diff --git a/packages/app/e2e/settings/settings-memory.spec.ts b/packages/app/e2e/settings/settings-memory.spec.ts
new file mode 100644
index 000000000..0a36ab0d5
--- /dev/null
+++ b/packages/app/e2e/settings/settings-memory.spec.ts
@@ -0,0 +1,113 @@
+import { test, expect } from "../fixtures"
+import { closeSettingsPanel, openSettings, withSession } from "../actions"
+
+test("@smoke memory settings exposes the raw MEMORY.md controls", async ({ page, project }) => {
+  await project.open()
+  await project.sdk.memory.reset()
+
+  const settings = await openSettings(page)
+  await settings.getByRole("tab", { name: "Memory" }).click()
+
+  await expect(settings.getByRole("heading", { level: 2, name: "Memory" })).toBeVisible()
+  await expect(settings.getByText("Enable memory")).toBeVisible()
+  await expect(settings.getByText("Raw MEMORY.md", { exact: true })).toBeVisible()
+
+  const raw = settings.locator('[data-action="settings-memory-raw"]')
+  await expect(raw).toBeVisible()
+  await expect(raw).toHaveValue(/# PawWork Memory/)
+  await expect(raw).toHaveValue(/## Profile/)
+  await expect(raw).toHaveValue(/## Archive/)
+
+  const next = [
+    "# PawWork Memory",
+    "",
+    "## Profile",
+    "- e2e memory settings profile",
+    "",
+    "## Archive",
+    "",
+  ].join("\n")
+
+  await raw.fill(next)
+  await settings.getByRole("button", { name: "Save" }).click()
+
+  await expect
+    .poll(async () => {
+      const state = await project.sdk.memory.get().then((response) => response.data as { content?: string })
+      return state.content ?? ""
+    })
+    .toContain("e2e memory settings profile")
+})
+
+test("idle session shows memory review and saves redacted entries", async ({ page, project }) => {
+  await project.open()
+  await project.sdk.memory.reset()
+  await project.sdk.memory.disabled({ memoryDisabledInput: { disabled: false } })
+
+  await withSession(project.sdk, "memory review e2e", async (session) => {
+    project.trackSession(session.id)
+    await project.gotoSession(session.id)
+
+    const review = page.locator('[data-component="session-memory-review"]')
+    await expect(review).toBeVisible()
+    await expect(review.getByText("Remember this session?")).toBeVisible()
+
+    await review.locator('[data-action="session-memory-review-text"]').fill("Remember sk-test-secret from this session")
+    await review.getByRole("button", { name: "Save memory" }).click()
+
+    await expect(review).toBeHidden()
+    await expect
+      .poll(async () => {
+        const state = await project.sdk.memory.get().then((response) => response.data as { content?: string })
+        return state.content ?? ""
+      })
+      .toContain("[REDACTED]")
+
+    const state = await project.sdk.memory.get().then((response) => response.data as { content?: string })
+    expect(state.content ?? "").not.toContain("sk-test-secret")
+  })
+})
+
+test("disabled memory hides the idle session review surface", async ({ page, project }) => {
+  await project.open()
+  await project.sdk.memory.reset()
+  await project.sdk.memory.disabled({ memoryDisabledInput: { disabled: true } })
+  try {
+    await project.sdk.memory.acceptProposal({ memoryProposalInput: { text: "Should not be saved.", scope: "project" } })
+    throw new Error("expected disabled memory proposal to be blocked")
+  } catch (error) {
+    expect((error as { error?: string }).error).toBe("memory_disabled")
+  }
+
+  try {
+    await withSession(project.sdk, "disabled memory review e2e", async (session) => {
+      project.trackSession(session.id)
+      await project.gotoSession(session.id)
+
+      await expect(page.locator('[data-component="session-memory-review"]')).toBeHidden()
+    })
+  } finally {
+    await project.sdk.memory.disabled({ memoryDisabledInput: { disabled: false } })
+  }
+})
+
+test("turning memory off hides an already visible session review surface", async ({ page, project }) => {
+  await project.open()
+  await project.sdk.memory.reset()
+  await project.sdk.memory.disabled({ memoryDisabledInput: { disabled: false } })
+
+  await withSession(project.sdk, "memory review toggle e2e", async (session) => {
+    project.trackSession(session.id)
+    await project.gotoSession(session.id)
+
+    const review = page.locator('[data-component="session-memory-review"]')
+    await expect(review).toBeVisible()
+
+    const settings = await openSettings(page)
+    await settings.getByRole("tab", { name: "Memory" }).click()
+    await settings.locator('[data-slot="switch-control"]').click()
+    await closeSettingsPanel(page, settings)
+
+    await expect(review).toBeHidden()
+  })
+})
diff --git a/packages/app/src/components/memory/memory-state-sync.ts b/packages/app/src/components/memory/memory-state-sync.ts
new file mode 100644
index 000000000..82a275eca
--- /dev/null
+++ b/packages/app/src/components/memory/memory-state-sync.ts
@@ -0,0 +1,9 @@
+import { createSignal } from "solid-js"
+
+const [memoryStateVersion, setMemoryStateVersion] = createSignal(0)
+
+export { memoryStateVersion }
+
+export function notifyMemoryStateChanged() {
+  setMemoryStateVersion((version) => version + 1)
+}
diff --git a/packages/app/src/components/memory/session-memory-review.tsx b/packages/app/src/components/memory/session-memory-review.tsx
new file mode 100644
index 000000000..ba8fbf9ca
--- /dev/null
+++ b/packages/app/src/components/memory/session-memory-review.tsx
@@ -0,0 +1,136 @@
+import { Button } from "@opencode-ai/ui/button"
+import { showToast } from "@opencode-ai/ui/toast"
+import { createEffect, createResource, createSignal, Show } from "solid-js"
+import { useLanguage } from "@/context/language"
+import { useSDK } from "@/context/sdk"
+import { memoryStateVersion } from "./memory-state-sync"
+
+type MemoryState = {
+  disabled?: boolean
+  status?: "ok" | "safe_mode"
+}
+
+type MemoryError = {
+  error?: string
+  reason?: string
+}
+
+const errorMessage = (error: unknown, fallback: string) => (error instanceof Error ? error.message : fallback)
+
+const memoryError = (value: unknown): MemoryError | undefined => {
+  if (!value || typeof value !== "object") return undefined
+  if ("error" in value || "reason" in value) return value as MemoryError
+  if ("data" in value) return memoryError((value as { data?: unknown }).data)
+  return undefined
+}
+
+export function SessionMemoryReview(props: { sessionID?: string; visible: boolean }) {
+  const language = useLanguage()
+  const sdk = useSDK()
+  const [draft, setDraft] = createSignal("")
+  const [dismissed, setDismissed] = createSignal(false)
+  const [saving, setSaving] = createSignal(false)
+  const [reviewState] = createResource(
+    () => (props.visible && props.sessionID ? { sessionID: props.sessionID, version: memoryStateVersion() } : undefined),
+    async () => {
+      const result = await sdk.client.memory.reviewState()
+      return (result.data ?? {}) as MemoryState
+    },
+  )
+
+  const show = () => props.visible && !dismissed() && reviewState.latest?.disabled === false && reviewState.latest?.status === "ok"
+
+  createEffect(() => {
+    props.sessionID
+    setDraft("")
+    setDismissed(false)
+  })
+
+  const accept = async () => {
+    const text = draft().trim()
+    if (!text || saving()) return
+    setSaving(true)
+    try {
+      const result = await sdk.client.memory.acceptProposal({ memoryProposalInput: { text, scope: "project" } })
+      const blocked = memoryError(result.error)
+      if (blocked?.error === "memory_disabled" || blocked?.error === "memory_safe_mode") {
+        setDraft("")
+        setDismissed(true)
+        showToast({
+          variant: "subtle",
+          title: language.t("memory.review.blocked"),
+          description: language.t(blocked.error === "memory_disabled" ? "memory.review.blockedDisabled" : "memory.review.blockedSafeMode"),
+        })
+        return
+      }
+      const state = (result.data ?? {}) as MemoryState
+      if (state.disabled || state.status === "safe_mode") {
+        setDraft("")
+        setDismissed(true)
+        showToast({
+          variant: "subtle",
+          title: language.t("memory.review.blocked"),
+          description: language.t(state.disabled ? "memory.review.blockedDisabled" : "memory.review.blockedSafeMode"),
+        })
+        return
+      }
+      setDraft("")
+      setDismissed(true)
+      showToast({
+        variant: "success",
+        title: language.t("memory.review.saved"),
+        description: language.t("memory.review.savedDescription"),
+      })
+    } catch (error) {
+      const blocked = memoryError(error)
+      if (blocked?.error === "memory_disabled" || blocked?.error === "memory_safe_mode") {
+        setDraft("")
+        setDismissed(true)
+        showToast({
+          variant: "subtle",
+          title: language.t("memory.review.blocked"),
+          description: language.t(blocked.error === "memory_disabled" ? "memory.review.blockedDisabled" : "memory.review.blockedSafeMode"),
+        })
+        return
+      }
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: errorMessage(error, language.t("common.requestFailed")),
+      })
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <Show when={show()}>
+      <section
+        data-component="session-memory-review"
+        class="mx-3 mb-2 rounded-lg border border-border bg-bg-panel p-3 shadow-sm"
+      >
+        <div class="mb-2 text-13-medium text-fg-strong">{language.t("memory.review.title")}</div>
+        <textarea
+          data-action="session-memory-review-text"
+          class="min-h-[72px] w-full rounded border border-border bg-bg-base p-2 text-13-regular text-fg-strong"
+          value={draft()}
+          placeholder={language.t("memory.review.placeholder")}
+          onInput={(event) => setDraft(event.currentTarget.value)}
+        />
+        <div class="mt-2 flex justify-end gap-2">
+          <Button
+            size="small"
+            onClick={() => {
+              setDismissed(true)
+            }}
+          >
+            {language.t("memory.review.dismiss")}
+          </Button>
+          <Button size="small" variant="primary" onClick={accept} disabled={!draft().trim() || saving()}>
+            {language.t("memory.review.accept")}
+          </Button>
+        </div>
+      </section>
+    </Show>
+  )
+}
diff --git a/packages/app/src/components/settings-memory.test.ts b/packages/app/src/components/settings-memory.test.ts
new file mode 100644
index 000000000..e6e3ed43e
--- /dev/null
+++ b/packages/app/src/components/settings-memory.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test"
+import { readFileSync } from "node:fs"
+
+describe("memory settings source contract", () => {
+  test("registers the Memory settings tab", () => {
+    const page = readFileSync("src/components/settings-page.tsx", "utf8")
+
+    expect(page).toContain('"memory"')
+    expect(page).toContain("SettingsMemory")
+    expect(page).toContain("settings.tab.memory")
+  })
+
+  test("keeps the v1 raw controls", () => {
+    const settings = readFileSync("src/components/settings-memory.tsx", "utf8")
+
+    expect(settings).toContain("settings-memory-raw")
+    expect(settings).toContain("memory.disabled")
+    expect(settings).not.toContain("settings-memory-delete-id")
+  })
+})
diff --git a/packages/app/src/components/settings-memory.tsx b/packages/app/src/components/settings-memory.tsx
new file mode 100644
index 000000000..658c995da
--- /dev/null
+++ b/packages/app/src/components/settings-memory.tsx
@@ -0,0 +1,143 @@
+import { Button } from "@opencode-ai/ui/button"
+import { Switch } from "@opencode-ai/ui/switch"
+import { showToast } from "@opencode-ai/ui/toast"
+import { createResource, createSignal, Show } from "solid-js"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useLanguage } from "@/context/language"
+import { notifyMemoryStateChanged } from "./memory/memory-state-sync"
+import { SettingsList } from "./settings-list"
+
+type MemoryState = {
+  path?: string
+  disabled?: boolean
+  status?: "ok" | "safe_mode"
+  reason?: string
+  content?: string
+  profileTooLarge?: boolean
+}
+
+const errorMessage = (error: unknown, fallback: string) => (error instanceof Error ? error.message : fallback)
+
+export function SettingsMemory(props: { directory?: string }) {
+  const language = useLanguage()
+  const globalSDK = useGlobalSDK()
+  const client = () => globalSDK.createClient({ directory: props.directory, throwOnError: true })
+  const [draft, setDraft] = createSignal("")
+  const [state, actions] = createResource(async () => {
+    try {
+      const result = await client().memory.get()
+      const data = (result.data ?? {}) as MemoryState
+      setDraft(data.content ?? "")
+      return data
+    } catch (error) {
+      setDraft("")
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: errorMessage(error, language.t("common.requestFailed")),
+      })
+      throw error
+    }
+  })
+
+  const refresh = () => void actions.refetch()
+
+  const save = async () => {
+    try {
+      await client().memory.update({ memoryRawInput: { content: draft() } })
+      showToast({ variant: "success", title: language.t("settings.memory.saved") })
+      refresh()
+    } catch (error) {
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: errorMessage(error, language.t("common.requestFailed")),
+      })
+    }
+  }
+
+  const reset = async () => {
+    if (!window.confirm(language.t("settings.memory.resetConfirm"))) return
+    try {
+      await client().memory.reset()
+      showToast({ variant: "success", title: language.t("settings.memory.resetDone") })
+      refresh()
+    } catch (error) {
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: errorMessage(error, language.t("common.requestFailed")),
+      })
+    }
+  }
+
+  const toggle = async (enabled: boolean) => {
+    try {
+      await client().memory.disabled({ memoryDisabledInput: { disabled: !enabled } })
+      notifyMemoryStateChanged()
+      refresh()
+    } catch (error) {
+      showToast({
+        variant: "error",
+        title: language.t("common.requestFailed"),
+        description: errorMessage(error, language.t("common.requestFailed")),
+      })
+    }
+  }
+
+  return (
+    <div class="py-4">
+      <SettingsList>
+        <section class="flex flex-col gap-1 border-b border-border-weak py-3">
+          <h2 class="text-16-medium text-fg-strong">{language.t("settings.memory.title")}</h2>
+          <p class="text-13-regular text-fg-weak">{language.t("settings.memory.description")}</p>
+          <Show when={state.latest?.path}>
+            <p class="text-12-regular text-fg-weaker">{state.latest?.path}</p>
+          </Show>
+        </section>
+
+        <section class="flex flex-wrap items-center gap-4 border-b border-border-weak py-3 sm:flex-nowrap">
+          <div class="min-w-0 flex-1">
+            <div class="text-13-medium text-fg-strong">{language.t("settings.memory.enabled.title")}</div>
+            <div class="text-13-regular text-fg-weak">{language.t("settings.memory.enabled.description")}</div>
+          </div>
+          <Switch checked={!state.latest?.disabled} onChange={toggle} />
+        </section>
+
+        <Show when={state.latest?.status === "safe_mode"}>
+          <section class="rounded border border-danger/40 bg-danger/5 p-3 text-13-regular text-danger">
+            {language.t("settings.memory.safeMode", { reason: state.latest?.reason ?? "" })}
+          </section>
+        </Show>
+
+        <Show when={state.latest?.profileTooLarge}>
+          <section class="rounded border border-border bg-bg-panel p-3 text-13-regular text-fg-weak">
+            {language.t("settings.memory.profileTooLarge")}
+          </section>
+        </Show>
+
+        <section class="flex flex-col gap-3 py-3">
+          <div>
+            <div class="text-13-medium text-fg-strong">{language.t("settings.memory.raw.title")}</div>
+            <div class="text-13-regular text-fg-weak">{language.t("settings.memory.raw.description")}</div>
+          </div>
+          <textarea
+            data-action="settings-memory-raw"
+            class="min-h-[360px] w-full rounded border border-border bg-bg-panel p-3 font-mono text-13-regular text-fg-strong"
+            value={draft()}
+            spellcheck={false}
+            onInput={(event) => setDraft(event.currentTarget.value)}
+          />
+          <div class="flex gap-2">
+            <Button variant="primary" onClick={save} disabled={state.loading}>
+              {language.t("common.save")}
+            </Button>
+            <Button onClick={reset} disabled={state.loading}>
+              {language.t("settings.memory.reset")}
+            </Button>
+          </div>
+        </section>
+      </SettingsList>
+    </div>
+  )
+}
diff --git a/packages/app/src/components/settings-page.tsx b/packages/app/src/components/settings-page.tsx
index 298c963d2..19dfb90e0 100644
--- a/packages/app/src/components/settings-page.tsx
+++ b/packages/app/src/components/settings-page.tsx
@@ -15,14 +15,16 @@ function focusablesIn(root: HTMLElement): HTMLElement[] {
 }
 import { SettingsGeneral } from "./settings-general"
 import { SettingsKeybinds } from "./settings-keybinds"
