opencode-claude-memory 1.7.7 → 1.7.8

package/dist/extraction/forkSession.js

@@ -0,0 +1,133 @@
+// Lifecycle of a plugin-owned child session: create → prompt (with timeout) → abort on timeout →
+// delete (best-effort). Shared by recall selection, extraction and auto-dream.
+//
+// Every stage has its own deadline and AbortSignal: the SDK client disables fetch timeouts, so a
+// hung `create`, `abort` or `delete` would otherwise pin the caller (and with it the extraction
+// queue and the maintenance lock) forever. `onFinished` always fires, even when cleanup timed out.
+import { unwrapData } from "../sdk.js";
+import { TimeoutError, withDeadline } from "../util/timeout.js";
+export const FORK_CREATE_TIMEOUT_MS = 30_000;
+export const FORK_CLEANUP_TIMEOUT_MS = 15_000;
+export class ForkSessionTimeoutError extends Error {
+    constructor(title, timeoutMs) {
+        super(`${title} timed out after ${timeoutMs}ms`);
+        this.name = "ForkSessionTimeoutError";
+    }
+}
+export function extractSessionID(response) {
+    const data = unwrapData(response);
+    if (!data || typeof data !== "object")
+        return undefined;
+    const id = data.id ?? data.sessionID;
+    return typeof id === "string" ? id : undefined;
+}
+function describeError(error) {
+    if (error && typeof error === "object") {
+        const named = error;
+        const message = named.data?.message ?? named.message;
+        if (typeof message === "string") {
+            return typeof named.name === "string" ? `${named.name}: ${message}` : message;
+        }
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
+// The SDK client never throws (`ThrowOnError = false`): HTTP failures arrive as `{ error }` and a
+// model failure inside the fork arrives as a normal assistant message carrying `info.error`. Both
+// must count as a failed fork, otherwise the caller would advance its watermark over nothing.
+export function forkFailure(response) {
+    if (!response || typeof response !== "object")
+        return undefined;
+    const transport = response.error;
+    if (transport !== undefined && transport !== null)
+        return describeError(transport);
+    const data = unwrapData(response);
+    const modelError = data && typeof data === "object" ? data.info?.error : undefined;
+    if (modelError !== undefined && modelError !== null)
+        return describeError(modelError);
+    return undefined;
+}
+export class ForkSessionError extends Error {
+    constructor(title, detail) {
+        super(`${title}: ${detail}`);
+        this.name = "ForkSessionError";
+    }
+}
+// Security: forks run on raw, potentially untrusted transcript content (fetched pages, tool output).
+// Callers restrict `tools` to the memory tools; the per-stage deadlines guarantee the caller gets
+// control back even when the fork hangs on a permission prompt or the server stops answering.
+export async function runForkSession(input) {
+    const { client, directory } = input;
+    const createTimeoutMs = input.createTimeoutMs ?? FORK_CREATE_TIMEOUT_MS;
+    const cleanupTimeoutMs = input.cleanupTimeoutMs ?? FORK_CLEANUP_TIMEOUT_MS;
+    const created = await withDeadline(`${input.title} session.create`, createTimeoutMs, (signal) => client.session.create({
+        body: { parentID: input.parentSessionID, title: input.title },
+        query: { directory },
+        signal,
+    }));
+    const createFailure = forkFailure(created);
+    if (createFailure)
+        throw new ForkSessionError(input.title, `session.create failed (${createFailure})`);
+    const forkID = extractSessionID(created);
+    if (!forkID)
+        throw new ForkSessionError(input.title, "session.create returned no session id");
+    input.onCreated?.(forkID);
+    // `format` (structured output) is accepted by the server but missing from the v1 SDK body type.
+    const body = {
+        agent: input.agent,
+        parts: input.parts,
+    };
+    if (input.system !== undefined)
+        body.system = input.system;
+    if (input.tools !== undefined)
+        body.tools = input.tools;
+    if (input.format !== undefined)
+        body.format = input.format;
+    if (input.model !== undefined)
+        body.model = input.model;
+    const cleanup = async (stage) => {
+        try {
+            await withDeadline(`${input.title} session.${stage}`, cleanupTimeoutMs, (signal) => stage === "abort"
+                ? client.session.abort({ path: { id: forkID }, query: { directory }, signal })
+                : client.session.delete({ path: { id: forkID }, query: { directory }, signal }));
+        }
+        catch (error) {
+            input.onCleanupFailed?.(forkID, stage, error);
+        }
+    };
+    let timedOut = false;
+    try {
+        let response;
+        try {
+            response = await withDeadline(`${input.title} session.prompt`, input.timeoutMs, (signal) => client.session.prompt({ path: { id: forkID }, query: { directory }, body: body, signal }));
+        }
+        catch (error) {
+            if (error instanceof TimeoutError) {
+                timedOut = true;
+                throw new ForkSessionTimeoutError(input.title, input.timeoutMs);
+            }
+            throw error;
+        }
+        const failure = forkFailure(response);
+        if (failure)
+            throw new ForkSessionError(input.title, failure);
+        return response;
+    }
+    finally {
+        try {
+            // On timeout the server is still running the fork: stop it before deleting the session so it
+            // does not keep inserting parts for a row that no longer exists.
+            if (timedOut)
+                await cleanup("abort");
+            await cleanup("delete");
+        }
+        finally {
+            input.onFinished?.(forkID);
+        }
+    }
+}

package/dist/extraction/lock.d.ts

@@ -0,0 +1,29 @@
+export declare const MAINTENANCE_STALE_LOCK_MS: number;
+export declare const MAINTENANCE_HEARTBEAT_MS: number;
+export declare const LOCK_INIT_GRACE_MS = 5000;
+export declare const REAP_LOCK_STALE_MS = 30000;
+export type LockContent = {
+    pid: number;
+    token: string;
+    startedAt: number;
+    heartbeatAt: number;
+};
+export declare class MaintenanceLock {
+    readonly lockPath: string;
+    private readonly now;
+    private readonly pid;
+    private readonly alive;
+    private token;
+    private heartbeat;
+    constructor(lockPath: string, now?: () => number, pid?: number, alive?: (pid: number) => boolean);
+    get held(): boolean;
+    private readHolder;
+    private isLive;
+    isHeld(): boolean;
+    tryAcquire(): boolean;
+    private reap;
+    refresh(): boolean;
+    release(): void;
+    private startHeartbeat;
+    private stopHeartbeat;
+}

package/dist/extraction/lock.js

@@ -0,0 +1,191 @@
+// Cross-process mutex for memory maintenance (extraction forks and auto-dream) on one project, so two
+// OpenCode processes on the same repository never write memory files concurrently (#30).
+//
+// Protocol:
+// - The lock file is created atomically with its full content (`createExclusiveSync`), so no
+//   process ever sees a half-written lock. Content: `{ pid, token, startedAt, heartbeatAt }`.
+// - Every acquisition has a unique token. `release()` and `refresh()` only touch the file while it
+//   still carries this token, so a slow old holder can never remove or overwrite its successor.
+// - A live holder refreshes `heartbeatAt` every MAINTENANCE_HEARTBEAT_MS; a lock is stale when its
+//   holder is dead or its heartbeat is older than MAINTENANCE_STALE_LOCK_MS. A fixed wall-clock
+//   limit is *not* used: a fork that legitimately runs long keeps its lock alive by heartbeat.
+// - A stale lock is reaped under a second, short-lived reap lock: only one process removes it,
+//   and only after re-reading it and confirming it is still the same stale content. A lock that
+//   was just created by someone else can therefore not be removed by a concurrent reaper.
+// - Contention is skipped, not queued: the extraction watermark stays put and the next idle /
+//   start-up retries.
+import { randomBytes } from "node:crypto";
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { createExclusiveSync, fileAgeMs, unlinkWithRetry } from "../util/exclusiveFile.js";
+export const MAINTENANCE_STALE_LOCK_MS = 10 * 60 * 1000;
+export const MAINTENANCE_HEARTBEAT_MS = 60 * 1000;
+// A lock file whose content cannot be parsed is treated as "being written" for this long (real
+// clock, from its mtime) before it counts as garbage.
+export const LOCK_INIT_GRACE_MS = 5_000;
+export const REAP_LOCK_STALE_MS = 30_000;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export class MaintenanceLock {
+    lockPath;
+    now;
+    pid;
+    alive;
+    token;
+    heartbeat;
+    constructor(lockPath, now = Date.now, pid = process.pid, alive = isProcessAlive) {
+        this.lockPath = lockPath;
+        this.now = now;
+        this.pid = pid;
+        this.alive = alive;
+    }
+    get held() {
+        return this.token !== undefined;
+    }
+    readHolder() {
+        let raw;
+        try {
+            raw = readFileSync(this.lockPath, "utf-8");
+        }
+        catch {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.pid !== "number" || typeof parsed.token !== "string")
+                return "unreadable";
+            const startedAt = typeof parsed.startedAt === "number" ? parsed.startedAt : 0;
+            const heartbeatAt = typeof parsed.heartbeatAt === "number" ? parsed.heartbeatAt : startedAt;
+            return { pid: parsed.pid, token: parsed.token, startedAt, heartbeatAt };
+        }
+        catch {
+            return "unreadable";
+        }
+    }
+    isLive(holder) {
+        if (holder === undefined)
+            return false;
+        if (holder === "unreadable") {
+            const age = fileAgeMs(this.lockPath);
+            return age !== undefined && age < LOCK_INIT_GRACE_MS;
+        }
+        if (holder.pid !== this.pid && !this.alive(holder.pid))
+            return false;
+        return this.now() - holder.heartbeatAt < MAINTENANCE_STALE_LOCK_MS;
+    }
+    isHeld() {
+        return this.isLive(this.readHolder());
+    }
+    tryAcquire() {
+        if (this.held)
+            return true;
+        const token = randomBytes(8).toString("hex");
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const now = this.now();
+            const content = { pid: this.pid, token, startedAt: now, heartbeatAt: now };
+            if (createExclusiveSync(this.lockPath, JSON.stringify(content))) {
+                this.token = token;
+                this.startHeartbeat();
+                return true;
+            }
+            const holder = this.readHolder();
+            if (this.isLive(holder))
+                return false;
+            if (!this.reap(holder))
+                return false;
+        }
+        return false;
+    }
+    // Removes a stale lock under the reap lock; returns false when someone else is reaping or the
+    // lock changed hands meanwhile (a fresh holder must never be removed).
+    reap(seen) {
+        const reapPath = `${this.lockPath}.reap`;
+        if (!createExclusiveSync(reapPath, String(this.pid))) {
+            const age = fileAgeMs(reapPath);
+            if (age === undefined || age < REAP_LOCK_STALE_MS)
+                return false;
+            try {
+                unlinkSync(reapPath);
+            }
+            catch {
+                return false;
+            }
+            if (!createExclusiveSync(reapPath, String(this.pid)))
+                return false;
+        }
+        try {
+            const current = this.readHolder();
+            if (current === undefined)
+                return true;
+            if (this.isLive(current))
+                return false;
+            if (current !== "unreadable" && seen !== "unreadable" && seen !== undefined && current.token !== seen.token) {
+                return false;
+            }
+            unlinkSync(this.lockPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            try {
+                unlinkSync(reapPath);
+            }
+            catch {
+                // already gone
+            }
+        }
+    }
+    // Rewrites the heartbeat while the file still carries this acquisition's token.
+    refresh() {
+        if (!this.token)
+            return false;
+        const holder = this.readHolder();
+        if (holder === undefined || holder === "unreadable" || holder.token !== this.token)
+            return false;
+        const next = { ...holder, heartbeatAt: this.now() };
+        const tmp = `${this.lockPath}.${this.pid}.${this.token}.hb`;
+        try {
+            writeFileSync(tmp, JSON.stringify(next), "utf-8");
+            renameSync(tmp, this.lockPath);
+            return true;
+        }
+        catch {
+            try {
+                unlinkSync(tmp);
+            }
+            catch {
+                // nothing to clean
+            }
+            return false;
+        }
+    }
+    release() {
+        this.stopHeartbeat();
+        const token = this.token;
+        this.token = undefined;
+        if (!token)
+            return;
+        const holder = this.readHolder();
+        if (holder === undefined || holder === "unreadable" || holder.token !== token)
+            return;
+        unlinkWithRetry(this.lockPath);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeat = setInterval(() => void this.refresh(), MAINTENANCE_HEARTBEAT_MS);
+        this.heartbeat.unref?.();
+    }
+    stopHeartbeat() {
+        if (this.heartbeat)
+            clearInterval(this.heartbeat);
+        this.heartbeat = undefined;
+    }
+}

package/dist/extraction/prompts.d.ts

@@ -0,0 +1,5 @@
+export declare const EXTRACT_PROMPT = "You are now acting as the memory extraction subagent. The conversation below is reviewed for anything worth remembering for future sessions.\n\n## What to save\n\nUse the `memory_save` tool to persist memories. There are four types:\n\n1. **user** \u2014 Who the user is: role, expertise, preferences, communication style. Helps tailor future interactions.\n2. **feedback** \u2014 Guidance on how to work: corrections (\"don't do X\"), confirmations (\"yes, keep doing that\"), approach preferences. Include *why* so edge cases can be judged.\n3. **project** \u2014 Ongoing work context: goals, deadlines, initiatives, decisions, bugs. NOT derivable from code/git. Convert relative dates to absolute.\n4. **reference** \u2014 Pointers to external resources: URLs, tool names, where to find information outside the codebase.\n\n## What NOT to save\n\n- Code patterns, architecture, file structure \u2014 derivable from the codebase\n- Git history, recent changes \u2014 use `git log`/`git blame`\n- Debugging solutions \u2014 the fix is in the code\n- Anything already in AGENTS.md / project config files\n- Ephemeral task details or current conversation context\n- Information that is already covered by an existing memory (see the list below) unless you are updating it with something new\n\n## How to save\n\nFor each memory worth saving, call `memory_save` with:\n- `file_name`: descriptive slug (e.g., `user_role`, `feedback_testing_approach`)\n- `name`: short title\n- `description`: one-line description (used for relevance matching in future sessions)\n- `type`: one of user, feedback, project, reference\n- `content`: the memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines.\n\n## Instructions\n\n1. Analyze the conversation for memorable information\n2. The existing memories are listed below \u2014 do not duplicate them. To update one, call `memory_read` first and re-save it under the same `file_name` with the merged content\n3. Save each distinct memory as a separate entry\n4. If the conversation was trivial (e.g., just \"hello\" or a quick lookup), save nothing \u2014 that's fine\n5. Be selective: 0-3 memories per session is typical. Quality over quantity.\n6. Do NOT save a memory about the extraction process itself.\n7. Each `memory_save` call persists immediately and its result lists everything saved so far in this run. Never save the same `file_name` twice in one run. When nothing else is worth saving, stop calling tools and reply with a one-line summary.";
+export declare const EXTRACT_EXISTING_MEMORIES_HEADING = "## Existing memories";
+export declare function buildExtractionSystemPrompt(manifest: string): string;
+export declare const AUTODREAM_PROMPT = "You are performing an auto-dream memory consolidation pass.\n\nGoal: tighten and de-duplicate memory files so future sessions can orient faster.\n\n## Available tools\n- memory_list\n- memory_search\n- memory_read\n- memory_save\n- memory_delete\n\n## Phase 1 \u2014 Orient\n1. Use memory_list to inspect current memory inventory.\n2. Identify overlapping or stale entries that can be merged/updated/deleted.\n\n## Phase 2 \u2014 Consolidate\n1. Merge duplicates into a single stronger memory using memory_save.\n2. Rewrite vague descriptions so retrieval is easier and more precise.\n3. For feedback/project entries, ensure content is structured as:\n   - main rule/fact\n   - **Why:**\n   - **How to apply:**\n\n## Phase 3 \u2014 Prune\n1. Delete memories that are clearly obsolete, contradictory, or low-value.\n2. Keep total memory set concise and high signal.\n\n## Guardrails\n- Do NOT invent facts.\n- If confidence is low, keep existing memory instead of guessing.\n- If memory quality is already strong, make no changes and explicitly say so.\n\nReturn a short summary of what you updated, merged, or removed.";
+export declare const AUTODREAM_USER_MESSAGE = "Run the consolidation pass over the current memory directory now.";

package/dist/extraction/prompts.js

@@ -0,0 +1,78 @@
+// The only copies of the extraction and auto-dream prompts.
+export const EXTRACT_PROMPT = `You are now acting as the memory extraction subagent. The conversation below is reviewed for anything worth remembering for future sessions.
+
+## What to save
+
+Use the \`memory_save\` tool to persist memories. There are four types:
+
+1. **user** — Who the user is: role, expertise, preferences, communication style. Helps tailor future interactions.
+2. **feedback** — Guidance on how to work: corrections ("don't do X"), confirmations ("yes, keep doing that"), approach preferences. Include *why* so edge cases can be judged.
+3. **project** — Ongoing work context: goals, deadlines, initiatives, decisions, bugs. NOT derivable from code/git. Convert relative dates to absolute.
+4. **reference** — Pointers to external resources: URLs, tool names, where to find information outside the codebase.
+
+## What NOT to save
+
+- Code patterns, architecture, file structure — derivable from the codebase
+- Git history, recent changes — use \`git log\`/\`git blame\`
+- Debugging solutions — the fix is in the code
+- Anything already in AGENTS.md / project config files
+- Ephemeral task details or current conversation context
+- Information that is already covered by an existing memory (see the list below) unless you are updating it with something new
+
+## How to save
+
+For each memory worth saving, call \`memory_save\` with:
+- \`file_name\`: descriptive slug (e.g., \`user_role\`, \`feedback_testing_approach\`)
+- \`name\`: short title
+- \`description\`: one-line description (used for relevance matching in future sessions)
+- \`type\`: one of user, feedback, project, reference
+- \`content\`: the memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines.
+
+## Instructions
+
+1. Analyze the conversation for memorable information
+2. The existing memories are listed below — do not duplicate them. To update one, call \`memory_read\` first and re-save it under the same \`file_name\` with the merged content
+3. Save each distinct memory as a separate entry
+4. If the conversation was trivial (e.g., just "hello" or a quick lookup), save nothing — that's fine
+5. Be selective: 0-3 memories per session is typical. Quality over quantity.
+6. Do NOT save a memory about the extraction process itself.
+7. Each \`memory_save\` call persists immediately and its result lists everything saved so far in this run. Never save the same \`file_name\` twice in one run. When nothing else is worth saving, stop calling tools and reply with a one-line summary.`;
+export const EXTRACT_EXISTING_MEMORIES_HEADING = "## Existing memories";
+export function buildExtractionSystemPrompt(manifest) {
+    const inventory = manifest.trim() ? manifest.trim() : "(none yet)";
+    return `${EXTRACT_PROMPT}\n\n${EXTRACT_EXISTING_MEMORIES_HEADING}\n\n${inventory}`;
+}
+export const AUTODREAM_PROMPT = `You are performing an auto-dream memory consolidation pass.
+
+Goal: tighten and de-duplicate memory files so future sessions can orient faster.
+
+## Available tools
+- memory_list
+- memory_search
+- memory_read
+- memory_save
+- memory_delete
+
+## Phase 1 — Orient
+1. Use memory_list to inspect current memory inventory.
+2. Identify overlapping or stale entries that can be merged/updated/deleted.
+
+## Phase 2 — Consolidate
+1. Merge duplicates into a single stronger memory using memory_save.
+2. Rewrite vague descriptions so retrieval is easier and more precise.
+3. For feedback/project entries, ensure content is structured as:
+   - main rule/fact
+   - **Why:**
+   - **How to apply:**
+
+## Phase 3 — Prune
+1. Delete memories that are clearly obsolete, contradictory, or low-value.
+2. Keep total memory set concise and high signal.
+
+## Guardrails
+- Do NOT invent facts.
+- If confidence is low, keep existing memory instead of guessing.
+- If memory quality is already strong, make no changes and explicitly say so.
+
+Return a short summary of what you updated, merged, or removed.`;
+export const AUTODREAM_USER_MESSAGE = "Run the consolidation pass over the current memory directory now.";

package/dist/extraction/state.d.ts

@@ -0,0 +1,38 @@
+export declare const EXTRACTION_STATE_VERSION = 1;
+export declare const EXTRACTION_STATE_FILE = "extraction-state.json";
+export declare const MAINTENANCE_LOCK_FILE = "maintenance.lock";
+export declare const STATE_LOCK_FILE = "extraction-state.lock";
+export declare const SESSION_STATE_TTL_MS: number;
+export type SessionExtractionState = {
+    lastExtractedMessageID?: string;
+    lastMessageAt?: number;
+    updatedAt: number;
+    failures: number;
+    attemptedAt?: number;
+};
+export type AutodreamState = {
+    lastConsolidatedAt: number;
+    sessionsSince: string[];
+};
+export type ExtractionStateData = {
+    version: typeof EXTRACTION_STATE_VERSION;
+    sessions: Record<string, SessionExtractionState>;
+    autodream: AutodreamState;
+};
+export declare function emptyExtractionState(): ExtractionStateData;
+export declare function parseExtractionState(raw: string): ExtractionStateData;
+export declare class ExtractionStateStore {
+    readonly stateDir: string;
+    private readonly now;
+    readonly filePath: string;
+    readonly lockPath: string;
+    readonly stateLockPath: string;
+    constructor(stateDir: string, now?: () => number);
+    read(): ExtractionStateData;
+    getSession(sessionID: string): SessionExtractionState | undefined;
+    update(mutate: (data: ExtractionStateData) => void): ExtractionStateData;
+    private prune;
+    private write;
+}
+export declare function posixCksum(input: string): number;
+export declare function migrateLegacyAutodreamState(store: ExtractionStateStore, legacyDir: string, projectRoots: readonly string[]): boolean;

package/dist/extraction/state.js

@@ -0,0 +1,159 @@
+// Persistent extraction state: per-session watermarks and the auto-dream gate.
+// <CLAUDE_CONFIG_DIR>/opencode-memory/<sanitizePath(canonicalRoot)>/extraction-state.json
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { withFileLock } from "../util/exclusiveFile.js";
+export const EXTRACTION_STATE_VERSION = 1;
+export const EXTRACTION_STATE_FILE = "extraction-state.json";
+export const MAINTENANCE_LOCK_FILE = "maintenance.lock";
+export const STATE_LOCK_FILE = "extraction-state.lock";
+export const SESSION_STATE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export function emptyExtractionState() {
+    return { version: EXTRACTION_STATE_VERSION, sessions: {}, autodream: { lastConsolidatedAt: 0, sessionsSince: [] } };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normaliseSession(value) {
+    if (!isRecord(value))
+        return undefined;
+    const updatedAt = typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) ? value.updatedAt : 0;
+    const failures = typeof value.failures === "number" && Number.isFinite(value.failures) ? value.failures : 0;
+    const state = { updatedAt, failures };
+    if (typeof value.lastExtractedMessageID === "string")
+        state.lastExtractedMessageID = value.lastExtractedMessageID;
+    if (typeof value.lastMessageAt === "number" && Number.isFinite(value.lastMessageAt))
+        state.lastMessageAt = value.lastMessageAt;
+    if (typeof value.attemptedAt === "number" && Number.isFinite(value.attemptedAt))
+        state.attemptedAt = value.attemptedAt;
+    return state;
+}
+// Tolerant parser: a missing or corrupt file yields empty state instead of disabling extraction.
+export function parseExtractionState(raw) {
+    const data = emptyExtractionState();
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return data;
+    }
+    if (!isRecord(parsed))
+        return data;
+    if (isRecord(parsed.sessions)) {
+        for (const [id, value] of Object.entries(parsed.sessions)) {
+            const session = normaliseSession(value);
+            if (session)
+                data.sessions[id] = session;
+        }
+    }
+    if (isRecord(parsed.autodream)) {
+        const last = parsed.autodream.lastConsolidatedAt;
+        if (typeof last === "number" && Number.isFinite(last))
+            data.autodream.lastConsolidatedAt = last;
+        if (Array.isArray(parsed.autodream.sessionsSince)) {
+            data.autodream.sessionsSince = parsed.autodream.sessionsSince.filter((s) => typeof s === "string");
+        }
+    }
+    return data;
+}
+// Never cached: several OpenCode processes may maintain the same project (#30). Every `update()` is a
+// read-modify-write under a short cross-process file lock, so two processes committing different
+// sessions at the same time cannot overwrite each other. The file is tiny and writes are rare.
+export class ExtractionStateStore {
+    stateDir;
+    now;
+    filePath;
+    lockPath;
+    stateLockPath;
+    constructor(stateDir, now = Date.now) {
+        this.stateDir = stateDir;
+        this.now = now;
+        this.filePath = join(stateDir, EXTRACTION_STATE_FILE);
+        this.lockPath = join(stateDir, MAINTENANCE_LOCK_FILE);
+        this.stateLockPath = join(stateDir, STATE_LOCK_FILE);
+    }
+    read() {
+        let raw = "";
+        try {
+            raw = readFileSync(this.filePath, "utf-8");
+        }
+        catch {
+            // first run
+        }
+        return parseExtractionState(raw);
+    }
+    getSession(sessionID) {
+        return this.read().sessions[sessionID];
+    }
+    // `mutate` sees the on-disk state as of this moment (under the lock), so it can make decisions
+    // against what other processes committed, not against a snapshot taken earlier.
+    update(mutate) {
+        mkdirSync(this.stateDir, { recursive: true });
+        return withFileLock(this.stateLockPath, () => {
+            const data = this.read();
+            mutate(data);
+            this.prune(data);
+            this.write(data);
+            return data;
+        });
+    }
+    prune(data) {
+        const cutoff = this.now() - SESSION_STATE_TTL_MS;
+        for (const [id, session] of Object.entries(data.sessions)) {
+            if (Math.max(session.updatedAt, session.attemptedAt ?? 0) < cutoff)
+                delete data.sessions[id];
+        }
+    }
+    write(data) {
+        mkdirSync(this.stateDir, { recursive: true });
+        const tmp = `${this.filePath}.${process.pid}.tmp`;
+        writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+        renameSync(tmp, this.filePath);
+    }
+}
+// POSIX `cksum` (CRC-32/CKSUM: polynomial 0x04C11DB7, non-reflected, length appended, inverted).
+// v1's bash wrapper keyed its auto-dream lock file on `cksum` of the git top-level path.
+export function posixCksum(input) {
+    const bytes = Buffer.from(input, "utf-8");
+    let crc = 0;
+    const feed = (byte) => {
+        crc ^= byte << 24;
+        for (let i = 0; i < 8; i++) {
+            crc = crc & 0x80000000 ? ((crc << 1) ^ 0x04c11db7) >>> 0 : (crc << 1) >>> 0;
+        }
+    };
+    for (const byte of bytes)
+        feed(byte);
+    let length = bytes.length;
+    while (length > 0) {
+        feed(length & 0xff);
+        length >>>= 8;
+    }
+    return (~crc >>> 0) >>> 0;
+}
+// v1 stored the last successful consolidation time as the mtime of
+// <CLAUDE_CONFIG_DIR>/opencode-memory/<cksum(project root)>.consolidate-lock. Carry it over once so
+// upgrading does not immediately trigger a consolidation pass, then remove the old file.
+export function migrateLegacyAutodreamState(store, legacyDir, projectRoots) {
+    if (store.read().autodream.lastConsolidatedAt > 0)
+        return false;
+    let migrated = false;
+    for (const root of new Set(projectRoots)) {
+        const legacyPath = join(legacyDir, `${posixCksum(root)}.consolidate-lock`);
+        if (!existsSync(legacyPath))
+            continue;
+        try {
+            const mtimeMs = statSync(legacyPath).mtimeMs;
+            store.update((data) => {
+                data.autodream.lastConsolidatedAt = Math.max(data.autodream.lastConsolidatedAt, Math.floor(mtimeMs));
+            });
+            unlinkSync(legacyPath);
+            migrated = true;
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return migrated;
+}

package/dist/hooks/ignore.d.ts

@@ -0,0 +1,6 @@
+import type { ChatMessage, MessagePart } from "../sdk.js";
+export declare function detectIgnoreMemory(query: string | undefined): boolean;
+export declare function detectResumeMemory(query: string | undefined): boolean;
+export declare function deriveIgnoredFromHistory(messages: readonly ChatMessage[]): boolean;
+export declare function isAutoMemoryPart(part: MessagePart): boolean;
+export declare function stripAutoMemoryParts(messages: readonly ChatMessage[]): ChatMessage[];