opencode-claude-memory 1.5.2 → 1.6.1

package/src/index.ts

@@ -1,142 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { tool } from "@opencode-ai/plugin"
-import { buildMemorySystemPrompt } from "./prompt.js"
-import { recallRelevantMemories, formatRecalledMemories } from "./recall.js"
-import {
-  saveMemory,
-  deleteMemory,
-  listMemories,
-  searchMemories,
-  readMemory,
-  MEMORY_TYPES,
-} from "./memory.js"
-import { getMemoryDir } from "./paths.js"
-
-export const MemoryPlugin: Plugin = async ({ worktree }) => {
-  getMemoryDir(worktree)
-
-  return {
-    "experimental.chat.system.transform": async (_input, output) => {
-      let query: string | undefined
-      if (_input && typeof _input === "object") {
-        const messages = (_input as { messages?: unknown }).messages
-        if (Array.isArray(messages)) {
-          const lastUserMsg = [...messages]
-            .reverse()
-            .find((message) =>
-              message && typeof message === "object" && "role" in message && (message as { role?: unknown }).role === "user",
-            )
-
-          if (lastUserMsg && typeof lastUserMsg === "object" && "content" in lastUserMsg) {
-            const content = (lastUserMsg as { content?: unknown }).content
-            query = typeof content === "string" ? content : JSON.stringify(content)
-          }
-        }
-      }
-
-      const recalled = recallRelevantMemories(worktree, query)
-      const recalledSection = formatRecalledMemories(recalled)
-      const memoryPrompt = buildMemorySystemPrompt(worktree, recalledSection)
-      output.system.push(memoryPrompt)
-    },
-
-    tool: {
-      memory_save: tool({
-        description:
-          "Save or update a memory for future conversations. " +
-          "Each memory is stored as a markdown file with frontmatter. " +
-          "Use this when the user explicitly asks you to remember something, " +
-          "or when you observe important information worth preserving across sessions " +
-          "(user preferences, feedback, project context, external references). " +
-          "Check existing memories first with memory_list or memory_search to avoid duplicates.",
-        args: {
-          file_name: tool.schema
-            .string()
-            .describe(
-              'File name for the memory (without .md extension). Use snake_case, e.g. "user_role", "feedback_testing_style", "project_auth_rewrite"',
-            ),
-          name: tool.schema.string().describe("Human-readable name for this memory"),
-          description: tool.schema
-            .string()
-            .describe("One-line description — used to decide relevance in future conversations, so be specific"),
-          type: tool.schema
-            .enum(MEMORY_TYPES)
-            .describe(
-              "Memory type: user (about the person), feedback (guidance on approach), project (ongoing work context), reference (pointers to external systems)",
-            ),
-          content: tool.schema
-            .string()
-            .describe(
-              "Memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines",
-            ),
-        },
-        async execute(args) {
-          const filePath = saveMemory(worktree, args.file_name, args.name, args.description, args.type, args.content)
-          return `Memory saved to ${filePath}`
-        },
-      }),
-
-      memory_delete: tool({
-        description: "Delete a memory that is outdated, wrong, or no longer relevant. Also removes it from the index.",
-        args: {
-          file_name: tool.schema.string().describe("File name of the memory to delete (with or without .md extension)"),
-        },
-        async execute(args) {
-          const deleted = deleteMemory(worktree, args.file_name)
-          return deleted ? `Memory "${args.file_name}" deleted.` : `Memory "${args.file_name}" not found.`
-        },
-      }),
-
-      memory_list: tool({
-        description:
-          "List all saved memories with their names, types, and descriptions. " +
-          "Use this to check what memories exist before saving a new one (to avoid duplicates) " +
-          "or when you need to recall what's been stored.",
-        args: {},
-        async execute() {
-          const entries = listMemories(worktree)
-          if (entries.length === 0) {
-            return "No memories saved yet."
-          }
-          const lines = entries.map(
-            (e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}`,
-          )
-          return `${entries.length} memories found:\n${lines.join("\n")}`
-        },
-      }),
-
-      memory_search: tool({
-        description:
-          "Search memories by keyword. Searches across names, descriptions, and content. " +
-          "Use this to find relevant memories before answering questions or when the user references past conversations.",
-        args: {
-          query: tool.schema.string().describe("Search query — searches across name, description, and content"),
-        },
-        async execute(args) {
-          const results = searchMemories(worktree, args.query)
-          if (results.length === 0) {
-            return `No memories matching "${args.query}".`
-          }
-          const lines = results.map(
-            (e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}\n  Content: ${e.content.slice(0, 200)}${e.content.length > 200 ? "..." : ""}`,
-          )
-          return `${results.length} matches for "${args.query}":\n${lines.join("\n")}`
-        },
-      }),
-
-      memory_read: tool({
-        description: "Read the full content of a specific memory file.",
-        args: {
-          file_name: tool.schema.string().describe("File name of the memory to read (with or without .md extension)"),
-        },
-        async execute(args) {
-          const entry = readMemory(worktree, args.file_name)
-          if (!entry) {
-            return `Memory "${args.file_name}" not found.`
-          }
-          return `# ${entry.name}\n**Type:** ${entry.type}\n**Description:** ${entry.description}\n\n${entry.content}`
-        },
-      }),
-    },
-  }
-}

