opencode-claude-memory 2.1.0 → 2.1.2

package/README.md

@@ -144,7 +144,7 @@ The V2 plugin API exposes less than V1, so a few behaviours differ:
 | Memory directory | `~/.claude/projects/<sanitized canonical git root>/memory/` | identical (`sanitizePath`, worktree → main repo resolution ported byte for byte) |
 | File format | Markdown + `name` / `description` / `type` frontmatter | identical; frontmatter parsed only within the first 30 lines, as in Claude Code |
 | Taxonomy | `user`, `feedback`, `project`, `reference` | identical |
-| `MEMORY.md` | one-line pointers, hand-organisable | read with the same truncation rules; written with minimal line-level edits |
+| `MEMORY.md` | one-line pointers, hand-organisable | read with the same truncation rules; written with minimal line-level edits, hand-written pointer lines are never replaced |
 | Sub-directories | `team/x.md` etc. | scanned, recalled and addressable from every tool |
 | System prompt | memory instructions + index + recalled memories | ported sections (`memoryTypes.ts`, `memdir.ts`) |
 | Recall | LLM side query | LLM side query (`findRelevantMemories.ts` port): a hidden child session on 1.x, a `generate.text` call on 2.x |

package/dist/host/v2/agents.d.ts

@@ -3,6 +3,13 @@ import type { MemoryAgents } from "../../config.js";
 import type { PermissionRule } from "./fork.js";
 export type { PermissionRule };
 export declare const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
+export declare const PERMISSIONS_PROBE_AGENT = "opencode-memory-permissions-probe";
 export declare function sandboxRules(allowedTools: readonly string[]): PermissionRule[];
+export declare const PROBE_RULES: readonly PermissionRule[];
 export declare function userRules(rules: readonly PermissionRule[], baseline: readonly PermissionRule[]): PermissionRule[];
 export declare function applyMemoryAgents(editor: AgentEditor, agents: MemoryAgents): void;
+export declare function ownAgentRules(resolved: readonly PermissionRule[], sandbox: readonly PermissionRule[], probe: readonly PermissionRule[]): PermissionRule[] | undefined;
+export declare function forkSessionRules(sandbox: readonly PermissionRule[], resolved: readonly PermissionRule[] | undefined, probe: readonly PermissionRule[] | undefined): {
+    rules: PermissionRule[];
+    own: boolean;
+};

package/dist/host/v2/agents.js

@@ -1,19 +1,26 @@
 import { memoryAgentDefaults } from "../../agents.js";
 // A throwaway id used to read the host's default ruleset inside the same draft.
 export const BASELINE_PROBE_AGENT = "opencode-memory-baseline-probe";
+// A hidden, deny-all agent that is kept: every rule after its own PROBE_RULES was appended to all
+// agents by a later transform (the global `permissions`, the browser plugin's `browser` deny). It
+// tells the fork which part of a memory agent's resolved ruleset is global and which is its own.
+export const PERMISSIONS_PROBE_AGENT = "opencode-memory-permissions-probe";
 export function sandboxRules(allowedTools) {
     return [
         { action: "*", resource: "*", effect: "deny" },
         ...allowedTools.map((tool) => ({ action: tool, resource: "*", effect: "allow" })),
     ];
 }
+export const PROBE_RULES = sandboxRules([]);
 function ruleKey(rule) {
     return `${rule.action}\u0000${rule.resource}\u0000${rule.effect}`;
 }
+function startsWith(rules, prefix) {
+    return prefix.every((rule, index) => rules[index] !== undefined && ruleKey(rules[index]) === ruleKey(rule));
+}
 // The user's own rules: the agent's ruleset minus the host defaults every agent starts with.
 export function userRules(rules, baseline) {
-    const prefix = baseline.every((rule, index) => rules[index] && ruleKey(rules[index]) === ruleKey(rule));
-    if (prefix)
+    if (startsWith(rules, baseline))
         return rules.slice(baseline.length).map((rule) => ({ ...rule }));
     const base = new Set(baseline.map(ruleKey));
     return rules.filter((rule) => !base.has(ruleKey(rule))).map((rule) => ({ ...rule }));
@@ -22,6 +29,12 @@ export function applyMemoryAgents(editor, agents) {
     editor.update(BASELINE_PROBE_AGENT, () => { });
     const baseline = (editor.get(BASELINE_PROBE_AGENT)?.permissions ?? []).map((rule) => ({ ...rule }));
     editor.remove(BASELINE_PROBE_AGENT);
+    editor.update(PERMISSIONS_PROBE_AGENT, (agent) => {
+        agent.mode = "subagent";
+        agent.hidden = true;
+        agent.description = "opencode-claude-memory internal: permission probe, never runs";
+        agent.permissions = PROBE_RULES.map((rule) => ({ ...rule }));
+    });
     for (const [name, defaults] of Object.entries(memoryAgentDefaults(agents))) {
         applyAgent(editor, name, defaults, baseline);
     }
@@ -39,3 +52,32 @@ function applyAgent(editor, name, defaults, baseline) {
         agent.permissions = [...sandboxRules(defaults.allowedTools), ...configured];
     });
 }