+import { SettingsMemory } from "./settings-memory"
 import { SettingsModels } from "./settings-models"
 import { SettingsProviders } from "./settings-providers"
 import { SettingsWorktrees } from "./settings-worktrees"
 
-export type SettingsPageTab = "general" | "shortcuts" | "providers" | "models" | "worktrees"
+export type SettingsPageTab = "general" | "shortcuts" | "providers" | "models" | "worktrees" | "memory"
 
 export const SettingsPage: Component<{
   active: SettingsPageTab
+  directory?: string
   onSelect: (value: SettingsPageTab) => void
   onClose: () => void
 }> = (props) => {
@@ -92,7 +94,8 @@ export const SettingsPage: Component<{
             value !== "shortcuts" &&
             value !== "providers" &&
             value !== "models" &&
-            value !== "worktrees"
+            value !== "worktrees" &&
+            value !== "memory"
           )
             return
           props.onSelect(value)
@@ -128,6 +131,10 @@ export const SettingsPage: Component<{
                       <Icon name="keyboard" />
                       {language.t("settings.tab.shortcuts")}
                     </Tabs.Trigger>
+                    <Tabs.Trigger value="memory">
+                      <Icon name="archive" />
+                      {language.t("settings.tab.memory")}
+                    </Tabs.Trigger>
                   </div>
                 </div>
 
@@ -167,6 +174,11 @@ export const SettingsPage: Component<{
             <SettingsKeybinds />
           </div>
         </Tabs.Content>
+        <Tabs.Content value="memory" class="no-scrollbar">
+          <div class="mx-auto w-full max-w-[760px]">
+            <SettingsMemory directory={props.directory} />
+          </div>
+        </Tabs.Content>
         <Tabs.Content value="providers" class="no-scrollbar">
           <div class="mx-auto w-full max-w-[760px]">
             <SettingsProviders />
diff --git a/packages/app/src/i18n/en.ts b/packages/app/src/i18n/en.ts
index 121fc3192..872c85a37 100644
--- a/packages/app/src/i18n/en.ts
+++ b/packages/app/src/i18n/en.ts
@@ -845,7 +845,29 @@ export const dict = {
   "settings.section.server": "Server",
   "settings.tab.general": "General",
   "settings.tab.shortcuts": "Shortcuts",
+  "settings.tab.memory": "Memory",
   "settings.tab.worktrees": "Worktrees",
+  "settings.memory.title": "Memory",
+  "settings.memory.description": "Review what PawWork remembers and edit the raw MEMORY.md file.",
+  "settings.memory.enabled.title": "Enable memory",
+  "settings.memory.enabled.description": "When off, PawWork does not read, search, draft, or write memory.",
+  "settings.memory.safeMode": "Memory is in safe mode. Reason: {{reason}}. Reset to template or fix the file manually.",
+  "settings.memory.profileTooLarge": "Profile is larger than the v1 soft limit. Keep it short because it loads at session start.",
+  "settings.memory.raw.title": "Raw MEMORY.md",
+  "settings.memory.raw.description": "Profile updates in v1 are made here. Archive entries are searched only when needed.",
+  "settings.memory.saved": "Memory saved",
+  "settings.memory.reset": "Reset to template",
+  "settings.memory.resetConfirm": "This will overwrite MEMORY.md. The previous file is saved as a backup. Continue?",
+  "settings.memory.resetDone": "Memory reset",
+  "memory.review.title": "Remember this session?",
+  "memory.review.placeholder": "Write one approved memory from this session...",
+  "memory.review.accept": "Save memory",
+  "memory.review.dismiss": "Dismiss",
+  "memory.review.saved": "Memory saved",
+  "memory.review.savedDescription": "Saved entry was re-read from MEMORY.md after redaction.",
+  "memory.review.blocked": "Memory was not saved",
+  "memory.review.blockedDisabled": "Memory is disabled.",
+  "memory.review.blockedSafeMode": "Memory is in safe mode. Reset to template or fix MEMORY.md manually.",
   "settings.worktrees.title": "Worktrees",
   "settings.worktrees.description": "Worktrees PawWork has created or registered. An active session keeps its worktree bound; run ExitWorktree before you can delete it.",
   "settings.worktrees.empty.title": "No worktrees yet",
diff --git a/packages/app/src/i18n/zh.ts b/packages/app/src/i18n/zh.ts
index d0699a903..f38319401 100644
--- a/packages/app/src/i18n/zh.ts
+++ b/packages/app/src/i18n/zh.ts
@@ -734,7 +734,29 @@ export const dict = {
 
   "settings.tab.general": "通用",
   "settings.tab.shortcuts": "快捷键",
+  "settings.tab.memory": "记忆",
   "settings.tab.worktrees": "工作树",
+  "settings.memory.title": "记忆",
+  "settings.memory.description": "查看爪印记住了什么，并编辑原始 MEMORY.md 文件。",
+  "settings.memory.enabled.title": "启用记忆",
+  "settings.memory.enabled.description": "关闭后，爪印不会读取、搜索、草拟或写入记忆。",
+  "settings.memory.safeMode": "记忆处于安全模式。原因：{{reason}}。请重置模板或手动修复文件。",
+  "settings.memory.profileTooLarge": "Profile 超过 v1 建议大小。它会在会话启动时加载，建议保持很短。",
+  "settings.memory.raw.title": "原始 MEMORY.md",
+  "settings.memory.raw.description": "v1 中 Profile 更新通过这里手动编辑。Archive 只在需要时搜索。",
+  "settings.memory.saved": "记忆已保存",
+  "settings.memory.reset": "重置为模板",
+  "settings.memory.resetConfirm": "这会覆盖 MEMORY.md。旧文件会先备份。继续吗？",
+  "settings.memory.resetDone": "记忆已重置",
+  "memory.review.title": "要记住这次会话吗？",
+  "memory.review.placeholder": "写一条本次会话确认要保存的记忆...",
+  "memory.review.accept": "保存记忆",
+  "memory.review.dismiss": "跳过",
+  "memory.review.saved": "记忆已保存",
+  "memory.review.savedDescription": "保存后已从 MEMORY.md 重新读取，敏感内容会被打码。",
+  "memory.review.blocked": "记忆未保存",
+  "memory.review.blockedDisabled": "记忆已关闭。",
+  "memory.review.blockedSafeMode": "记忆处于安全模式。请重置模板或手动修复 MEMORY.md。",
   "settings.worktrees.title": "工作树",
   "settings.worktrees.description": "爪印创建或登记过的工作树。正在使用中的会话会保持绑定，先调用 ExitWorktree 才能删除。",
   "settings.worktrees.empty.title": "还没有工作树",
diff --git a/packages/app/src/pages/layout.tsx b/packages/app/src/pages/layout.tsx
index 47b849305..57c68fa9a 100644
--- a/packages/app/src/pages/layout.tsx
+++ b/packages/app/src/pages/layout.tsx
@@ -2295,7 +2295,12 @@ export default function Layout(props: ParentProps) {
                     </div>
                     <Show when={settingsOpen()}>
                       <div class="absolute inset-0 z-40">
-                        <SettingsPage active={settingsTab()} onSelect={setSettingsTab} onClose={closeSettings} />
+                        <SettingsPage
+                          active={settingsTab()}
+                          directory={currentProject()?.worktree ?? currentDir()}
+                          onSelect={setSettingsTab}
+                          onClose={closeSettings}
+                        />
                       </div>
                     </Show>
                   </div>
diff --git a/packages/app/src/pages/session.tsx b/packages/app/src/pages/session.tsx
index 87e5b4c92..7c589311c 100644
--- a/packages/app/src/pages/session.tsx
+++ b/packages/app/src/pages/session.tsx
@@ -655,6 +655,7 @@ export default function Page() {
       anchor={timelineInteraction.anchor}
       onRetryOpenSession={retryOpenRouteSession}
       onOpenNewSession={openNewRouteSession}
+      memoryReviewVisible={!!timelineSessionID() && !timelineRunning()}
       composerSession={renderComposerRegion("session")}
       composerHome={(ctx) => renderComposerRegion("home", ctx)}
       canReview={canReview}
diff --git a/packages/app/src/pages/session/session-main-view.tsx b/packages/app/src/pages/session/session-main-view.tsx
index 807674d63..5910a3815 100644
--- a/packages/app/src/pages/session/session-main-view.tsx
+++ b/packages/app/src/pages/session/session-main-view.tsx
@@ -1,6 +1,7 @@
 import { Match, Show, Switch, type ComponentProps, type JSX } from "solid-js"
 import { Tabs } from "@opencode-ai/ui/tabs"
 import { NewSessionView, SessionHeader } from "@/components/session"
+import { SessionMemoryReview } from "@/components/memory/session-memory-review"
 import type { PawworkSkillName } from "@/components/session/pawwork-skill-meta"
 import type { useLanguage } from "@/context/language"
 import type { createSizing } from "@/pages/session/helpers"
@@ -46,6 +47,7 @@ export function SessionMainView(props: {
   anchor: TimelineProps["anchor"]
   onRetryOpenSession: () => void
   onOpenNewSession: () => void
+  memoryReviewVisible: boolean
   composerSession: JSX.Element
   composerHome: (ctx: {
     onModeChange: (mode: "normal" | "shell") => void
@@ -171,7 +173,10 @@ export function SessionMainView(props: {
               </Match>
             </Switch>
           </div>
-          <Show when={props.activeSessionID && !showSessionOpeningState()}>{props.composerSession}</Show>
+          <Show when={props.activeSessionID && !showSessionOpeningState()}>
+            <SessionMemoryReview sessionID={props.timelineSessionID} visible={props.memoryReviewVisible} />
+            {props.composerSession}
+          </Show>
         </div>
 
         <SessionSidePanel
diff --git a/packages/app/src/shell-frame-contract.test.ts b/packages/app/src/shell-frame-contract.test.ts
index 4cba7462e..9845e5efc 100644
--- a/packages/app/src/shell-frame-contract.test.ts
+++ b/packages/app/src/shell-frame-contract.test.ts
@@ -159,7 +159,10 @@ test("session composer is docked outside the scroll-clipped timeline region", ()
   expect(session).toContain('variant: "session" | "home"')
   expect(sessionMainView).toContain('<div class="flex-1 min-h-0 overflow-hidden">')
   expect(sessionMainView).toContain(
-    "</div>\n          <Show when={props.activeSessionID && !showSessionOpeningState()}>{props.composerSession}</Show>",
+    '<SessionMemoryReview sessionID={props.timelineSessionID} visible={props.memoryReviewVisible} />',
+  )
+  expect(sessionMainView).toContain(
+    "</div>\n          <Show when={props.activeSessionID && !showSessionOpeningState()}>",
   )
   expect(messageTimeline).toContain('"padding-bottom": "calc(var(--composer-dock-height, 0px) + 32px)"')
 })
diff --git a/packages/core/src/pawwork-home.ts b/packages/core/src/pawwork-home.ts
index a49ac57bd..dc65cd02f 100644
--- a/packages/core/src/pawwork-home.ts
+++ b/packages/core/src/pawwork-home.ts
@@ -94,6 +94,14 @@ export namespace PawWorkHome {
     return fileCandidates("AGENTS.md")
   }
 
+  export function memoryDir() {
+    return path.join(primary(), "memory")
+  }
+
+  export function memoryFile() {
+    return path.join(memoryDir(), "MEMORY.md")
+  }
+
   export function configFilesIn(dir: string) {
     return [path.join(dir, "pawwork.json"), path.join(dir, "pawwork.jsonc")]
   }
diff --git a/packages/opencode/src/memory/memory.ts b/packages/opencode/src/memory/memory.ts
new file mode 100644
index 000000000..b43304595
--- /dev/null
+++ b/packages/opencode/src/memory/memory.ts
@@ -0,0 +1,208 @@
+import crypto from "crypto"
+
+export namespace MemoryFile {
+  export type Scope = "user" | "project"
+  export type SafeModeReason =
+    | "missing_profile"
+    | "missing_archive"
+    | "duplicate_profile"
+    | "duplicate_archive"
+    | "sections_out_of_order"
+
+  export type Entry = {
+    id: string
+    createdAt: string
+    scope: Scope
+    appliesTo?: string
+    heading: string
+    body: string
+    raw: string
+  }
+
+  export type InvalidEntry = {
+    heading: string
+    raw: string
+    reason: string
+  }
+
+  export type ParseResult =
+    | {
+        status: "ok"
+        profile: string
+        archive: string
+        entries: Entry[]
+        invalidEntries: InvalidEntry[]
+        profileTooLarge: boolean
+      }
+    | { status: "safe_mode"; reason: SafeModeReason }
+
+  export type ProfileOnlyParseResult =
+    | {
+        status: "ok"
+        profile: string
+        profileTooLarge: boolean
+      }
+    | { status: "safe_mode"; reason: SafeModeReason }
+
+  const PROFILE_HEADING = "## Profile"
+  const ARCHIVE_HEADING = "## Archive"
+  export const PROFILE_CONTEXT_LIMIT = 2_000
+
+  export function defaultTemplate() {
+    return [
+      "# PawWork Memory",
+      "",
+      PROFILE_HEADING,
+      "",
+      "- PawWork Memory is enabled.",
+      "",
+      ARCHIVE_HEADING,
+      "",
+    ].join("\n")
+  }
+
+  export function makeID() {
+    return `mem_${crypto.randomUUID().replaceAll("-", "").slice(0, 16)}`
+  }
+
+  export function parse(input: string): ParseResult {
+    const sections = parseSections(input)
+    if (sections.status === "safe_mode") return sections
+
+    const { profileStart, archiveStart } = sections
+    const profileBodyStart = nextLineIndex(input, profileStart)
+    const archiveBodyStart = nextLineIndex(input, archiveStart)
+    const profile = input.slice(profileBodyStart, archiveStart).trim()
+    const archive = input.slice(archiveBodyStart).trim()
+    const { entries, invalidEntries } = parseEntries(archive)
+    return {
+      status: "ok",
+      profile,
+      archive,
+      entries,
+      invalidEntries,
+      profileTooLarge: profile.length > PROFILE_CONTEXT_LIMIT,
+    }
+  }
+
+  export function parseProfileOnly(input: string): ProfileOnlyParseResult {
+    const sections = parseSections(input)
+    if (sections.status === "safe_mode") return sections
+
+    const profileBodyStart = nextLineIndex(input, sections.profileStart)
+    const profile = input.slice(profileBodyStart, sections.archiveStart).trim()
+    return {
+      status: "ok",
+      profile,
+      profileTooLarge: profile.length > PROFILE_CONTEXT_LIMIT,
+    }
+  }
+
+  function parseSections(input: string):
+    | {
+        status: "ok"
+        profileStart: number
+        archiveStart: number
+      }
+    | { status: "safe_mode"; reason: SafeModeReason } {
+    const profileMatches = [...input.matchAll(/^## Profile\s*$/gm)]
+    const archiveMatches = [...input.matchAll(/^## Archive\s*$/gm)]
+    if (profileMatches.length === 0) return { status: "safe_mode", reason: "missing_profile" }
+    if (archiveMatches.length === 0) return { status: "safe_mode", reason: "missing_archive" }
+    if (profileMatches.length > 1) return { status: "safe_mode", reason: "duplicate_profile" }
+    if (archiveMatches.length > 1) return { status: "safe_mode", reason: "duplicate_archive" }
+
+    const profileStart = profileMatches[0]!.index!
+    const archiveStart = archiveMatches[0]!.index!
+    if (archiveStart < profileStart) return { status: "safe_mode", reason: "sections_out_of_order" }
+    return { status: "ok", profileStart, archiveStart }
+  }
+
+  export function formatEntry(input: {
+    id?: string
+    createdAt?: string
+    scope: Scope
+    appliesTo?: string
+    text: string
+  }) {
+    const id = input.id ?? makeID()
+    const createdAt = input.createdAt ?? new Date().toISOString()
+    const scope = input.scope === "project" ? `scope:project applies_to:${encodeURIComponent(input.appliesTo ?? "")}` : "scope:user"
+    return `### ${createdAt} id:${id} ${scope}\n${input.text.trim()}\n`
+  }
+
+  function nextLineIndex(input: string, start: number) {
+    const offset = input.slice(start).indexOf("\n")
+    return offset === -1 ? input.length : start + offset + 1
+  }
+
+  function parseEntries(archive: string): { entries: Entry[]; invalidEntries: InvalidEntry[] } {
+    const headingPattern = /^### \d{4}-\d{2}-\d{2}T[^\n]*\bid:[^\s]+[^\n]*$/gm
+    const headings = [...archive.matchAll(headingPattern)]
+    const chunks = headings
+      .map((match, index) => archive.slice(match.index!, headings[index + 1]?.index ?? archive.length))
+      .map((chunk) => chunk.trim())
+      .filter(Boolean)
+    const seen = new Set<string>()
+    const entries: Entry[] = []
+    const invalidEntries: InvalidEntry[] = []
+
+    for (const raw of chunks) {
+      const [heading = "", ...bodyLines] = raw.split("\n")
+      if (!heading.startsWith("### ")) continue
+      const parsed = parseHeading(heading)
+      if (!parsed.ok) {
+        invalidEntries.push({ heading, raw, reason: parsed.reason })
+        continue
+      }
+      if (seen.has(parsed.entry.id)) {
+        invalidEntries.push({ heading, raw, reason: "duplicate_id" })
+        continue
+      }
+      seen.add(parsed.entry.id)
+      const body = bodyLines.join("\n").trim()
+      entries.push({ ...parsed.entry, heading, body, raw })
+    }
+
+    return { entries, invalidEntries }
+  }
+
+  function parseHeading(
+    heading: string,
+  ): { ok: true; entry: Omit<Entry, "body" | "raw"> } | { ok: false; reason: string } {
+    const rest = heading.slice(4).trim()
+    const [createdAt, ...tokens] = rest.split(/\s+/)
+    if (!createdAt || Number.isNaN(Date.parse(createdAt))) return { ok: false, reason: "invalid_timestamp" }
+    const meta = Object.fromEntries(
+      tokens.map((token) => {
+        const index = token.indexOf(":")
+        return index === -1 ? [token, ""] : [token.slice(0, index), token.slice(index + 1)]
+      }),
+    )
+    const id = meta.id
+    if (!id) return { ok: false, reason: "missing_id" }
+    if (meta.scope !== "user" && meta.scope !== "project") return { ok: false, reason: "invalid_scope" }
+    if (meta.scope === "project" && !meta.applies_to) return { ok: false, reason: "missing_applies_to" }
+
+    const appliesTo = meta.applies_to
+      ? (() => {
+          try {
+            return decodeURIComponent(meta.applies_to)
+          } catch {
+            return meta.applies_to
+          }
+        })()
+      : undefined
+
+    return {
+      ok: true,
+      entry: {
+        id,
+        createdAt,
+        scope: meta.scope,
+        appliesTo,
+        heading,
+      },
+    }
+  }
+}
diff --git a/packages/opencode/src/memory/proposal.ts b/packages/opencode/src/memory/proposal.ts
new file mode 100644
index 000000000..4f19168b1
--- /dev/null
+++ b/packages/opencode/src/memory/proposal.ts
@@ -0,0 +1,42 @@
+import { MemoryFile } from "./memory"
+
+const SENSITIVE_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{8,}/g,
+  /ghp_[A-Za-z0-9_]{8,}/g,
+  /github_pat_[A-Za-z0-9_]{8,}/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\bpassword\s*[:=]\s*\S+/gi,
+]
+
+export namespace MemoryProposal {
+  export type Proposal = {
+    id: string
+    text: string
+    scope: MemoryFile.Scope
+    defaultSelected: boolean
+    warning?: string
+  }
+
+  export function redact(input: string) {
+    let text = input
+    let highRisk = false
+    for (const pattern of SENSITIVE_PATTERNS) {
+      pattern.lastIndex = 0
+      if (pattern.test(text)) highRisk = true
+      pattern.lastIndex = 0
+      text = text.replace(pattern, "[REDACTED]")
+    }
+    return { text, highRisk }
+  }
+
+  export function fromText(input: { text: string; scope?: MemoryFile.Scope }): Proposal {
+    const redacted = redact(input.text)
+    return {
+      id: MemoryFile.makeID(),
+      text: redacted.text,
+      scope: input.scope ?? "project",
+      defaultSelected: !redacted.highRisk,
+      warning: redacted.highRisk ? "Contains possible sensitive data." : undefined,
+    }
+  }
+}
diff --git a/packages/opencode/src/memory/service.ts b/packages/opencode/src/memory/service.ts
new file mode 100644
index 000000000..481ed0fb1
--- /dev/null
+++ b/packages/opencode/src/memory/service.ts
@@ -0,0 +1,180 @@
+import fs from "fs/promises"
+import path from "path"
+import { PawWorkHome } from "@opencode-ai/core/pawwork-home"
+import { MemoryFile } from "./memory"
+import { MemoryProposal } from "./proposal"
+
+export namespace MemoryService {
+  export type State = {
+    path: string
+    disabled: boolean
+    status: "ok" | "safe_mode"
+    reason?: MemoryFile.SafeModeReason
+    content: string
+    profile?: string
+    profileTooLarge?: boolean
+    invalidEntries?: MemoryFile.InvalidEntry[]
+  }
+
+  export type ProfileState = {
+    path: string
+    disabled: boolean
+    status: "ok" | "safe_mode"
+    reason?: MemoryFile.SafeModeReason
+    profile?: string
+    profileTooLarge?: boolean
+  }
+
+  const writeQueues = new Map<string, Promise<void>>()
+
+  async function enqueueWrite<T>(file: string, task: () => Promise<T>) {
+    const previous = writeQueues.get(file) ?? Promise.resolve()
+    const run = previous.catch(() => undefined).then(task)
+    writeQueues.set(
+      file,
+      run.then(
+        () => undefined,
+        () => undefined,
+      ),
+    )
+    return run
+  }
+
+  export function create(input?: { home?: string; workspacePath?: string }) {
+    const home = input?.home ?? PawWorkHome.primary()
+    const file = path.join(home, "memory", "MEMORY.md")
+    const disabledFile = path.join(home, "memory", ".disabled")
+    const workspacePath = input?.workspacePath ?? process.cwd()
+
+    async function ensure() {
+      await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
+      try {
+        await fs.access(file)
+      } catch {
+        await fs.writeFile(file, MemoryFile.defaultTemplate(), { mode: 0o600 })
+      }
+    }
+
+    async function isDisabled() {
+      try {
+        await fs.access(disabledFile)
+        return true
+      } catch {
+        return false
+      }
+    }
+
+    async function read(): Promise<State> {
+      await ensure()
+      const content = await fs.readFile(file, "utf8")
+      const disabled = await isDisabled()
+      const parsed = MemoryFile.parse(content)
+      if (parsed.status === "safe_mode") return { path: file, disabled, status: "safe_mode", reason: parsed.reason, content }
+      return {
+        path: file,
+        disabled,
+        status: "ok",
+        content,
+        profile: parsed.profile,
+        profileTooLarge: parsed.profileTooLarge,
+        invalidEntries: parsed.invalidEntries,
+      }
+    }
+
+    async function readProfile(): Promise<ProfileState> {
+      const disabled = await isDisabled()
+      if (disabled) return { path: file, disabled, status: "ok" }
+
+      await ensure()
+      const content = await fs.readFile(file, "utf8")
+      const parsed = MemoryFile.parseProfileOnly(content)
+      if (parsed.status === "safe_mode") return { path: file, disabled, status: "safe_mode", reason: parsed.reason }
+      return {
+        path: file,
+        disabled,
+        status: "ok",
+        profile: parsed.profile,
+        profileTooLarge: parsed.profileTooLarge,
+      }
+    }
+
+    async function writeAtomic(next: string) {
+      await ensure()
+      const previous = await fs.readFile(file, "utf8")
+      await fs.writeFile(`${file}.bak`, previous, { mode: 0o600 })
+      const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
+      await fs.writeFile(tmp, next, { mode: 0o600 })
+      await fs.rename(tmp, file)
+    }
+
+    async function saveRaw(next: string) {
+      const parsed = MemoryFile.parse(next)
+      if (parsed.status === "safe_mode") throw new Error(parsed.reason)
+      await enqueueWrite(file, () => writeAtomic(next))
+    }
+
+    async function resetToTemplate() {
+      await enqueueWrite(file, async () => {
+        await ensure()
+        const previous = await fs.readFile(file, "utf8")
+        await fs.writeFile(`${file}.broken.bak`, previous, { mode: 0o600 })
+        await writeAtomic(MemoryFile.defaultTemplate())
+      })
+    }
+
+    async function deleteEntry(id: string) {
+      await enqueueWrite(file, async () => {
+        const state = await read()
+        const parsed = MemoryFile.parse(state.content)
+        if (parsed.status !== "ok") throw new Error("Memory is in safe mode")
+        const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        const next = state.content.replace(
+          new RegExp(`\\n?### \\d{4}-\\d{2}-\\d{2}T[^\\n]*\\bid:${escaped}(?:\\s|$)[\\s\\S]*?(?=\\n### \\d{4}-\\d{2}-\\d{2}T[^\\n]*\\bid:|$)`),
+          "",
+        )
+        if (next === state.content) throw new Error(`Memory entry not found: ${id}`)
+        await writeAtomic(next.trimEnd() + "\n")
+      })
+    }
+
+    async function setDisabled(value: boolean) {
+      await enqueueWrite(file, async () => {
+        await fs.mkdir(path.dirname(disabledFile), { recursive: true, mode: 0o700 })
+        if (value) await fs.writeFile(disabledFile, "disabled\n", { mode: 0o600 })
+        else await fs.rm(disabledFile, { force: true })
+      })
+    }
+
+    async function appendAcceptedProposal(input: { text: string; scope: MemoryFile.Scope }) {
+      return enqueueWrite(file, async () => {
+        const state = await read()
+        if (state.disabled) throw new Error("Memory is disabled")
+        const parsed = MemoryFile.parse(state.content)
+        if (parsed.status !== "ok") throw new Error("Memory is in safe mode")
+        const redacted = MemoryProposal.redact(input.text)
+        const entry = MemoryFile.formatEntry({
+          scope: input.scope,
+          appliesTo: input.scope === "project" ? workspacePath : undefined,
+          text: redacted.text,
+        })
+        await writeAtomic(`${state.content.trimEnd()}\n\n${entry}`)
+        return entry
+      })
+    }
+
+    return {
+      isDisabled,
+      read,
+      readProfile,
+      saveRaw,
+      resetToTemplate,
+      deleteEntry,
+      setDisabled,
+      appendAcceptedProposal,
+    }
+  }
+
+  export function createForTest(input: { home: string; workspacePath: string }) {
+    return create(input)
+  }
+}
diff --git a/packages/opencode/src/server/instance/index.ts b/packages/opencode/src/server/instance/index.ts
index cff7e31b8..ca9cf1a9c 100644
--- a/packages/opencode/src/server/instance/index.ts
+++ b/packages/opencode/src/server/instance/index.ts
@@ -25,6 +25,7 @@ import { ConfigRoutes } from "./config"
 import { ExperimentalRoutes } from "./experimental"
 import { ProviderRoutes } from "./provider"
 import { EventRoutes } from "./event"
+import { MemoryRoutes } from "./memory"
 import { WorkspaceRouterMiddleware } from "./middleware"
 import { AppRuntime } from "@/effect/app-runtime"
 
@@ -40,6 +41,7 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono =>
     .route("/question", QuestionRoutes())
     .route("/blocker", BlockerRoutes())
     .route("/provider", ProviderRoutes())
+    .route("/memory", MemoryRoutes())
     .route("/", FileRoutes())
     .route("/", EventRoutes())
     .route("/mcp", McpRoutes())
diff --git a/packages/opencode/src/server/instance/memory.ts b/packages/opencode/src/server/instance/memory.ts
new file mode 100644
index 000000000..6036a1c3b
--- /dev/null
+++ b/packages/opencode/src/server/instance/memory.ts
@@ -0,0 +1,130 @@
+import { Hono } from "hono"
+import { describeRoute, resolver, validator } from "hono-openapi"
+import z from "zod"
+import { Instance } from "@/project/instance"
+import { MemoryService } from "@/memory/service"
+
+const MemoryRawInput = z.object({ content: z.string() }).meta({ ref: "MemoryRawInput" })
+const MemoryDisabledInput = z.object({ disabled: z.boolean() }).meta({ ref: "MemoryDisabledInput" })
+const MemoryProposalInput = z
+  .object({
+    text: z.string(),
+    scope: z.enum(["user", "project"]),
+  })
+  .meta({ ref: "MemoryProposalInput" })
+
+const MemoryState = z.any().meta({ ref: "MemoryState" })
+
+function service() {
+  return MemoryService.create({ workspacePath: Instance.directory })
+}
+
+export const MemoryRoutes = () =>
+  new Hono()
+    .get(
+      "/",
+      describeRoute({
+        summary: "Get PawWork memory",
+        operationId: "memory.get",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      async (c) => c.json(await service().read()),
+    )
+    .get(
+      "/review-state",
+      describeRoute({
+        summary: "Get PawWork memory review availability",
+        operationId: "memory.reviewState",
+        responses: {
+          200: { description: "Memory review state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      async (c) => c.json(await service().readProfile()),
+    )
+    .patch(
+      "/",
+      describeRoute({
+        summary: "Update raw PawWork memory",
+        operationId: "memory.update",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+          400: { description: "Invalid memory file" },
+        },
+      }),
+      validator("json", MemoryRawInput),
+      async (c) => {
+        try {
+          await service().saveRaw(c.req.valid("json").content)
+          return c.json(await service().read())
+        } catch (error) {
+          return c.json({ error: "invalid_memory_file", reason: error instanceof Error ? error.message : String(error) }, 400)
+        }
+      },
+    )
+    .post(
+      "/reset",
+      describeRoute({
+        summary: "Reset PawWork memory",
+        operationId: "memory.reset",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      async (c) => {
+        await service().resetToTemplate()
+        return c.json(await service().read())
+      },
+    )
+    .patch(
+      "/disabled",
+      describeRoute({
+        summary: "Disable or enable PawWork memory",
+        operationId: "memory.disabled",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      validator("json", MemoryDisabledInput),
+      async (c) => {
+        await service().setDisabled(c.req.valid("json").disabled)
+        return c.json(await service().read())
+      },
+    )
+    .delete(
+      "/entry/:id",
+      describeRoute({
+        summary: "Delete PawWork memory entry",
+        operationId: "memory.deleteEntry",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      async (c) => {
+        await service().deleteEntry(c.req.param("id"))
+        return c.json(await service().read())
+      },
+    )
+    .post(
+      "/proposal/accept",
+      describeRoute({
+        summary: "Accept PawWork memory proposal",
+        operationId: "memory.acceptProposal",
+        responses: {
+          200: { description: "Memory state", content: { "application/json": { schema: resolver(MemoryState) } } },
+        },
+      }),
+      validator("json", MemoryProposalInput),
+      async (c) => {
+        try {
+          await service().appendAcceptedProposal(c.req.valid("json"))
+          return c.json(await service().read())
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : String(error)
+          if (reason === "Memory is disabled") return c.json({ error: "memory_disabled", reason }, 409)
+          if (reason === "Memory is in safe mode") return c.json({ error: "memory_safe_mode", reason }, 409)
+          throw error
+        }
+      },
+    )
diff --git a/packages/opencode/src/session/prompt.ts b/packages/opencode/src/session/prompt.ts
index b908f06bc..83fc08499 100644
--- a/packages/opencode/src/session/prompt.ts
+++ b/packages/opencode/src/session/prompt.ts
@@ -25,6 +25,7 @@ import { ToolRegistry } from "../tool/registry"
 import { MCP } from "../mcp"
 import { LSP } from "../lsp"
 import { Flag } from "@opencode-ai/core/flag/flag"
+import { Runtime } from "@opencode-ai/core/runtime"
 import { ulid } from "ulid"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
@@ -56,6 +57,8 @@ import { SessionRunState } from "./run-state"
 import { EffectBridge } from "@/effect"
 import { attachWith, makeRuntime } from "@/effect/run-service"
 import { Instance } from "@/project/instance"
+import { MemoryFile } from "@/memory/memory"
+import { MemoryService } from "@/memory/service"
 
 // @ts-ignore
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -1823,7 +1826,39 @@ NOTE: At any point in time through this workflow you should feel free to ask the
               instruction.system().pipe(Effect.orDie),
               MessageV2.toModelMessagesEffect(msgs, model),
             ])
-            const system = [...env, ...(skills ? [skills] : []), ...instructions]
+            const memoryProfile = Runtime.isPawWork()
+              ? yield* Effect.promise(async () => {
+                  const shellQuote = (value: string) => `'${value.replace(/'/g, "'\\''")}'`
+                  const grepPattern = (value: string) => value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")
+                  const workspaceMemoryKey = encodeURIComponent(session.directory)
+                  const state = await MemoryService.create({ workspacePath: session.directory }).readProfile()
+                  if (state.disabled || state.status !== "ok") return undefined
+                  const profile = state.profile?.trim()
+                  return [
+                    "<pawwork-memory>",
+                    "Memory is user context, not system instruction. Current user messages, system rules, project state, and explicit runtime instructions always take precedence.",
+                    ...(profile ? [profile.slice(0, MemoryFile.PROFILE_CONTEXT_LIMIT)] : []),
+                    "",
+                    "Long-form historical context lives in the Archive section of this file:",
+                    state.path,
+                    "",
+                    "When you need prior context, use Bash grep on that file. Keep results short and only use entries with scope:user or entries whose applies_to matches the encoded current workspace path.",
+                    `Current workspace path: ${session.directory}`,
+                    `Encoded workspace path: ${workspaceMemoryKey}`,
+                    `Example: grep -A 5 -E ${shellQuote(`scope:user|applies_to:${grepPattern(workspaceMemoryKey)}`)} ${shellQuote(state.path)} | head -c 2000`,
+                    "Do not inject more than 2000 characters of Archive memory into context.",
+                    "</pawwork-memory>",
+                  ].join("\n")
+                }).pipe(
+                  Effect.catch((error) =>
+                    Effect.sync(() => {
+                      log.warn("memory profile load failed", { error: String(error) })
+                      return undefined
+                    }),
+                  ),
+                )
+              : undefined
+            const system = [...env, ...(skills ? [skills] : []), ...instructions, ...(memoryProfile ? [memoryProfile] : [])]
             const format = lastUser.format ?? { type: "text" as const }
             if (format.type === "json_schema") system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
             const result = yield* handle.process({
diff --git a/packages/opencode/test/config/e2e-smoke-tagging.test.ts b/packages/opencode/test/config/e2e-smoke-tagging.test.ts
index fe1cf9f96..501c43aac 100644
--- a/packages/opencode/test/config/e2e-smoke-tagging.test.ts
+++ b/packages/opencode/test/config/e2e-smoke-tagging.test.ts
@@ -16,6 +16,7 @@ const expectedSmokeTests = [
   "packages/app/e2e/prompt/first-message-reply.spec.ts:@smoke first replied message in a new session renders without page errors",
   "packages/app/e2e/prompt/prompt.spec.ts:@smoke can send a prompt and receive a reply",
   "packages/app/e2e/release-notes/release-notes-toast.spec.ts:@smoke shows subtle toast when stored version is older than current",
+  "packages/app/e2e/settings/settings-memory.spec.ts:@smoke memory settings exposes the raw MEMORY.md controls",
   "packages/app/e2e/settings/settings.spec.ts:@smoke PawWork settings opens as a full-pane surface, not a dialog",
   "packages/app/e2e/settings/settings.spec.ts:@smoke new installs start with the PawWork theme",
   "packages/app/e2e/settings/settings.spec.ts:@smoke settings dialog opens, switches tabs, closes",
diff --git a/packages/opencode/test/memory/pawwork-memory.test.ts b/packages/opencode/test/memory/pawwork-memory.test.ts
new file mode 100644
index 000000000..b87ffac0c
--- /dev/null
+++ b/packages/opencode/test/memory/pawwork-memory.test.ts
@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { tmpdir } from "../fixture/fixture"
+import { MemoryFile } from "../../src/memory/memory"
+import { MemoryProposal } from "../../src/memory/proposal"
+import { MemoryService } from "../../src/memory/service"
+
+describe("PawWork memory parser", () => {
+  test("parses the default Profile and Archive sections", () => {
+    const parsed = MemoryFile.parse(MemoryFile.defaultTemplate())
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.profile.trim()).toContain("PawWork Memory")
+    expect(parsed.archive.trim()).toBe("")
+  })
+
+  test("enters safe mode when Profile is missing", () => {
+    const parsed = MemoryFile.parse("# PawWork Memory\n\n## Archive\n")
+    expect(parsed.status).toBe("safe_mode")
+    if (parsed.status !== "safe_mode") throw new Error("expected safe mode")
+    expect(parsed.reason).toBe("missing_profile")
+  })
+
+  test("enters safe mode when Archive appears before Profile", () => {
+    const parsed = MemoryFile.parse("# PawWork Memory\n\n## Archive\n\n## Profile\n")
+    expect(parsed.status).toBe("safe_mode")
+    if (parsed.status !== "safe_mode") throw new Error("expected safe mode")
+    expect(parsed.reason).toBe("sections_out_of_order")
+  })
+
+  test("parses Archive entries with user and project scopes only", () => {
+    const parsed = MemoryFile.parse(`
+# PawWork Memory
+
+## Profile
+
+- Preferred language: Chinese.
+
+## Archive
+
+### 2026-05-10T18:00:00+09:00 id:mem_abc scope:project applies_to:/repo/pawwork
+Project memory.
+`)
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.entries).toHaveLength(1)
+    expect(parsed.entries[0]?.id).toBe("mem_abc")
+    expect(parsed.entries[0]?.scope).toBe("project")
+  })
+
+  test("round-trips project paths with spaces", () => {
+    const entry = MemoryFile.formatEntry({
+      id: "mem_space",
+      createdAt: "2026-05-10T18:00:00+09:00",
+      scope: "project",
+      appliesTo: "/repo/Paw Work",
+      text: "Project memory.",
+    })
+    const parsed = MemoryFile.parse(`# PawWork Memory\n\n## Profile\n\n## Archive\n\n${entry}`)
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.entries[0]?.appliesTo).toBe("/repo/Paw Work")
+  })
+
+  test("does not split Archive entries on markdown body headings", () => {
+    const parsed = MemoryFile.parse(`
+# PawWork Memory
+
+## Profile
+
+## Archive
+
+### 2026-05-10T18:00:00+09:00 id:mem_markdown scope:user
+Remember this:
+### Body heading
+Still the same entry.
+`)
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.entries).toHaveLength(1)
+    expect(parsed.entries[0]?.body).toContain("### Body heading")
+  })
+
+  test("marks global scope invalid in v1", () => {
+    const parsed = MemoryFile.parse(`
+# PawWork Memory
+
+## Profile
+
+## Archive
+
+### 2026-05-10T18:00:00+09:00 id:mem_bad scope:global
+Bad entry.
+`)
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.entries).toHaveLength(0)
+    expect(parsed.invalidEntries).toHaveLength(1)
+  })
+
+  test("parses Profile-only startup state without parsing Archive entries", () => {
+    const parsed = MemoryFile.parseProfileOnly(`
+# PawWork Memory
+
+## Profile
+
+- Preferred language: Chinese.
+
+## Archive
+
+### not a valid memory entry
+This malformed Archive entry should not affect startup.
+`)
+    expect(parsed.status).toBe("ok")
+    if (parsed.status !== "ok") throw new Error("expected ok parse")
+    expect(parsed.profile).toContain("Preferred language")
+  })
+
+  test("Profile-only startup still enforces the top-level section contract", () => {
+    const parsed = MemoryFile.parseProfileOnly("# PawWork Memory\n\n## Archive\n\n## Profile\n")
+    expect(parsed.status).toBe("safe_mode")
+    if (parsed.status !== "safe_mode") throw new Error("expected safe mode")
+    expect(parsed.reason).toBe("sections_out_of_order")
+  })
+})
+
+describe("PawWork memory service", () => {
+  test("creates default MEMORY.md under PawWork home", async () => {
+    await using tmp = await tmpdir()
+    const dir = tmp.path
+    const service = MemoryService.createForTest({ home: dir, workspacePath: "/repo/pawwork" })
+    const state = await service.read()
+    expect(state.status).toBe("ok")
+    expect(await fs.readFile(path.join(dir, "memory", "MEMORY.md"), "utf8")).toContain("## Profile")
+  })
+
+  test("redacts high-risk tokens and defaults proposal to unselected", () => {
+    const proposal = MemoryProposal.fromText({ text: "Use token sk-test123456" })
+    expect(proposal.text).toContain("[REDACTED]")
+    expect(proposal.defaultSelected).toBe(false)
+    expect(proposal.warning).toContain("sensitive")
+  })
+
+  test("create append read delete smoke path", async () => {
+    await using tmp = await tmpdir()
+    const dir = tmp.path
+    const service = MemoryService.createForTest({ home: dir, workspacePath: "/repo/pawwork" })
+    await service.read()
+    await service.appendAcceptedProposal({ text: "PawWork uses one MEMORY.md file.", scope: "project" })
+    const appended = await service.read()
+    expect(appended.content).toContain("scope:project")
+    const id = appended.content.match(/id:(mem_[a-z0-9]+)/)?.[1]
+    expect(id).toBeTruthy()
+    await service.deleteEntry(id!)
+    const deleted = await service.read()
+    expect(deleted.content).not.toContain(id!)
+  })
+
+  test("serializes concurrent proposal appends", async () => {
+    await using tmp = await tmpdir()
+    const service = MemoryService.createForTest({ home: tmp.path, workspacePath: "/repo/pawwork" })
+    await service.read()
+    await Promise.all([
+      service.appendAcceptedProposal({ text: "First memory.", scope: "project" }),
+      service.appendAcceptedProposal({ text: "Second memory.", scope: "project" }),
+    ])
+    const state = await service.read()
+    expect(state.content).toContain("First memory.")
+    expect(state.content).toContain("Second memory.")
+  })
+
+  test("disabled runtime Profile read does not create or parse MEMORY.md", async () => {
+    await using tmp = await tmpdir()
+    const memoryDir = path.join(tmp.path, "memory")
+    await fs.mkdir(memoryDir, { recursive: true })
+    await fs.writeFile(path.join(memoryDir, ".disabled"), "disabled\n")
+
+    const service = MemoryService.createForTest({ home: tmp.path, workspacePath: "/repo/pawwork" })
+    const state = await service.readProfile()
+
+    expect(state.disabled).toBe(true)
+    expect(state.status).toBe("ok")
+    await expect(fs.access(path.join(memoryDir, "MEMORY.md"))).rejects.toThrow()
+  })
+
+  test("runtime Profile read ignores malformed Archive entries", async () => {
+    await using tmp = await tmpdir()
+    const service = MemoryService.createForTest({ home: tmp.path, workspacePath: "/repo/pawwork" })
+    await service.saveRaw(`
+# PawWork Memory
+
+## Profile
+
+- Runtime profile survives malformed Archive.
+
+## Archive
+
+### invalid archive heading
+This entry is not parseable by full Archive parsing.
+`)
+
+    const state = await service.readProfile()
+    expect(state.status).toBe("ok")
+    expect(state.profile).toContain("Runtime profile survives")
+  })
+})
diff --git a/packages/sdk/js/src/v2/gen/sdk.gen.ts b/packages/sdk/js/src/v2/gen/sdk.gen.ts
index a2647650e..abee222b7 100644
--- a/packages/sdk/js/src/v2/gen/sdk.gen.ts
+++ b/packages/sdk/js/src/v2/gen/sdk.gen.ts
@@ -67,6 +67,17 @@ import type {
   McpLocalConfig,
   McpRemoteConfig,
   McpStatusResponses,
+  MemoryAcceptProposalResponses,
+  MemoryDeleteEntryResponses,
+  MemoryDisabledInput,
+  MemoryDisabledResponses,
+  MemoryGetResponses,
+  MemoryProposalInput,
+  MemoryRawInput,
+  MemoryResetResponses,
+  MemoryReviewStateResponses,
+  MemoryUpdateErrors,
+  MemoryUpdateResponses,
   OutputFormat,
   Part as Part2,
   PartDeleteErrors,
@@ -3287,6 +3298,227 @@ export class Provider extends HeyApiClient {
   }
 }
 
+export class Memory extends HeyApiClient {
+  /**
+   * Get PawWork memory
+   */
+  public get<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<MemoryGetResponses, unknown, ThrowOnError>({
+      url: "/memory",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Update raw PawWork memory
+   */
+  public update<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+      memoryRawInput?: MemoryRawInput
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "memoryRawInput", map: "body" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).patch<MemoryUpdateResponses, MemoryUpdateErrors, ThrowOnError>({
+      url: "/memory",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+
+  /**
+   * Get PawWork memory review availability
+   */
+  public reviewState<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).get<MemoryReviewStateResponses, unknown, ThrowOnError>({
+      url: "/memory/review-state",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Reset PawWork memory
+   */
+  public reset<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<MemoryResetResponses, unknown, ThrowOnError>({
+      url: "/memory/reset",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Disable or enable PawWork memory
+   */
+  public disabled<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+      memoryDisabledInput?: MemoryDisabledInput
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "memoryDisabledInput", map: "body" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).patch<MemoryDisabledResponses, unknown, ThrowOnError>({
+      url: "/memory/disabled",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+
+  /**
+   * Delete PawWork memory entry
+   */
+  public deleteEntry<ThrowOnError extends boolean = false>(
+    parameters: {
+      id: string
+      directory?: string
+      workspace?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "path", key: "id" },
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).delete<MemoryDeleteEntryResponses, unknown, ThrowOnError>({
+      url: "/memory/entry/{id}",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Accept PawWork memory proposal
+   */
+  public acceptProposal<ThrowOnError extends boolean = false>(
+    parameters?: {
+      directory?: string
+      workspace?: string
+      memoryProposalInput?: MemoryProposalInput
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "workspace" },
+            { key: "memoryProposalInput", map: "body" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<MemoryAcceptProposalResponses, unknown, ThrowOnError>({
+      url: "/memory/proposal/accept",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+}
+
 export class Find extends HeyApiClient {
   /**
    * Find text
@@ -4169,6 +4401,11 @@ export class OpencodeClient extends HeyApiClient {
     return (this._provider ??= new Provider({ client: this.client }))
   }
 
+  private _memory?: Memory
+  get memory(): Memory {
+    return (this._memory ??= new Memory({ client: this.client }))
+  }
+
   private _find?: Find
   get find(): Find {
     return (this._find ??= new Find({ client: this.client }))
diff --git a/packages/sdk/js/src/v2/gen/types.gen.ts b/packages/sdk/js/src/v2/gen/types.gen.ts
index 112a77887..1f680f872 100644
--- a/packages/sdk/js/src/v2/gen/types.gen.ts
+++ b/packages/sdk/js/src/v2/gen/types.gen.ts
@@ -4,35 +4,6 @@ export type ClientOptions = {
   baseUrl: `${string}://${string}` | (string & {})
 }
 
-export type Project = {
-  id: string
-  worktree: string
-  vcs?: "git"
-  name?: string
-  icon?: {
-    url?: string
-    override?: string
-    color?: string
-  }
-  commands?: {
-    /**
-     * Startup script to run when creating a new workspace (worktree)
-     */
-    start?: string
-  }
-  time: {
-    created: number
-    updated: number
-    initialized?: number
-  }
-  sandboxes: Array<string>
-}
-
-export type EventProjectUpdated = {
-  type: "project.updated"
-  properties: Project
-}
-
 export type EventServerConnected = {
   type: "server.connected"
   properties: {
@@ -346,50 +317,47 @@ export type EventSessionError = {
   }
 }
 
-export type EventFileEdited = {
-  type: "file.edited"
-  properties: {
-    file: string
+export type Project = {
+  id: string
+  worktree: string
+  vcs?: "git"
+  name?: string
+  icon?: {
+    url?: string
+    override?: string
+    color?: string
   }
-}
-
-export type EventFileWatcherUpdated = {
-  type: "file.watcher.updated"
-  properties: {
-    file: string
-    event: "add" | "change" | "unlink"
+  commands?: {
+    /**
+     * Startup script to run when creating a new workspace (worktree)
+     */
+    start?: string
   }
-}
-
-export type EventVcsBranchUpdated = {
-  type: "vcs.branch.updated"
-  properties: {
-    branch?: string
+  time: {
+    created: number
+    updated: number
+    initialized?: number
   }
+  sandboxes: Array<string>
 }
 
-export type EventMcpToolsChanged = {
-  type: "mcp.tools.changed"
-  properties: {
-    server: string
-  }
+export type EventProjectUpdated = {
+  type: "project.updated"
+  properties: Project
 }
 
-export type EventMcpBrowserOpenFailed = {
-  type: "mcp.browser.open.failed"
+export type EventFileEdited = {
+  type: "file.edited"
   properties: {
-    mcpName: string
-    url: string
+    file: string
   }
 }
 
-export type EventCommandExecuted = {
-  type: "command.executed"
+export type EventFileWatcherUpdated = {
+  type: "file.watcher.updated"
   properties: {
-    name: string
-    sessionID: string
-    arguments: string
-    messageID: string
+    file: string
+    event: "add" | "change" | "unlink"
   }
 }
 
@@ -468,6 +436,38 @@ export type EventWorktreeFailed = {
   }
 }
 
+export type EventMcpToolsChanged = {
+  type: "mcp.tools.changed"
+  properties: {
+    server: string
+  }
+}
+
+export type EventMcpBrowserOpenFailed = {
+  type: "mcp.browser.open.failed"
+  properties: {
+    mcpName: string
+    url: string
+  }
+}
+
+export type EventCommandExecuted = {
+  type: "command.executed"
+  properties: {
+    name: string
+    sessionID: string
+    arguments: string
+    messageID: string
+  }
+}
+
+export type EventVcsBranchUpdated = {
+  type: "vcs.branch.updated"
+  properties: {
+    branch?: string
+  }
+}
+
 export type Pty = {
   id: string
   title: string
@@ -1132,7 +1132,6 @@ export type EventSessionDeleted = {
 }
 
 export type Event =
-  | EventProjectUpdated
   | EventServerConnected
   | EventGlobalDisposed
   | EventServerInstanceDisposed
@@ -1151,18 +1150,19 @@ export type Event =
   | EventMessagePartDelta
   | EventSessionDiff
   | EventSessionError
+  | EventProjectUpdated
   | EventFileEdited
   | EventFileWatcherUpdated
-  | EventVcsBranchUpdated
-  | EventMcpToolsChanged
-  | EventMcpBrowserOpenFailed
-  | EventCommandExecuted
   | EventTodoUpdated
   | EventSessionStatus
   | EventSessionIdle
   | EventSessionCompacted
   | EventWorktreeReady
   | EventWorktreeFailed
+  | EventMcpToolsChanged
+  | EventMcpBrowserOpenFailed
+  | EventCommandExecuted
+  | EventVcsBranchUpdated
   | EventPtyCreated
   | EventPtyUpdated
   | EventPtyExited
@@ -2226,6 +2226,21 @@ export type ProviderAuthAuthorization = {
   instructions: string
 }
 
+export type MemoryState = unknown
+
+export type MemoryRawInput = {
+  content: string
+}
+
+export type MemoryDisabledInput = {
+  disabled: boolean
+}
+
+export type MemoryProposalInput = {
+  text: string
+  scope: "user" | "project"
+}
+
 export type Symbol = {
   name: string
   kind: number
@@ -5295,6 +5310,148 @@ export type ProviderOauthCallbackResponses = {
 
 export type ProviderOauthCallbackResponse = ProviderOauthCallbackResponses[keyof ProviderOauthCallbackResponses]
 
+export type MemoryGetData = {
+  body?: never
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory"
+}
+
+export type MemoryGetResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryGetResponse = MemoryGetResponses[keyof MemoryGetResponses]
+
+export type MemoryUpdateData = {
+  body?: MemoryRawInput
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory"
+}
+
+export type MemoryUpdateErrors = {
+  /**
+   * Invalid memory file
+   */
+  400: unknown
+}
+
+export type MemoryUpdateResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryUpdateResponse = MemoryUpdateResponses[keyof MemoryUpdateResponses]
+
+export type MemoryReviewStateData = {
+  body?: never
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory/review-state"
+}
+
+export type MemoryReviewStateResponses = {
+  /**
+   * Memory review state
+   */
+  200: MemoryState
+}
+
+export type MemoryReviewStateResponse = MemoryReviewStateResponses[keyof MemoryReviewStateResponses]
+
+export type MemoryResetData = {
+  body?: never
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory/reset"
+}
+
+export type MemoryResetResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryResetResponse = MemoryResetResponses[keyof MemoryResetResponses]
+
+export type MemoryDisabledData = {
+  body?: MemoryDisabledInput
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory/disabled"
+}
+
+export type MemoryDisabledResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryDisabledResponse = MemoryDisabledResponses[keyof MemoryDisabledResponses]
+
+export type MemoryDeleteEntryData = {
+  body?: never
+  path: {
+    id: string
+  }
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory/entry/{id}"
+}
+
+export type MemoryDeleteEntryResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryDeleteEntryResponse = MemoryDeleteEntryResponses[keyof MemoryDeleteEntryResponses]
+
+export type MemoryAcceptProposalData = {
+  body?: MemoryProposalInput
+  path?: never
+  query?: {
+    directory?: string
+    workspace?: string
+  }
+  url: "/memory/proposal/accept"
+}
+
+export type MemoryAcceptProposalResponses = {
+  /**
+   * Memory state
+   */
+  200: MemoryState
+}
+
+export type MemoryAcceptProposalResponse = MemoryAcceptProposalResponses[keyof MemoryAcceptProposalResponses]
+
 export type FindTextData = {
   body?: never
   path?: never