package/src/memory.ts

@@ -1,243 +0,0 @@
-import { readFileSync, writeFileSync, readdirSync, unlinkSync, existsSync } from "fs"
-import { join, basename } from "path"
-import {
-  getMemoryDir,
-  getMemoryEntrypoint,
-  ENTRYPOINT_NAME,
-  validateMemoryFileName,
-  MAX_MEMORY_FILES,
-  MAX_MEMORY_FILE_BYTES,
-  FRONTMATTER_MAX_LINES,
-} from "./paths.js"
-
-export const MEMORY_TYPES = ["user", "feedback", "project", "reference"] as const
-export type MemoryType = (typeof MEMORY_TYPES)[number]
-
-export type MemoryEntry = {
-  filePath: string
-  fileName: string
-  name: string
-  description: string
-  type: MemoryType
-  content: string
-  rawContent: string
-}
-
-function parseFrontmatter(raw: string): { frontmatter: Record<string, string>; content: string } {
-  const trimmed = raw.trim()
-  if (!trimmed.startsWith("---")) {
-    return { frontmatter: {}, content: trimmed }
-  }
-
-  const lines = trimmed.split("\n")
-  let closingLineIdx = -1
-  for (let i = 1; i < Math.min(lines.length, FRONTMATTER_MAX_LINES); i++) {
-    if (lines[i].trimEnd() === "---") {
-      closingLineIdx = i
-      break
-    }
-  }
-  if (closingLineIdx === -1) {
-    return { frontmatter: {}, content: trimmed }
-  }
-
-  const endIndex = lines.slice(0, closingLineIdx).join("\n").length + 1
-
-  const frontmatterBlock = trimmed.slice(3, endIndex).trim()
-  const content = trimmed.slice(endIndex + 3).trim()
-
-  const frontmatter: Record<string, string> = {}
-  for (const line of frontmatterBlock.split("\n")) {
-    const colonIdx = line.indexOf(":")
-    if (colonIdx === -1) continue
-    const key = line.slice(0, colonIdx).trim()
-    const value = line.slice(colonIdx + 1).trim()
-    if (key && value) {
-      frontmatter[key] = value
-    }
-  }
-
-  return { frontmatter, content }
-}
-
-function buildFrontmatter(name: string, description: string, type: MemoryType): string {
-  return `---\nname: ${name}\ndescription: ${description}\ntype: ${type}\n---`
-}
-
-function parseMemoryType(raw: string | undefined): MemoryType | undefined {
-  if (!raw) return undefined
-  return MEMORY_TYPES.find((t) => t === raw)
-}
-
-export function listMemories(worktree: string): MemoryEntry[] {
-  const memDir = getMemoryDir(worktree)
-  const entries: MemoryEntry[] = []
-
-  let files: string[]
-  try {
-    files = readdirSync(memDir)
-      .filter((f) => f.endsWith(".md") && f !== ENTRYPOINT_NAME)
-      .sort()
-      .slice(0, MAX_MEMORY_FILES)
-  } catch {
-    return entries
-  }
-
-  for (const fileName of files) {
-    const filePath = join(memDir, fileName)
-    try {
-      const rawContent = readFileSync(filePath, "utf-8")
-      const { frontmatter, content } = parseFrontmatter(rawContent)
-      entries.push({
-        filePath,
-        fileName,
-        name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
-        description: frontmatter.description ?? "",
-        type: parseMemoryType(frontmatter.type) ?? "user",
-        content,
-        rawContent,
-      })
-    } catch {
-      
-    }
-  }
-
-  return entries
-}
-
-export function readMemory(worktree: string, fileName: string): MemoryEntry | null {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  try {
-    const rawContent = readFileSync(filePath, "utf-8")
-    const { frontmatter, content } = parseFrontmatter(rawContent)
-    return {
-      filePath,
-      fileName: basename(filePath),
-      name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
-      description: frontmatter.description ?? "",
-      type: parseMemoryType(frontmatter.type) ?? "user",
-      content,
-      rawContent,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function saveMemory(
-  worktree: string,
-  fileName: string,
-  name: string,
-  description: string,
-  type: MemoryType,
-  content: string,
-): string {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  const fileContent = `${buildFrontmatter(name, description, type)}\n\n${content.trim()}\n`
-  if (Buffer.byteLength(fileContent, "utf-8") > MAX_MEMORY_FILE_BYTES) {
-    throw new Error(
-      `Memory file content exceeds the ${MAX_MEMORY_FILE_BYTES}-byte limit`,
-    )
-  }
-  writeFileSync(filePath, fileContent, "utf-8")
-
-  updateIndex(worktree, safeName, name, description)
-
-  return filePath
-}
-
-export function deleteMemory(worktree: string, fileName: string): boolean {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  try {
-    unlinkSync(filePath)
-    removeFromIndex(worktree, safeName)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function searchMemories(worktree: string, query: string): MemoryEntry[] {
-  const all = listMemories(worktree)
-  const lowerQuery = query.toLowerCase()
-
-  return all.filter(
-    (entry) =>
-      entry.name.toLowerCase().includes(lowerQuery) ||
-      entry.description.toLowerCase().includes(lowerQuery) ||
-      entry.content.toLowerCase().includes(lowerQuery),
-  )
-}
-
-export function readIndex(worktree: string): string {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  try {
-    return readFileSync(entrypoint, "utf-8")
-  } catch {
-    return ""
-  }
-}
-
-function updateIndex(worktree: string, fileName: string, name: string, description: string): void {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  const existing = readIndex(worktree)
-  const lines = existing.split("\n").filter((l) => l.trim())
-
-  const pointer = `- [${name}](${fileName}) — ${description}`
-  const existingIdx = lines.findIndex((l) => l.includes(`(${fileName})`))
-
-  if (existingIdx >= 0) {
-    lines[existingIdx] = pointer
-  } else {
-    lines.push(pointer)
-  }
-
-  writeFileSync(entrypoint, lines.join("\n") + "\n", "utf-8")
-}
-
-function removeFromIndex(worktree: string, fileName: string): void {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  const existing = readIndex(worktree)
-  const lines = existing
-    .split("\n")
-    .filter((l) => l.trim() && !l.includes(`(${fileName})`))
-
-  writeFileSync(entrypoint, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8")
-}
-
-export function truncateEntrypoint(raw: string): { content: string; wasTruncated: boolean } {
-  const trimmed = raw.trim()
-  if (!trimmed) return { content: "", wasTruncated: false }
-
-  const lines = trimmed.split("\n")
-  const lineCount = lines.length
-  const byteCount = trimmed.length
-
-  const wasLineTruncated = lineCount > 200
-  const wasByteTruncated = byteCount > 25_000
-
-  if (!wasLineTruncated && !wasByteTruncated) {
-    return { content: trimmed, wasTruncated: false }
-  }
-
-  let truncated = wasLineTruncated ? lines.slice(0, 200).join("\n") : trimmed
-
-  if (truncated.length > 25_000) {
-    const cutAt = truncated.lastIndexOf("\n", 25_000)
-    truncated = truncated.slice(0, cutAt > 0 ? cutAt : 25_000)
-  }
-
-  return {
-    content: truncated + "\n\n> WARNING: MEMORY.md was truncated. Keep index entries concise.",
-    wasTruncated: true,
-  }
-}

package/src/paths.ts

@@ -1,165 +0,0 @@
-// Claude Code compatible memory directory path resolution.
-// Directory: ~/.claude/projects/<sanitizePath(canonicalGitRoot)>/memory/
-// Ensures bidirectional memory sharing between Claude Code and OpenCode.
-
-import { homedir } from "os"
-import { join, dirname, resolve, sep } from "path"
-import { mkdirSync, existsSync, readFileSync, statSync, realpathSync } from "fs"
-
-export const ENTRYPOINT_NAME = "MEMORY.md"
-export const MAX_ENTRYPOINT_LINES = 200
-export const MAX_ENTRYPOINT_BYTES = 25_000
-
-export const MAX_MEMORY_FILES = 200
-export const MAX_MEMORY_FILE_BYTES = 40_000
-export const FRONTMATTER_MAX_LINES = 30
-
-export function validateMemoryFileName(fileName: string): string {
-  const base = fileName.endsWith(".md") ? fileName.slice(0, -3) : fileName
-
-  if (base.length === 0) {
-    throw new Error("Memory file name cannot be empty")
-  }
-  if (base.includes("/") || base.includes("\\")) {
-    throw new Error(`Memory file name must not contain path separators: ${fileName}`)
-  }
-  if (base.includes("..")) {
-    throw new Error(`Memory file name must not contain path traversal: ${fileName}`)
-  }
-  if (base.includes("\0")) {
-    throw new Error(`Memory file name must not contain null bytes: ${fileName}`)
-  }
-  if (base.startsWith(".")) {
-    throw new Error(`Memory file name must not start with '.': ${fileName}`)
-  }
-  if (base.toUpperCase() === "MEMORY") {
-    throw new Error(`'MEMORY' is a reserved name and cannot be used as a memory file name`)
-  }
-
-  return `${base}.md`
-}
-
-const MAX_SANITIZED_LENGTH = 200
-
-// Exact copy of Claude Code's djb2Hash() from utils/hash.ts
-function djb2Hash(str: string): number {
-  let hash = 0
-  for (let i = 0; i < str.length; i++) {
-    hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0
-  }
-  return hash
-}
-
-function simpleHash(str: string): string {
-  return Math.abs(djb2Hash(str)).toString(36)
-}
-
-// Exact copy of Claude Code's sanitizePath() from utils/sessionStoragePortable.ts
-export function sanitizePath(name: string): string {
-  const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-")
-  if (sanitized.length <= MAX_SANITIZED_LENGTH) {
-    return sanitized
-  }
-  const hash = simpleHash(name)
-  return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${hash}`
-}
-
-// Matches Claude Code's findGitRoot() from utils/git.ts
-function findGitRoot(startPath: string): string | null {
-  let current = resolve(startPath)
-  const root = current.substring(0, current.indexOf(sep) + 1) || sep
-
-  while (current !== root) {
-    try {
-      const gitPath = join(current, ".git")
-      const s = statSync(gitPath)
-      if (s.isDirectory() || s.isFile()) {
-        return current.normalize("NFC")
-      }
-    } catch {}
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-
-  try {
-    const gitPath = join(root, ".git")
-    const s = statSync(gitPath)
-    if (s.isDirectory() || s.isFile()) {
-      return root.normalize("NFC")
-    }
-  } catch {}
-
-  return null
-}
-
-// Matches Claude Code's resolveCanonicalRoot() from utils/git.ts
-// Resolves worktrees to the main repo root via .git -> gitdir -> commondir chain
-function resolveCanonicalRoot(gitRoot: string): string {
-  try {
-    const gitContent = readFileSync(join(gitRoot, ".git"), "utf-8").trim()
-    if (!gitContent.startsWith("gitdir:")) {
-      return gitRoot
-    }
-    const worktreeGitDir = resolve(gitRoot, gitContent.slice("gitdir:".length).trim())
-
-    const commonDir = resolve(
-      worktreeGitDir,
-      readFileSync(join(worktreeGitDir, "commondir"), "utf-8").trim(),
-    )
-
-    // SECURITY: validate worktreeGitDir is a direct child of <commonDir>/worktrees/
-    if (resolve(dirname(worktreeGitDir)) !== join(commonDir, "worktrees")) {
-      return gitRoot
-    }
-
-    // SECURITY: validate gitdir back-link points to our .git
-    const backlink = realpathSync(
-      readFileSync(join(worktreeGitDir, "gitdir"), "utf-8").trim(),
-    )
-    if (backlink !== join(realpathSync(gitRoot), ".git")) {
-      return gitRoot
-    }
-
-    if (commonDir.endsWith(`${sep}.git`) || commonDir.endsWith("/.git")) {
-      return dirname(commonDir).normalize("NFC")
-    }
-
-    return commonDir.normalize("NFC")
-  } catch {
-    return gitRoot
-  }
-}
-
-export function findCanonicalGitRoot(startPath: string): string | null {
-  const root = findGitRoot(startPath)
-  if (!root) return null
-  return resolveCanonicalRoot(root)
-}
-
-function getClaudeConfigHomeDir(): string {
-  return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC")
-}
-
-export function getMemoryDir(worktree: string): string {
-  const canonicalRoot = findCanonicalGitRoot(worktree) ?? worktree
-  const projectsDir = join(getClaudeConfigHomeDir(), "projects")
-  const memoryDir = join(projectsDir, sanitizePath(canonicalRoot), "memory")
-  ensureDir(memoryDir)
-  return memoryDir
-}
-
-export function getMemoryEntrypoint(worktree: string): string {
-  return join(getMemoryDir(worktree), ENTRYPOINT_NAME)
-}
-
-export function isMemoryPath(absolutePath: string, worktree: string): boolean {
-  const memDir = getMemoryDir(worktree)
-  return absolutePath.startsWith(memDir)
-}
-
-export function ensureDir(dir: string): void {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-}

package/src/prompt.ts

@@ -1,147 +0,0 @@
-import { MEMORY_TYPES } from "./memory.js"
-import { readIndex, truncateEntrypoint } from "./memory.js"
-import { getMemoryDir, ENTRYPOINT_NAME } from "./paths.js"
-
-const FRONTMATTER_EXAMPLE = `\`\`\`markdown
----
-name: {{memory name}}
-description: {{one-line description — used to decide relevance in future conversations, so be specific}}
-type: {{${MEMORY_TYPES.join(", ")}}}
----
-
-{{memory content — for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}}
-\`\`\``
-
-const TYPES_SECTION = `## Types of memory
-
-There are several discrete types of memory that you can store:
-
-<types>
-<type>
-    <name>user</name>
-    <description>Information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective.</description>
-    <when_to_save>When you learn any details about the user's role, preferences, responsibilities, or knowledge</when_to_save>
-    <how_to_use>When your work should be informed by the user's profile or perspective.</how_to_use>
-    <examples>
-    user: I'm a data scientist investigating what logging we have in place
-    assistant: [saves user memory: user is a data scientist, currently focused on observability/logging]
-    </examples>
-</type>
-<type>
-    <name>feedback</name>
-    <description>Guidance the user has given you about how to approach work — both what to avoid and what to keep doing. Record from failure AND success.</description>
-    <when_to_save>Any time the user corrects your approach ("no not that", "don't", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that"). Include *why* so you can judge edge cases later.</when_to_save>
-    <how_to_use>Let these memories guide your behavior so that the user does not need to offer the same guidance twice.</how_to_use>
-    <body_structure>Lead with the rule itself, then a **Why:** line and a **How to apply:** line.</body_structure>
-    <examples>
-    user: don't mock the database in these tests — we got burned last quarter when mocked tests passed but the prod migration failed
-    assistant: [saves feedback memory: integration tests must hit a real database, not mocks]
-    </examples>
-</type>
-<type>
-    <name>project</name>
-    <description>Information about ongoing work, goals, initiatives, bugs, or incidents that is not derivable from the code or git history.</description>
-    <when_to_save>When you learn who is doing what, why, or by when. Always convert relative dates to absolute dates when saving.</when_to_save>
-    <how_to_use>Use these memories to understand the broader context behind the user's request.</how_to_use>
-    <body_structure>Lead with the fact or decision, then a **Why:** line and a **How to apply:** line.</body_structure>
-    <examples>
-    user: we're freezing all non-critical merges after Thursday — mobile team is cutting a release branch
-    assistant: [saves project memory: merge freeze begins 2026-03-05 for mobile release cut]
-    </examples>
-</type>
-<type>
-    <name>reference</name>
-    <description>Pointers to where information can be found in external systems.</description>
-    <when_to_save>When you learn about resources in external systems and their purpose.</when_to_save>
-    <how_to_use>When the user references an external system or information that may be in an external system.</how_to_use>
-    <examples>
-    user: check the Linear project "INGEST" if you want context on these tickets
-    assistant: [saves reference memory: pipeline bugs are tracked in Linear project "INGEST"]
-    </examples>
-</type>
-</types>`
-
-const WHAT_NOT_TO_SAVE = `## What NOT to save in memory
-
-- Code patterns, conventions, architecture, file paths, or project structure — these can be derived by reading the current project state.
-- Git history, recent changes, or who-changed-what — \`git log\` / \`git blame\` are authoritative.
-- Debugging solutions or fix recipes — the fix is in the code; the commit message has the context.
-- Anything already documented in AGENTS.md or project rules files.
-- Ephemeral task details: in-progress work, temporary state, current conversation context.
-
-These exclusions apply even when the user explicitly asks you to save. If they ask you to save a PR list or activity summary, ask what was *surprising* or *non-obvious* about it — that is the part worth keeping.`
-
-const WHEN_TO_ACCESS = `## When to access memories
-- When memories seem relevant, or the user references prior-conversation work.
-- You MUST access memory when the user explicitly asks you to check, recall, or remember.
-- If the user says to *ignore* or *not use* memory: proceed as if MEMORY.md were empty.
-- Memory records can become stale over time. Before answering based solely on memory, verify against current state. If a recalled memory conflicts with current information, trust what you observe now — and update or remove the stale memory.`
-
-const TRUSTING_RECALL = `## Before recommending from memory
-
-A memory that names a specific function, file, or flag is a claim that it existed *when the memory was written*. It may have been renamed, removed, or never merged. Before recommending it:
-
-- If the memory names a file path: check the file exists.
-- If the memory names a function or flag: grep for it.
-- If the user is about to act on your recommendation, verify first.
-
-"The memory says X exists" is not the same as "X exists now."
-
-A memory that summarizes repo state is frozen in time. If the user asks about *recent* or *current* state, prefer \`git log\` or reading the code over recalling the snapshot.`
-
-export function buildMemorySystemPrompt(worktree: string, recalledMemoriesSection?: string): string {
-  const memoryDir = getMemoryDir(worktree)
-  const indexContent = readIndex(worktree)
-
-  const lines: string[] = [
-    "# Auto Memory",
-    "",
-    `You have a persistent, file-based memory system at \`${memoryDir}\`. This directory already exists — write to it directly (do not run mkdir or check for its existence).`,
-    "",
-    "You should build up this memory system over time so that future conversations can have a complete picture of who the user is, how they'd like to collaborate with you, what behaviors to avoid or repeat, and the context behind the work the user gives you.",
-    "",
-    "If the user explicitly asks you to remember something, save it immediately using the `memory_save` tool as whichever type fits best. If they ask you to forget something, find and remove the relevant entry using `memory_delete`.",
-    "",
-    TYPES_SECTION,
-    "",
-    WHAT_NOT_TO_SAVE,
-    "",
-    `## How to save memories`,
-    "",
-    "Use the `memory_save` tool to create or update a memory. Each memory goes in its own file with frontmatter:",
-    "",
-    FRONTMATTER_EXAMPLE,
-    "",
-    `- The \`${ENTRYPOINT_NAME}\` index is managed automatically — you don't need to edit it`,
-    "- Organize memory semantically by topic, not chronologically",
-    "- Update or remove memories that turn out to be wrong or outdated",
-    "- Do not write duplicate memories. First use `memory_list` or `memory_search` to check if there is an existing memory you can update before writing a new one.",
-    "",
-    WHEN_TO_ACCESS,
-    "",
-    TRUSTING_RECALL,
-    "",
-    "## Memory and other forms of persistence",
-    "Memory is one of several persistence mechanisms. The distinction is that memory can be recalled in future conversations and should not be used for persisting information that is only useful within the scope of the current conversation.",
-    "- When to use or update a plan instead of memory: If you are about to start a non-trivial implementation task, use a Plan rather than saving this to memory.",
-    "- When to use or update tasks instead of memory: When you need to break your work into discrete steps or track progress, use tasks instead of saving to memory.",
-    "",
-  ]
-
-  if (indexContent.trim()) {
-    const { content: truncated } = truncateEntrypoint(indexContent)
-    lines.push(`## ${ENTRYPOINT_NAME}`, "", truncated)
-  } else {
-    lines.push(
-      `## ${ENTRYPOINT_NAME}`,
-      "",
-      `Your ${ENTRYPOINT_NAME} is currently empty. When you save new memories, they will appear here.`,
-    )
-  }
-
-  if (recalledMemoriesSection?.trim()) {
-    lines.push("", recalledMemoriesSection)
-  }
-
-  return lines.join("\n")
-}