+// The memory agent's own rules: what follows the sandbox in its resolved ruleset, minus the rules
+// appended to every agent (the probe's tail, removed as an ordered subsequence). These are the
+// user's `agents.<name>.permissions` (and rules of a plugin that configured the agent first).
+// undefined when either ruleset does not have the layout this plugin wrote.
+export function ownAgentRules(resolved, sandbox, probe) {
+    if (!startsWith(resolved, sandbox) || !startsWith(probe, PROBE_RULES))
+        return undefined;
+    const shared = probe.slice(PROBE_RULES.length);
+    const own = [];
+    let next = 0;
+    for (const rule of resolved.slice(sandbox.length)) {
+        const expected = shared[next];
+        if (expected && ruleKey(expected) === ruleKey(rule))
+            next += 1;
+        else
+            own.push({ ...rule });
+    }
+    return next === shared.length ? own : undefined;
+}
+// The fork's session ruleset. The host evaluates `[...agent rules, ...session rules]` last match
+// wins, and checks deny before any saved "always" approval, so a session ruleset that starts with the
+// sandbox overrides every global rule (allow, ask, or a rule for `shell`, `read`,
+// `external_directory`, ...). The agent's own rules follow it, so a user override in
+// `agents.<name>.permissions` still widens or narrows the sandbox. Global rules no longer reach the
+// fork; without a recoverable layout the fork runs under the bare sandbox.
+export function forkSessionRules(sandbox, resolved, probe) {
+    const own = resolved && probe ? ownAgentRules(resolved, sandbox, probe) : undefined;
+    return { rules: [...sandbox.map((rule) => ({ ...rule })), ...(own ?? [])], own: own !== undefined };
+}

