opencode-claude-memory 2.0.1 → 2.1.0

package/dist/recall/turn.js

@@ -0,0 +1,49 @@
+// Host-independent text rules for a user turn: the "ignore memory" / "use memory again" phrases and
+// the keys of memories already surfaced in a system prompt. The host adapters apply them to their
+// own message shapes.
+import { RECALLED_MEMORIES_HEADING } from "../prompt/systemPrompt.js";
+// "Ignore memory" handling. Claude Code's semantics are session-scoped: once the user asks to
+// ignore memory, it stays ignored until they explicitly ask for it back.
+export function detectIgnoreMemory(query) {
+    if (!query)
+        return false;
+    const normalized = query.toLowerCase();
+    return (/(ignore|don't use|do not use|without|skip)\s+(the\s+|your\s+)?memory/.test(normalized) ||
+        /memory\s+(should be|must be)?\s*ignored/.test(normalized));
+}
+export function detectResumeMemory(query) {
+    if (!query)
+        return false;
+    const normalized = query.toLowerCase();
+    return (/(use|enable|resume|restore|bring back|turn on)\s+(the\s+|your\s+)?memory(\s+again)?/.test(normalized) ||
+        /memory\s+(back\s+)?on\b/.test(normalized) ||
+        /stop ignoring\s+(the\s+|your\s+)?memory/.test(normalized));
+}
+// Replays user queries in order and returns whether memory is ignored at the end. Used to rebuild
+// session state the coordinator no longer holds (process restart, cache eviction), so an "ignore
+// memory" said earlier in the session keeps applying without the user repeating it.
+export function deriveIgnoredFromQueries(queries) {
+    let ignored = false;
+    for (const query of queries) {
+        if (detectIgnoreMemory(query))
+            ignored = true;
+        else if (ignored && detectResumeMemory(query))
+            ignored = false;
+    }
+    return ignored;
+}
+// Parses "### <name> (<type>)" headers from the ## Recalled Memories section
+// of system prompts. After compaction old system messages disappear, so
+// the returned set naturally shrinks — no manual reset needed.
+export function extractSurfacedMemoryKeys(systemText) {
+    const keys = new Set();
+    const recalledSection = systemText.indexOf(RECALLED_MEMORIES_HEADING);
+    if (recalledSection === -1)
+        return keys;
+    const headerPattern = /^### (.+?) \((\w+)\)/gm;
+    const section = systemText.slice(recalledSection);
+    for (let match = headerPattern.exec(section); match !== null; match = headerPattern.exec(section)) {
+        keys.add(`${match[1]}|${match[2]}`);
+    }
+    return keys;
+}

package/dist/store/MemoryStore.js

@@ -1,7 +1,7 @@
-import { cpSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { cpSync, lstatSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { writeFileAtomicSync } from "../util/exclusiveFile.js";
-import { buildFrontmatter, editFrontmatter, FRONTMATTER_MAX_LINES, ORIGIN, parseFrontmatter, parseMemoryType, } from "./frontmatter.js";
+import { buildFrontmatter, editFrontmatter, FRONTMATTER_MAX_LINES, frontmatterKeys, ORIGIN, parseFrontmatter, parseMemoryType, } from "./frontmatter.js";
 import { buildIndexPointer, indexHasPointer, readIndexFile, removeIndexLine, upsertIndexLine } from "./indexFile.js";
 import { ENTRYPOINT_NAME, findCanonicalGitRoot, findGitRoot, MAX_MEMORY_FILE_BYTES, resolveMemoryFilePath, sanitizePath, } from "./paths.js";
 import { formatMemoryManifest, nameFromFilename, readMemoryEntry, scanMemoryFiles, } from "./scan.js";
@@ -59,6 +59,10 @@ export class MemoryStore {
         if (typeof input.name !== "string" || !input.name.trim()) {
             throw new Error("Memory name is required");
         }
+        // Writes follow links, so a memory file that links to the index would overwrite MEMORY.md itself.
+        if (isLinkTo(filePath, this.entrypoint)) {
+            throw new Error(`Memory "${relativePath}" is a link to ${ENTRYPOINT_NAME}; saving it would overwrite the index`);
+        }
         const existing = readTextFile(filePath);
         const parsed = existing === null ? null : parseFrontmatter(existing);
         const pointer = buildIndexPointer(relativePath, input.name, input.description);
@@ -82,16 +86,17 @@ export class MemoryStore {
         this.writeIndex(upsertIndexLine(this.readIndex(), relativePath, pointer));
         return { filePath, fileName: relativePath, unchanged: false };
     }
-    // Deleting a memory this plugin did not create (Claude Code's, dsh's, a hand-written one) first
-    // keeps a copy under the plugin's state directory, as dsh-unified-memory does, so an auto-dream
-    // prune can never silently destroy another tool's memory.
+    // Deleting a memory that is not purely this plugin's (Claude Code's, dsh's, a hand-written one, or
+    // one of ours that another tool has since edited) first keeps a copy under the plugin's state
+    // directory, as dsh-unified-memory does, so an auto-dream prune can never silently destroy
+    // another tool's work.
     delete(fileName) {
         const { relativePath, filePath } = resolveMemoryFilePath(this.memoryDir, fileName);
         const existing = readTextFile(filePath);
         if (existing === null)
             return { deleted: false };
         let trashedTo;
-        if (parseFrontmatter(existing).frontmatter.origin !== ORIGIN) {
+        if (!isPurelyOwn(existing, filePath)) {
             const stamp = this.now().toISOString().replace(/[:.]/g, "-");
             trashedTo = join(this.stateDir, "trash", stamp, relativePath);
             mkdirSync(dirname(trashedTo), { recursive: true });
@@ -132,6 +137,45 @@ export class MemoryStore {
         return same && indexHasPointer(this.readIndex(), pointer);
     }
 }
+// The frontmatter keys of a memory this plugin creates (buildFrontmatter), each on one line; its own
+// later saves keep exactly this set.
+const OWN_KEYS = ["name", "description", "metadata", "type", "origin", "modified"];
+// How far a file's modification time may sit from this plugin's own `modified` stamp and still count
+// as that write: the stamp is taken just before the write, and filesystems with coarse timestamps
+// (FAT, HFS+) round the modification time down by up to 2 s.
+const OWN_WRITE_SLACK_MS = 2_000;
+// A memory is purely this plugin's when its frontmatter is exactly what this plugin writes, with
+// `origin: opencode`, and the file has not changed since the plugin last wrote it. Other writers are
+// recognised by what they leave: Claude Code's Write and Edit tools keep `origin` but add `node_type`
+// and `originSessionId` and restamp `modified`, other tools add `updatedBy` or keys of their own
+// (or a second `modified`), and an edit that stamps nothing moves the modification time away from
+// our `modified`. Any doubt counts as "not ours": an unneeded copy in the trash is harmless, a
+// missing one loses another tool's work.
+function isPurelyOwn(content, filePath) {
+    const keys = frontmatterKeys(content);
+    if (keys?.length !== OWN_KEYS.length || !OWN_KEYS.every((key) => keys.includes(key)))
+        return false;
+    const { frontmatter } = parseFrontmatter(content);
+    if (frontmatter.origin !== ORIGIN)
+        return false;
+    const stamped = Date.parse(frontmatter.modified ?? "");
+    if (Number.isNaN(stamped))
+        return false;
+    try {
+        return Math.abs(statSync(filePath).mtimeMs - stamped) <= OWN_WRITE_SLACK_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function isLinkTo(path, other) {
+    try {
+        return lstatSync(path).isSymbolicLink() && realpathSync(path) === realpathSync(other);
+    }
+    catch {
+        return false;
+    }
+}
 function readTextFile(path) {
     try {
         return readFileSync(path, "utf-8");

package/dist/store/frontmatter.d.ts

@@ -14,6 +14,7 @@ export type ParsedMemoryFile = {
 };
 export declare function quoteScalar(value: string): string;
 export declare function parseFrontmatter(raw: string): ParsedMemoryFile;
+export declare function frontmatterKeys(raw: string): string[] | undefined;
 export declare function parseFrontmatterHeader(raw: string): {
     frontmatter: Frontmatter;
     hasFrontmatter: boolean;

package/dist/store/frontmatter.js

@@ -72,6 +72,25 @@ export function parseFrontmatter(raw) {
         hasFrontmatter: true,
     };
 }
+// The key of every non-blank frontmatter line, in order and with repeats, which the flat parser
+// above merges away; a line that is not `key: value` (a list item, a comment) yields "". `undefined`
+// when the file has no frontmatter.
+export function frontmatterKeys(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("---"))
+        return undefined;
+    const lines = trimmed.split("\n");
+    const closing = findClosingLine(lines);
+    if (closing === -1)
+        return undefined;
+    return lines
+        .slice(1, closing)
+        .filter((line) => line.trim() !== "")
+        .map((line) => {
+        const colonIdx = line.indexOf(":");
+        return colonIdx === -1 ? "" : line.slice(0, colonIdx).trim();
+    });
+}
 // Header-only variant for the directory scanner: parses the first FRONTMATTER_MAX_LINES lines and
 // never materialises the body. Leading whitespace is dropped before counting lines, exactly as the
 // full parser does, so both entry points agree on every file (leading blank lines included).

package/dist/tools.d.ts

@@ -1,9 +1,22 @@
-import { type Hooks } from "@opencode-ai/plugin";
+import { z } from "zod/v4";
+import type { MemoryToolName } from "./agents.js";
 import type { ExtractionCoordinator } from "./extraction/ExtractionCoordinator.js";
 import type { MemoryStore, SaveMemoryResult } from "./store/MemoryStore.js";
 export declare function formatMemorySaveResult(outcome: SaveMemoryResult, savedThisRun?: readonly string[]): string;
 export declare function memorySaveTitle(type: string, name: string): string | undefined;
 export declare function memoryListTitle(count: number): string;
 export declare function memorySearchTitle(query: string, count: number): string;
-export type MemoryTools = NonNullable<Hooks["tool"]>;
-export declare function buildMemoryTools(store: MemoryStore, extraction: Pick<ExtractionCoordinator, "recordSave">): MemoryTools;
+export type MemoryToolResult = {
+    title?: string;
+    output: string;
+};
+export type MemoryToolContext = {
+    sessionID?: string;
+};
+export type MemoryToolSpec = {
+    name: MemoryToolName;
+    description: string;
+    args: z.ZodRawShape;
+    execute(args: Record<string, unknown>, ctx: MemoryToolContext): Promise<MemoryToolResult>;
+};
+export declare function buildMemoryToolSpecs(store: MemoryStore, extraction: Pick<ExtractionCoordinator, "recordSave">): MemoryToolSpec[];

package/dist/tools.js

@@ -1,4 +1,9 @@
-import { tool } from "@opencode-ai/plugin";
+// The five memory tools, defined once. Each host adapter wraps the specs into its own tool format
+// (V1: `Hooks["tool"]`, V2: `ToolEditor.add`); results carry their own titles.
+//
+// Argument schemas use `zod/v4`: both hosts accept them (V1 duck-types Zod v4 schemas, V2 takes any
+// Standard Schema), so the plugin needs no runtime import from either SDK.
+import { z } from "zod/v4";
 import { MEMORY_TYPES } from "./store/frontmatter.js";
 // Tool result for memory_save. Inside an extraction fork, `savedThisRun` (file names already saved
 // by this fork, in order) is appended as an explicit done-signal so the model does not lose track on
@@ -42,9 +47,14 @@ export function memorySearchTitle(query, count) {
     return `"${query}" · ${plural(count, "match", "matches")}`;
 }
 const FILE_NAME_HINT = 'with or without the .md extension; sub-directories are allowed, e.g. "team/conventions"';
-export function buildMemoryTools(store, extraction) {
-    return {
-        memory_save: tool({
+function str(args, key) {
+    const value = args[key];
+    return typeof value === "string" ? value : "";
+}
+export function buildMemoryToolSpecs(store, extraction) {
+    return [
+        {
+            name: "memory_save",
             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, " +
@@ -52,52 +62,56 @@ export function buildMemoryTools(store, extraction) {
                 "(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
+                file_name: z
                     .string()
                     .describe('File name for the memory (without .md extension). Use snake_case, e.g. "user_role", "feedback_testing_style", "project_auth_rewrite"; a sub-directory prefix such as "team/conventions" is allowed'),
-                name: tool.schema.string().describe("Human-readable name for this memory"),
-                description: tool.schema
+                name: z.string().describe("Human-readable name for this memory"),
+                description: z
                     .string()
                     .describe("One-line description — used to decide relevance in future conversations, so be specific"),
-                type: tool.schema
+                type: z
                     .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
+                content: z
                     .string()
                     .describe("Memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines"),
             },
             async execute(args, ctx) {
+                const type = str(args, "type");
                 const outcome = store.save({
-                    fileName: args.file_name,
-                    name: args.name,
-                    description: args.description,
-                    type: args.type,
-                    content: args.content,
+                    fileName: str(args, "file_name"),
+                    name: str(args, "name"),
+                    description: str(args, "description"),
+                    type,
+                    content: str(args, "content"),
                 });
-                const savedThisRun = extraction.recordSave(ctx?.sessionID, outcome.fileName);
+                const savedThisRun = extraction.recordSave(ctx.sessionID, outcome.fileName);
                 return {
-                    title: memorySaveTitle(args.type, args.name),
+                    title: memorySaveTitle(type, str(args, "name")),
                     output: formatMemorySaveResult(outcome, savedThisRun),
                 };
             },
-        }),
-        memory_delete: tool({
+        },
+        {
+            name: "memory_delete",
             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 (${FILE_NAME_HINT})`),
+                file_name: z.string().describe(`File name of the memory to delete (${FILE_NAME_HINT})`),
             },
             async execute(args) {
-                const { deleted, trashedTo } = store.delete(args.file_name);
-                let output = `Memory "${args.file_name}" not found.`;
+                const fileName = str(args, "file_name");
+                const { deleted, trashedTo } = store.delete(fileName);
+                let output = `Memory "${fileName}" not found.`;
                 if (deleted) {
                     output = trashedTo
-                        ? `Memory "${args.file_name}" deleted (a copy was kept at ${trashedTo}).`
-                        : `Memory "${args.file_name}" deleted.`;
+                        ? `Memory "${fileName}" deleted (a copy was kept at ${trashedTo}).`
+                        : `Memory "${fileName}" deleted.`;
                 }
-                return { title: args.file_name, output };
+                return { title: fileName, output };
             },
-        }),
-        memory_list: tool({
+        },
+        {
+            name: "memory_list",
             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.",
@@ -110,36 +124,40 @@ export function buildMemoryTools(store, extraction) {
                 const lines = entries.map((e) => `- **${e.name}** (${e.type}) [${e.filename}]: ${e.description}`);
                 return { title, output: `${entries.length} memories found:\n${lines.join("\n")}` };
             },
-        }),
-        memory_search: tool({
+        },
+        {
+            name: "memory_search",
             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"),
+                query: z.string().describe("Search query — searches across name, description, and content"),
             },
             async execute(args) {
-                const results = store.search(args.query);
-                const title = memorySearchTitle(args.query, results.length);
+                const query = str(args, "query");
+                const results = store.search(query);
+                const title = memorySearchTitle(query, results.length);
                 if (results.length === 0)
-                    return { title, output: `No memories matching "${args.query}".` };
+                    return { title, output: `No memories matching "${query}".` };
                 const lines = results.map((e) => `- **${e.name}** (${e.type}) [${e.filename}]: ${e.description}\n  Content: ${e.body.slice(0, 200)}${e.body.length > 200 ? "..." : ""}`);
-                return { title, output: `${results.length} matches for "${args.query}":\n${lines.join("\n")}` };
+                return { title, output: `${results.length} matches for "${query}":\n${lines.join("\n")}` };
             },
-        }),
-        memory_read: tool({
+        },
+        {
+            name: "memory_read",
             description: "Read the full content of a specific memory file.",
             args: {
-                file_name: tool.schema.string().describe(`File name of the memory to read (${FILE_NAME_HINT})`),
+                file_name: z.string().describe(`File name of the memory to read (${FILE_NAME_HINT})`),
             },
             async execute(args) {
-                const entry = store.read(args.file_name);
+                const fileName = str(args, "file_name");
+                const entry = store.read(fileName);
                 if (!entry)
-                    return { title: args.file_name, output: `Memory "${args.file_name}" not found.` };
+                    return { title: fileName, output: `Memory "${fileName}" not found.` };
                 return {
-                    title: args.file_name,
+                    title: fileName,
                     output: `# ${entry.name}\n**Type:** ${entry.type}\n**Description:** ${entry.description}\n\n${entry.body}`,
                 };
             },
-        }),
-    };
+        },
+    ];
 }

package/dist/util/exclusiveFile.d.ts

@@ -1,5 +1,5 @@
 export declare function createExclusiveSync(path: string, content: string): boolean;
-export declare function writeFileAtomicSync(path: string, content: string): void;
+export declare function writeFileAtomicSync(path: string, content: string, rename?: (from: string, to: string) => void): void;
 export declare function fileAgeMs(path: string, now?: number): number | undefined;
 export declare function sleepSync(ms: number): void;
 export declare function unlinkWithRetry(path: string, attempts?: number): boolean;

package/dist/util/exclusiveFile.js

@@ -6,7 +6,7 @@
 // Writing the content to a private temp file and hard-linking it into place is atomic: `link(2)`
 // either creates the full file or fails with EEXIST. Filesystems without hard links fall back to `wx`.
 import { randomBytes } from "node:crypto";
-import { linkSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, linkSync, lstatSync, mkdirSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 function errorCode(error) {
     return error?.code;
@@ -43,23 +43,115 @@ export function createExclusiveSync(path, content) {
     }
 }
 // Replaces a file's content atomically (temp file + rename), so a reader such as Claude Code or
-// another plugin sharing the memory folder never sees a half-written file.
-export function writeFileAtomicSync(path, content) {
+// another plugin sharing the memory folder never sees a half-written file. The file's permission
+// bits are carried over, and a symbolic link (a dotfiles-managed MEMORY.md) stays a link: the regular
+// file at the end of its chain is replaced instead. Where a rename cannot do the job it writes in
+// place, which is not atomic but is what `writeFileSync` did before: through a link whose target is
+// missing, is not a regular file or sits in a directory that takes no new files, and, on Windows,
+// over a file another process keeps open. A replaced file is a new inode, so unlike `writeFileSync`
+// it does not keep hard links, owner, ACLs or extended attributes, and write protection on the file
+// itself (rather than on its directory) does not stop it.
+//
+// Callers own containment: the memory store checks memory-file names with `resolveMemoryFilePath`
+// (links must stay inside the memory directory), while MEMORY.md is followed wherever it points.
+export function writeFileAtomicSync(path, content, rename = renameSync) {
+    const link = isSymbolicLink(path);
+    const target = link ? replaceableLinkTarget(path) : path;
+    if (target === undefined) {
+        writeFileSync(path, content, "utf-8");
+        return;
+    }
     mkdirSync(dirname(path), { recursive: true });
-    const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    const mode = existingMode(target);
+    const tmp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    try {
+        // Created with the target's mode (the umask can only narrow it), so the new content is never
+        // more readable than the file it replaces, not even for a moment.
+        writeFileSync(tmp, content, { encoding: "utf-8", mode });
+    }
+    catch (error) {
+        unlinkWithRetry(tmp);
+        if (!link || !TEMP_REFUSED_CODES.includes(errorCode(error) ?? ""))
+            throw error;
+        writeFileSync(path, content, "utf-8");
+        return;
+    }
+    let renamed = false;
+    try {
+        if (mode !== undefined)
+            restoreMode(tmp, mode);
+        renamed = renameWithRetry(tmp, target, rename);
+        if (!renamed)
+            writeFileSync(target, content, "utf-8");
+    }
+    finally {
+        if (!renamed)
+            unlinkWithRetry(tmp);
+    }
+}
+// Codes meaning no temp file can be created next to a link's target (a read-only dotfiles directory,
+// /dev): the write then goes through the link instead.
+const TEMP_REFUSED_CODES = ["EACCES", "EPERM", "EROFS"];
+function isSymbolicLink(path) {
     try {
-        writeFileSync(tmp, content, "utf-8");
-        renameSync(tmp, path);
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+// The regular file at the end of a link's chain, which the rename replaces so the link survives.
+// `undefined` when there is none (a dangling link, a link to a device or a directory, or one Bun
+// cannot resolve, e.g. to an unreadable file): the write then goes through the link, which also
+// creates a missing target as `writeFileSync` did. A looping link is replaced like a plain file.
+function replaceableLinkTarget(path) {
+    try {
+        const target = realpathSync(path);
+        return statSync(target).isFile() ? target : undefined;
     }
     catch (error) {
+        return errorCode(error) === "ELOOP" ? path : undefined;
+    }
+}
+function existingMode(path) {
+    try {
+        return statSync(path).mode & 0o7777;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Puts back bits the umask stripped when the temp file was created. Best effort: some mounts (FAT,
+// exFAT or CIFS owned by another user, some FUSE filesystems) refuse chmod, and the file then keeps
+// the mode they give it, as it did before modes were carried over.
+function restoreMode(path, mode) {
+    try {
+        chmodSync(path, mode);
+    }
+    catch {
+        // the mount decides the mode
+    }
+}
+// Windows refuses to replace a file that another process holds open without FILE_SHARE_DELETE, as
+// EPERM, EBUSY or EACCES, usually for a few milliseconds. Elsewhere these codes are permanent
+// (immutable files, sticky directories, ACLs), so they are thrown at once.
+const RENAME_BUSY_CODES = ["EPERM", "EBUSY", "EACCES"];
+const RENAME_ATTEMPTS = 5;
+// False when Windows still refuses after RENAME_ATTEMPTS tries (2, 4, 6 and 8 ms apart).
+function renameWithRetry(tmp, target, rename) {
+    for (let attempt = 1; attempt <= RENAME_ATTEMPTS; attempt++) {
         try {
-            unlinkSync(tmp);
+            rename(tmp, target);
+            return true;
         }
-        catch {
-            // never created
+        catch (error) {
+            if (process.platform !== "win32" || !RENAME_BUSY_CODES.includes(errorCode(error) ?? ""))
+                throw error;
+            if (attempt < RENAME_ATTEMPTS)
+                sleepSync(2 * attempt);
         }
-        throw error;
     }
+    return false;
 }
 export function fileAgeMs(path, now = Date.now()) {
     try {

package/dist/util/log.d.ts

@@ -1,6 +1,4 @@
-import type { OpencodeClient } from "../sdk.js";
 export declare const LOG_SERVICE = "opencode-claude-memory";
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export type Logger = (level: LogLevel, message: string, extra?: Record<string, unknown>) => void;
 export declare function getErrorMessage(error: unknown): string;
-export declare function createLogger(client: OpencodeClient | undefined, directory: string): Logger;

package/dist/util/log.js

@@ -1,3 +1,5 @@
+// Host-independent logging types. Each host adapter supplies its own sink (V1: the OpenCode service
+// log, V2: a file in the plugin state directory); stderr is never used because it ends up in the UI.
 export const LOG_SERVICE = "opencode-claude-memory";
 export function getErrorMessage(error) {
     if (error instanceof Error)
@@ -9,21 +11,3 @@ export function getErrorMessage(error) {
     }
     return String(error);
 }
-// Logging goes through the OpenCode service log only. stderr is rendered into the chat UI, so a
-// failing background task must never write there. Every call is best-effort and never throws.
-export function createLogger(client, directory) {
-    return (level, message, extra) => {
-        const log = client?.app?.log;
-        if (typeof log !== "function")
-            return;
-        try {
-            void Promise.resolve(log.call(client?.app, {
-                body: { service: LOG_SERVICE, level, message, extra },
-                query: { directory },
-            })).catch(() => { });
-        }
-        catch {
-            // best-effort
-        }
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "description": "OpenCode plugin for Claude Code memory: persistent, local-first shared memory with Claude Code-compatible Markdown files, LLM recall, in-process auto extraction, and auto-dream consolidation",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "dist"
   ],
   "engines": {
-    "opencode": ">=1.18.0"
+    "opencode": ">=1.18.29"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -58,14 +58,26 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.18.0"
+    "@opencode-ai/plugin": ">=1.18.29",
+    "@opencode/plugin": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "zod": "^3.24.0"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2",
     "@opencode-ai/plugin": "^1.18.16",
+    "@opencode/client": "2.0.22",
+    "@opencode/plugin": "2.0.22",
+    "@opencode/schema": "2.0.22",
     "bun-types": "^1.3.11",
     "conventional-changelog-conventionalcommits": "^9",
     "typescript": "^6.0.2"

package/dist/hooks/ignore.js

@@ -1,53 +0,0 @@
-// "Ignore memory" handling. Claude Code's semantics are session-scoped: once the user asks to
-// ignore memory, it stays ignored until they explicitly ask for it back.
-import { AUTO_MEMORY_MARKER } from "../prompt/systemPrompt.js";
-import { extractUserQuery, roleOf } from "./messages.js";
-export function detectIgnoreMemory(query) {
-    if (!query)
-        return false;
-    const normalized = query.toLowerCase();
-    return (/(ignore|don't use|do not use|without|skip)\s+(the\s+|your\s+)?memory/.test(normalized) ||
-        /memory\s+(should be|must be)?\s*ignored/.test(normalized));
-}
-export function detectResumeMemory(query) {
-    if (!query)
-        return false;
-    const normalized = query.toLowerCase();
-    return (/(use|enable|resume|restore|bring back|turn on)\s+(the\s+|your\s+)?memory(\s+again)?/.test(normalized) ||
-        /memory\s+(back\s+)?on\b/.test(normalized) ||
-        /stop ignoring\s+(the\s+|your\s+)?memory/.test(normalized));
-}
-// Replays every user message in order and returns whether memory is ignored at the end. Used to
-// rebuild session state that the coordinator no longer holds (process restart, cache eviction), so
-// an "ignore memory" said earlier in the session keeps applying without the user repeating it.
-export function deriveIgnoredFromHistory(messages) {
-    let ignored = false;
-    for (const message of messages) {
-        if (roleOf(message) !== "user")
-            continue;
-        const query = extractUserQuery(message);
-        if (detectIgnoreMemory(query))
-            ignored = true;
-        else if (ignored && detectResumeMemory(query))
-            ignored = false;
-    }
-    return ignored;
-}
-export function isAutoMemoryPart(part) {
-    if (!part || typeof part !== "object")
-        return false;
-    const text = part.text;
-    return typeof text === "string" && text.trimStart().startsWith(AUTO_MEMORY_MARKER);
-}
-// Drops the plugin's own system segment from system-role messages; messages left without parts
-// are removed entirely.
-export function stripAutoMemoryParts(messages) {
-    return messages
-        .map((message) => {
-        if (roleOf(message) !== "system" || !Array.isArray(message.parts))
-            return message;
-        const parts = message.parts.filter((part) => !isAutoMemoryPart(part));
-        return parts.length === message.parts.length ? message : { ...message, parts };
-    })
-        .filter((message) => !Array.isArray(message.parts) || message.parts.length > 0);
-}