package/dist/host/v2/host.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from "../../util/log.js";
 import { type GenerateInput, type MemoryHost } from "../types.js";
 import { type ModelRef, type PermissionRule, type V2SessionApi } from "./fork.js";
 export type V2AgentInfo = {
@@ -14,6 +15,7 @@ export type V2HostOptions = {
     }>;
     getAgent: (name: string) => Promise<V2AgentInfo | undefined>;
     sandboxFor: (name: string) => PermissionRule[];
+    log?: Logger;
 };
 export declare function buildGeneratePrompt(input: Pick<GenerateInput, "system" | "text" | "schema">): string;
 export declare class V2Host implements MemoryHost {

package/dist/host/v2/host.js

@@ -1,13 +1,6 @@
-// MemoryHost over the V2 plugin context (`setup` entry).
-//
-// Differences from V1 that the coordinators see through the interface:
-// - readTranscript only has the messages after the last compaction (`session.context`), so a
-//   watermark message that was compacted away yields `truncated: true`;
-// - listSessions is unavailable (the plugin API cannot list sessions);
-// - generate is a one-shot `generate.text` call: no system prompt, no structured output, so both
-//   are folded into the prompt and the caller parses the text.
 import { withDeadline } from "../../util/timeout.js";
 import { SDK_READ_TIMEOUT_MS } from "../types.js";
+import { forkSessionRules, PERMISSIONS_PROBE_AGENT } from "./agents.js";
 import { runV2Fork } from "./fork.js";
 import { toTranscript } from "./transcript.js";
 // The V2 plugin calls take no AbortSignal; withDeadline only bounds the wait.
@@ -63,12 +56,18 @@ export class V2Host {
         }
     }
     async fork(input) {
-        // The resolved agent's ruleset (sandbox + the user's overrides) is also passed as the session
-        // ruleset; without one the child would inherit its parent's session permissions.
-        const agent = await this.agent(input.agent);
-        const permissions = agent?.permissions?.length
-            ? agent.permissions.map((rule) => ({ ...rule }))
-            : this.options.sandboxFor(input.agent);
+        // The resolved agent ruleset carries the global `permissions` after the sandbox (see agents.ts),
+        // so it is never passed through: the session ruleset is the sandbox followed by the agent's own
+        // rules only. Without an explicit one the child would also inherit its parent's session rules.
+        const sandbox = this.options.sandboxFor(input.agent);
+        const [agent, probe] = await Promise.all([this.agent(input.agent), this.agent(PERMISSIONS_PROBE_AGENT)]);
+        const { rules: permissions, own } = forkSessionRules(sandbox, agent?.permissions, probe?.permissions);
+        if (!own && agent?.permissions) {
+            this.options.log?.("warn", "Memory agent overrides could not be told apart from global rules; forking with the bare sandbox", {
+                agent: input.agent,
+            });
+        }
+        this.options.log?.("debug", "Memory fork session permissions", { agent: input.agent, permissions });
         return runV2Fork(this.options.session, {
             ...input,
             permissions,

package/dist/host/v2/plugin.js

@@ -52,6 +52,7 @@ export const createV2Setup = (env, homeDir) => async (ctx) => {
             return agent?.data;
         },
         sandboxFor: (name) => sandboxRules(defaults[name]?.allowedTools ?? []),
+        log,
     });
     const deps = { store, config, host, owned, log };
     const recall = new RecallCoordinator(deps);

package/dist/store/MemoryStore.d.ts

@@ -43,5 +43,4 @@ export declare class MemoryStore {
     search(query: string): MemoryEntry[];
     readIndex(): string;
     private writeIndex;
-    private isUnchanged;
 }

package/dist/store/MemoryStore.js

@@ -2,7 +2,7 @@ import { cpSync, lstatSync, mkdirSync, readFileSync, realpathSync, statSync, unl
 import { dirname, join } from "node:path";
 import { writeFileAtomicSync } from "../util/exclusiveFile.js";
 import { buildFrontmatter, editFrontmatter, FRONTMATTER_MAX_LINES, frontmatterKeys, ORIGIN, parseFrontmatter, parseMemoryType, } from "./frontmatter.js";
-import { buildIndexPointer, indexHasPointer, readIndexFile, removeIndexLine, upsertIndexLine } from "./indexFile.js";
+import { buildIndexPointer, findIndexPointerLine, 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";
 // Owns the resolved memory paths for one project. Path resolution (git root, worktree canonical
@@ -65,9 +65,14 @@ export class MemoryStore {
         }
         const existing = readTextFile(filePath);
         const parsed = existing === null ? null : parseFrontmatter(existing);
-        const pointer = buildIndexPointer(relativePath, input.name, input.description);
-        if (parsed !== null && this.isUnchanged(parsed, relativePath, input, pointer)) {
-            return { filePath, fileName: relativePath, unchanged: true };
+        const index = this.readIndex();
+        const nextIndex = indexAfterSave(index, relativePath, input, parsed);
+        if (parsed !== null && isUnchanged(parsed, relativePath, input)) {
+            // The same memory: at most a missing index pointer is added, the file itself is not rewritten.
+            if (nextIndex === index)
+                return { filePath, fileName: relativePath, unchanged: true };
+            this.writeIndex(nextIndex);
+            return { filePath, fileName: relativePath, unchanged: false };
         }
         const modified = this.now().toISOString();
         const fileContent = existing === null || parsed === null
@@ -83,7 +88,8 @@ export class MemoryStore {
             throw new Error(`Memory "${relativePath}" frontmatter would exceed ${FRONTMATTER_MAX_LINES} lines; trim its frontmatter first`);
         }
         writeFileAtomicSync(filePath, fileContent);
-        this.writeIndex(upsertIndexLine(this.readIndex(), relativePath, pointer));
+        if (nextIndex !== index)
+            this.writeIndex(nextIndex);
         return { filePath, fileName: relativePath, unchanged: false };
     }
     // Deleting a memory that is not purely this plugin's (Claude Code's, dsh's, a hand-written one, or
@@ -123,19 +129,41 @@ export class MemoryStore {
     writeIndex(content) {
         writeFileAtomicSync(this.entrypoint, content);
     }
-    // Unchanged means the same name, description, type and body, whatever else the frontmatter
-    // holds, so an identical re-save neither bumps `modified` nor stamps provenance.
-    isUnchanged(parsed, relativePath, input, pointer) {
-        const { frontmatter, body, hasFrontmatter } = parsed;
-        if (!hasFrontmatter)
-            return false;
-        // Missing fields compare as the defaults the scanner (and `read()`) reports for them.
-        const same = (frontmatter.name ?? nameFromFilename(relativePath)) === input.name &&
-            (frontmatter.description ?? "") === input.description &&
-            (parseMemoryType(frontmatter.type) ?? "user") === input.type &&
-            body.replace(/\r\n/g, "\n") === input.content.trim().replace(/\r\n/g, "\n");
-        return same && indexHasPointer(this.readIndex(), pointer);
-    }
+}
+// A memory's name and description as the scanner (and `read()`) reports them: missing fields
+// count as their defaults.
+function previousFields(parsed, relativePath) {
+    return {
+        name: parsed.frontmatter.name ?? nameFromFilename(relativePath),
+        description: parsed.frontmatter.description ?? "",
+    };
+}
+// Unchanged means the same name, description, type and body, whatever else the frontmatter holds,
+// so an identical re-save neither bumps `modified` nor stamps provenance.
+function isUnchanged(parsed, relativePath, input) {
+    if (!parsed.hasFrontmatter)
+        return false;
+    const before = previousFields(parsed, relativePath);
+    return (before.name === input.name &&
+        before.description === input.description &&
+        (parseMemoryType(parsed.frontmatter.type) ?? "user") === input.type &&
+        parsed.body.replace(/\r\n/g, "\n") === input.content.trim().replace(/\r\n/g, "\n"));
+}
+// MEMORY.md after a save. Index lines are often hand-written (Claude Code's format is
+// `- [Title](file.md) — one-line hook`, and neither part has to repeat the frontmatter), so an
+// existing pointer is kept unless it is still exactly the line this plugin generates from the
+// memory's previous name and description: only such a line follows a new name or description. A
+// memory without a pointer gains one. No other line is touched.
+function indexAfterSave(raw, relativePath, input, parsed) {
+    const pointer = buildIndexPointer(relativePath, input.name, input.description);
+    const current = findIndexPointerLine(raw, relativePath);
+    if (current === undefined)
+        return upsertIndexLine(raw, relativePath, pointer);
+    if (current === pointer || parsed === null)
+        return raw;
+    const before = previousFields(parsed, relativePath);
+    const generatedBefore = buildIndexPointer(relativePath, before.name, before.description);
+    return current === generatedBefore ? upsertIndexLine(raw, relativePath, pointer) : raw;
 }
 // The frontmatter keys of a memory this plugin creates (buildFrontmatter), each on one line; its own
 // later saves keep exactly this set.

package/dist/store/indexFile.d.ts

@@ -2,6 +2,7 @@ export declare const POINTER_RE: RegExp;
 export declare function readIndexFile(entrypoint: string): string;
 export declare function buildIndexPointer(fileName: string, name: string, description: string): string;
 export declare function indexHasPointer(raw: string, pointer: string): boolean;
+export declare function findIndexPointerLine(raw: string, fileName: string): string | undefined;
 export declare function pointerTarget(line: string): string | undefined;
 export declare function upsertIndexLine(raw: string, fileName: string, pointer: string): string;
 export declare function removeIndexLine(raw: string, fileName: string): string;

package/dist/store/indexFile.js

@@ -20,6 +20,14 @@ export function buildIndexPointer(fileName, name, description) {
 export function indexHasPointer(raw, pointer) {
     return raw.split(/\r?\n/).some((line) => line.trimEnd() === pointer);
 }
+// The first pointer line for `fileName` without its indentation and trailing whitespace, or
+// undefined when the index has none.
+export function findIndexPointerLine(raw, fileName) {
+    return raw
+        .split(/\r?\n/)
+        .find((line) => pointerTarget(line) === fileName)
+        ?.trim();
+}
 function detectEol(raw) {
     return raw.includes("\r\n") ? "\r\n" : "\n";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-memory",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "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",