visionclaw 0.1.219-beta.0 → 0.1.219-dev.codex-issue-2805-worker-runtime.1

package/dist/tools/delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.js","sourceRoot":"","sources":["../../src/tools/delegation.ts"],"names":[],"mappings":"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"}

package/dist/tools/dream-memory.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type MemoryStoreRoot } from "../agent/nightly-maintenance/dreaming-files.js";
+import { type DreamingBatch, type DreamingReportData } from "../agent/nightly-maintenance/dreaming-batch.js";
+/**
+ * The restricted memory capability of a Dreaming batch (#2805 stage 2).
+ *
+ * Not the conversational `memory` tool: Dreaming edits unattended, so every
+ * edit is bounded to what the model has actually read in this batch.
+ *  - view is paginated (16 KB per response) and records the line ranges and
+ *    content hash the model saw;
+ *  - str_replace and insert require the touched lines to have been viewed at
+ *    the file's current content; create refuses an existing path;
+ *  - there is no delete or rename in this version, so an edit cannot remove a
+ *    file or move content out of view;
+ *  - every write goes through the shared memory-store path: store lock,
+ *    version check, atomic replacement;
+ *  - before a batch first changes a file, a backup of that content is kept;
+ *    each edit appends local metadata (paths, hashes, line spans; no content).
+ *
+ * The protection is per edit, not per batch: a committed edit stays when the
+ * batch is preempted or runs out of budget. Hash-then-rename is not an atomic
+ * compare-and-swap against writers that bypass the memory store; such a
+ * change is detected at the next edit, not prevented.
+ */
+export declare const DREAM_VIEW_MAX_BYTES = 16000;
+export interface DreamingToolContext {
+    batch: DreamingBatch;
+    stores: MemoryStoreRoot[];
+    /** Ordinary memory root: the local edit log and backups live under its `.dream_log`. */
+    memoriesDir: string;
+    now?: () => Date;
+}
+/** Read and edit guard state for one batch, held by the worker process only. */
+export declare class DreamingMemorySession {
+    private readonly context;
+    private readonly viewed;
+    private readonly backedUp;
+    /** Paths with at least one committed edit in this batch. */
+    private readonly touched;
+    private editSeq;
+    private report;
+    constructor(context: DreamingToolContext);
+    get reported(): DreamingReportData | null;
+    get editedPaths(): string[];
+    view(virtualPath: string, viewRange?: [number, number]): CallToolResult;
+    private renderPage;
+    private listDirectory;
+    private noteView;
+    private static isRangeViewed;
+    /** After an edit, keep coverage of known lines and shift later ones; unread lines never gain coverage. */
+    private refreshAfterEdit;
+    strReplace(virtualPath: string, oldStr: string, newStr: string): CallToolResult;
+    insert(virtualPath: string, insertLine: number, text: string): CallToolResult;
+    create(virtualPath: string, fileText: string): CallToolResult;
+    /**
+     * One version-checked edit under the store lock. The backup of the
+     * pre-batch content is written before the file is replaced; a failed
+     * backup leaves the file untouched.
+     */
+    private edit;
+    private backupOnce;
+    private appendEdit;
+    /** The content hash of a file this batch has viewed in full at its current content; null otherwise. */
+    private fullyViewedHash;
+    private relativeOf;
+    /**
+     * Record the batch outcome once. Each vocabulary candidate is validated on
+     * its own: an invalid one, or one citing a source outside this batch, is
+     * dropped and counted, never echoed back. A file reported as reviewed
+     * (tidied or unchanged) must have been viewed in full at its current
+     * content; the report carries the hash it was reviewed at.
+     */
+    submitReport(raw: {
+        ingestion?: {
+            status: "ingested" | "no_new_facts" | "not_done";
+            reason?: string;
+        };
+        files?: {
+            path: string;
+            status: "tidied" | "unchanged" | "not_done";
+        }[];
+        vocabularyCandidates?: unknown[];
+    }): CallToolResult;
+}
+export declare function installDreamingMemorySession(session: DreamingMemorySession | null): void;
+export declare function getDreamingMemorySession(): DreamingMemorySession | null;
+export declare const dreamMemoryTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    command: z.ZodEnum<{
+        create: "create";
+        view: "view";
+        str_replace: "str_replace";
+        insert: "insert";
+    }>;
+    path: z.ZodString;
+    view_range: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    old_str: z.ZodOptional<z.ZodString>;
+    new_str: z.ZodOptional<z.ZodString>;
+    insert_line: z.ZodOptional<z.ZodNumber>;
+    insert_text: z.ZodOptional<z.ZodString>;
+    file_text: z.ZodOptional<z.ZodString>;
+}>;
+export declare const dreamingReportTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    ingestion: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            ingested: "ingested";
+            no_new_facts: "no_new_facts";
+            not_done: "not_done";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            unchanged: "unchanged";
+            not_done: "not_done";
+            tidied: "tidied";
+        }>;
+    }, z.core.$strip>>>;
+    vocabularyCandidates: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}>;
+//# sourceMappingURL=dream-memory.d.ts.map

package/dist/tools/dream-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dream-memory.d.ts","sourceRoot":"","sources":["../../src/tools/dream-memory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAQzE,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAExB,MAAM,gDAAgD,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAc3C,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,wFAAwF;IACxF,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AA6CD,gFAAgF;AAChF,qBAAa,qBAAqB;IAQpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAAmC;gBAEpB,OAAO,EAAE,mBAAmB;IAEzD,IAAI,QAAQ,IAAI,kBAAkB,GAAG,IAAI,CAExC;IAED,IAAI,WAAW,IAAI,MAAM,EAAE,CAE1B;IAID,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc;IA8CvE,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,aAAa;IAoCrB,OAAO,CAAC,QAAQ;IAWhB,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B,0GAA0G;IAC1G,OAAO,CAAC,gBAAgB;IAgBxB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc;IAyB/E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc;IAmB7E,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc;IAiB7D;;;;OAIG;IACH,OAAO,CAAC,IAAI;IA0CZ,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,UAAU;IAelB,uGAAuG;IACvG,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,UAAU;IAOlB;;;;;;OAMG;IACH,YAAY,CAAC,GAAG,EAAE;QAChB,SAAS,CAAC,EAAE;YAAE,MAAM,EAAE,UAAU,GAAG,cAAc,GAAG,UAAU,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAClF,KAAK,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAA;SAAE,EAAE,CAAC;QACxE,oBAAoB,CAAC,EAAE,OAAO,EAAE,CAAC;KAClC,GAAG,cAAc;CA6DnB;AAID,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI,CAExF;AAED,wBAAgB,wBAAwB,IAAI,qBAAqB,GAAG,IAAI,CAEvE;AAaD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;EA6B3B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAgB9B,CAAC"}

package/dist/tools/dream-memory.js

@@ -0,0 +1,513 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { contentHash, editUnderLock, MemoryConflictError, replaceIfUnchanged, withMemoryLock, } from "../agent/memory-store.js";
+import { dreamLogDir, isMemoryDirectoryRelative, isMemoryFileRelative, resolveMemoryPath, } from "../agent/nightly-maintenance/dreaming-files.js";
+import { dreamEditsPath, DreamingReportDataSchema, VocabularyCandidateSchema, } from "../agent/nightly-maintenance/dreaming-batch.js";
+import { getWorkerExecutionRuntime } from "../threads/worker-execution-runtime.js";
+/**
+ * The restricted memory capability of a Dreaming batch (#2805 stage 2).
+ *
+ * Not the conversational `memory` tool: Dreaming edits unattended, so every
+ * edit is bounded to what the model has actually read in this batch.
+ *  - view is paginated (16 KB per response) and records the line ranges and
+ *    content hash the model saw;
+ *  - str_replace and insert require the touched lines to have been viewed at
+ *    the file's current content; create refuses an existing path;
+ *  - there is no delete or rename in this version, so an edit cannot remove a
+ *    file or move content out of view;
+ *  - every write goes through the shared memory-store path: store lock,
+ *    version check, atomic replacement;
+ *  - before a batch first changes a file, a backup of that content is kept;
+ *    each edit appends local metadata (paths, hashes, line spans; no content).
+ *
+ * The protection is per edit, not per batch: a committed edit stays when the
+ * batch is preempted or runs out of budget. Hash-then-rename is not an atomic
+ * compare-and-swap against writers that bypass the memory store; such a
+ * change is detected at the next edit, not prevented.
+ */
+export const DREAM_VIEW_MAX_BYTES = 16_000;
+const MAX_FILE_LINES = 999_999;
+function reply(text, isError = false) {
+    return { ...(isError ? { isError: true } : {}), content: [{ type: "text", text }] };
+}
+function lineCount(content) {
+    return content.split("\n").length;
+}
+/**
+ * Edit CRLF files as LF text and write them back with CRLF, so a model's
+ * LF-only old_str matches and inserted lines keep the file's line endings.
+ */
+function editLines(current, transform) {
+    const crlf = current.includes("\r\n");
+    const result = transform(crlf ? current.replace(/\r\n/g, "\n") : current);
+    return crlf && "content" in result ? { content: result.content.replace(/\r?\n/g, "\r\n") } : result;
+}
+/** A backup file name per memory path, without collisions between paths. */
+function backupName(virtualPath) {
+    return encodeURIComponent(virtualPath.replace(/^\//, ""));
+}
+function isRegularFile(fullPath) {
+    try {
+        return fs.lstatSync(fullPath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function splitLines(content) {
+    return content.replace(/\r\n/g, "\n").split("\n");
+}
+/** Tool error text. A file system error names host paths, so the model gets only its code. */
+function errorText(error) {
+    if (error instanceof Error && typeof error.syscall === "string") {
+        return `The memory store could not complete this (${error.code ?? "error"})`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+/** Read and edit guard state for one batch, held by the worker process only. */
+export class DreamingMemorySession {
+    context;
+    viewed = new Map();
+    backedUp = new Set();
+    /** Paths with at least one committed edit in this batch. */
+    touched = new Set();
+    editSeq = 0;
+    report = null;
+    constructor(context) {
+        this.context = context;
+    }
+    get reported() {
+        return this.report;
+    }
+    get editedPaths() {
+        return [...this.touched];
+    }
+    // ------------------------------------------------------------------ view
+    view(virtualPath, viewRange) {
+        const relative = this.relativeOf(virtualPath.replace(/\/+$/, ""));
+        if (relative !== null && !isMemoryFileRelative(relative) && isMemoryDirectoryRelative(relative)) {
+            const directory = resolveMemoryPath(this.context.stores, virtualPath, "directory");
+            // A protected file has a directory-like path; the file check below refuses it by name.
+            if (!isRegularFile(directory.fullPath))
+                return this.listDirectory(directory);
+        }
+        const target = resolveMemoryPath(this.context.stores, virtualPath, "file");
+        let content;
+        try {
+            content = fs.readFileSync(target.fullPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return reply(`${target.virtualPath} does not exist`, true);
+            throw error;
+        }
+        const lines = splitLines(content);
+        if (lines.length > MAX_FILE_LINES)
+            return reply(`${target.virtualPath} exceeds ${MAX_FILE_LINES} lines`, true);
+        const requestedStart = viewRange?.[0] ?? 1;
+        const requestedEnd = viewRange?.[1] ?? -1;
+        if (!Number.isInteger(requestedStart) || !Number.isInteger(requestedEnd)
+            || requestedStart < 1 || (requestedEnd !== -1 && requestedEnd < 1)
+            || (requestedEnd !== -1 && requestedEnd < requestedStart)) {
+            return reply(`Invalid view_range for ${target.virtualPath}; start at line 1 or later and use -1 for the end of the file.`, true);
+        }
+        const start = requestedStart;
+        const end = Math.min(lines.length, requestedEnd === -1 ? lines.length : requestedEnd);
+        if (start > lines.length)
+            return reply(`Line ${start} is beyond the end of ${target.virtualPath} (${lines.length} lines)`, true);
+        if (end < start)
+            return reply(`Invalid view_range for ${target.virtualPath}`, true);
+        // Fill the page greedily under the byte cap; only delivered lines count as viewed.
+        let page = null;
+        let last = start - 1;
+        for (let line = start; line <= end; line += 1) {
+            const candidate = this.renderPage(target.virtualPath, lines, start, line);
+            if (Buffer.byteLength(candidate, "utf8") > DREAM_VIEW_MAX_BYTES)
+                break;
+            page = candidate;
+            last = line;
+        }
+        if (page === null) {
+            return reply(`Line ${start} of ${target.virtualPath} is too long to show and has NOT been viewed; leave it unchanged.${start < lines.length ? ` Continue with view_range [${start + 1}, -1].` : ""}`, true);
+        }
+        this.noteView(target.virtualPath, content, start, last);
+        return reply(page);
+    }
+    renderPage(virtualPath, lines, start, last) {
+        return [
+            `${virtualPath} (lines ${start}-${last} of ${lines.length})`,
+            ...lines.slice(start - 1, last).map((line, index) => `${String(start + index).padStart(6, " ")}\t${line}`),
+            last < lines.length ? `Next page: view_range [${last + 1}, -1].` : "End of file.",
+        ].join("\n");
+    }
+    listDirectory(target) {
+        const rows = [];
+        const visit = (directory, prefix, depth) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return;
+                throw error;
+            }
+            for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                if (entry.isSymbolicLink())
+                    continue;
+                const child = prefix ? `${prefix}/${entry.name}` : entry.name;
+                const relative = target.relative ? `${target.relative}/${child}` : child;
+                if (entry.isDirectory() && isMemoryDirectoryRelative(relative)) {
+                    rows.push(`${target.virtualPath}/${child}/`);
+                    if (depth < 2)
+                        visit(path.join(directory, entry.name), child, depth + 1);
+                }
+                else if (entry.isFile() && isMemoryFileRelative(relative)) {
+                    rows.push(`${fs.statSync(path.join(directory, entry.name)).size}\t${target.virtualPath}/${child}`);
+                }
+            }
+        };
+        visit(target.fullPath, "", 1);
+        const kept = [`${target.virtualPath} (editable files up to 2 levels deep):`];
+        let bytes = Buffer.byteLength(kept[0], "utf8");
+        for (const [index, row] of rows.entries()) {
+            bytes += Buffer.byteLength(row, "utf8") + 1;
+            if (bytes > DREAM_VIEW_MAX_BYTES - 200) {
+                kept.push(`… ${rows.length - index} more entries; view a subdirectory to see them.`);
+                break;
+            }
+            kept.push(row);
+        }
+        return reply(kept.join("\n"));
+    }
+    noteView(virtualPath, content, start, end) {
+        const hash = contentHash(content);
+        const existing = this.viewed.get(virtualPath);
+        // Ranges seen at a different content never combine with the current ones.
+        if (existing?.hash !== hash) {
+            this.viewed.set(virtualPath, { hash, ranges: [[start, end]] });
+            return;
+        }
+        existing.ranges.push([start, end]);
+    }
+    static isRangeViewed(record, start, end) {
+        let covered = start - 1;
+        for (const [from, to] of [...record.ranges].sort((a, b) => a[0] - b[0])) {
+            if (from > covered + 1)
+                break;
+            covered = Math.max(covered, to);
+        }
+        return covered >= end;
+    }
+    /** After an edit, keep coverage of known lines and shift later ones; unread lines never gain coverage. */
+    refreshAfterEdit(virtualPath, before, newContent, span) {
+        const delta = span.newEnd - span.oldEnd;
+        const ranges = span.newEnd >= span.start ? [[span.start, span.newEnd]] : [];
+        for (const [from, to] of before.ranges) {
+            if (to < span.start)
+                ranges.push([from, to]);
+            else if (from > span.oldEnd)
+                ranges.push([from + delta, to + delta]);
+            else {
+                if (from < span.start)
+                    ranges.push([from, span.start - 1]);
+                if (to > span.oldEnd)
+                    ranges.push([span.newEnd + 1, to + delta]);
+            }
+        }
+        this.viewed.set(virtualPath, { hash: contentHash(newContent), ranges: ranges.filter(([from, to]) => from >= 1 && to >= from) });
+    }
+    // ----------------------------------------------------------------- edits
+    strReplace(virtualPath, oldStr, newStr) {
+        if (oldStr.length === 0)
+            return reply("old_str must not be empty", true);
+        const target = resolveMemoryPath(this.context.stores, virtualPath, "file");
+        const seen = this.viewed.get(target.virtualPath);
+        if (!seen)
+            return reply(`View ${target.virtualPath} before editing it`, true);
+        const span = { start: 0, oldEnd: 0, newEnd: 0 };
+        oldStr = oldStr.replace(/\r\n/g, "\n");
+        newStr = newStr.replace(/\r\n/g, "\n");
+        return this.edit(target, "str_replace", seen, span, (raw) => editLines(raw, (current) => {
+            const first = current.indexOf(oldStr);
+            if (first < 0)
+                return { refused: `old_str does not appear verbatim in ${target.virtualPath}` };
+            if (current.includes(oldStr, first + 1)) {
+                return { refused: `old_str appears more than once in ${target.virtualPath}; include more surrounding text` };
+            }
+            span.start = current.slice(0, first).split("\n").length;
+            span.oldEnd = span.start + lineCount(oldStr) - 1;
+            span.newEnd = span.start + lineCount(newStr) - 1;
+            if (!DreamingMemorySession.isRangeViewed(seen, span.start, span.oldEnd)) {
+                return { refused: `Lines ${span.start}-${span.oldEnd} of ${target.virtualPath} were not viewed; view them before editing` };
+            }
+            // A function replacement keeps `$&`/`$'` literal, so unread text cannot be copied in.
+            return { content: current.replace(oldStr, () => newStr) };
+        }), () => `Edited ${target.virtualPath} (now lines ${span.start}-${span.newEnd}).`);
+    }
+    insert(virtualPath, insertLine, text) {
+        const target = resolveMemoryPath(this.context.stores, virtualPath, "file");
+        const seen = this.viewed.get(target.virtualPath);
+        if (!seen)
+            return reply(`View ${target.virtualPath} before editing it`, true);
+        const inserted = text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+        const span = { start: insertLine + 1, oldEnd: insertLine, newEnd: insertLine + inserted.length };
+        return this.edit(target, "insert", seen, span, (raw) => editLines(raw, (current) => {
+            const lines = current.split("\n");
+            if (insertLine < 0 || insertLine > lines.length)
+                return { refused: `insert_line must be between 0 and ${lines.length}` };
+            // The insertion point must sit next to a line the model has read.
+            const anchor = Math.max(1, insertLine);
+            if (!DreamingMemorySession.isRangeViewed(seen, anchor, anchor)) {
+                return { refused: `Line ${anchor} of ${target.virtualPath} was not viewed; view it before inserting there` };
+            }
+            lines.splice(insertLine, 0, ...inserted);
+            return { content: lines.join("\n") };
+        }), () => `Inserted ${inserted.length} line(s) into ${target.virtualPath} after line ${insertLine}.`);
+    }
+    create(virtualPath, fileText) {
+        const target = resolveMemoryPath(this.context.stores, virtualPath, "file");
+        let hash;
+        try {
+            hash = replaceIfUnchanged(target.store.directory, target.fullPath, null, fileText);
+        }
+        catch (error) {
+            if (!(error instanceof MemoryConflictError))
+                throw error;
+            this.appendEdit({ path: target.virtualPath, command: "create", beforeHash: error.currentHash, afterHash: null, startLine: 0, endLine: 0, lineDelta: 0, result: "conflict" });
+            return reply(`${target.virtualPath} already exists; view it and edit it instead`, true);
+        }
+        const lines = lineCount(fileText);
+        this.touched.add(target.virtualPath);
+        this.appendEdit({ path: target.virtualPath, command: "create", beforeHash: null, afterHash: hash, startLine: 1, endLine: lines, lineDelta: lines, result: "committed" });
+        this.viewed.set(target.virtualPath, { hash, ranges: [[1, lines]] });
+        return reply(`Created ${target.virtualPath}.`);
+    }
+    /**
+     * One version-checked edit under the store lock. The backup of the
+     * pre-batch content is written before the file is replaced; a failed
+     * backup leaves the file untouched.
+     */
+    edit(target, command, seen, span, compute, describe) {
+        const observed = { hash: null };
+        const result = editUnderLock(target.store.directory, target.fullPath, (current) => {
+            observed.hash = contentHash(current);
+            if (observed.hash !== seen.hash) {
+                return { refused: `${target.virtualPath} changed since you viewed it; view it again before editing` };
+            }
+            const next = compute(current);
+            // An edit that changes nothing is not an edit: no backup, no log, no ingestion credit.
+            if ("content" in next && next.content === current)
+                return { refused: `The edit leaves ${target.virtualPath} unchanged` };
+            // There is no delete in this version, so an edit may not empty a file either.
+            if ("content" in next && next.content.trim() === "" && current.trim() !== "") {
+                return { refused: `An edit may not empty ${target.virtualPath}; keep what is still useful` };
+            }
+            if ("content" in next)
+                this.backupOnce(target.virtualPath, current);
+            return next;
+        });
+        if ("refused" in result) {
+            if (observed.hash !== null && observed.hash !== seen.hash) {
+                // Changed by another writer since the view: record the conflict, require a re-read.
+                this.viewed.delete(target.virtualPath);
+                this.appendEdit({ path: target.virtualPath, command, beforeHash: seen.hash, afterHash: observed.hash, startLine: 0, endLine: 0, lineDelta: 0, result: "conflict" });
+            }
+            return reply(result.refused, true);
+        }
+        const afterHash = contentHash(result.content);
+        this.touched.add(target.virtualPath);
+        this.appendEdit({
+            path: target.virtualPath, command, beforeHash: observed.hash, afterHash,
+            startLine: span.start, endLine: span.newEnd, lineDelta: span.newEnd - span.oldEnd, result: "committed",
+        });
+        this.refreshAfterEdit(target.virtualPath, seen, result.content, span);
+        return reply(describe());
+    }
+    backupOnce(virtualPath, content) {
+        if (this.backedUp.has(virtualPath))
+            return;
+        const dir = path.join(dreamLogDir(this.context.memoriesDir), "backups", this.context.batch.batchId);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(path.join(dir, backupName(virtualPath)), content, { encoding: "utf8", mode: 0o600 });
+        this.backedUp.add(virtualPath);
+    }
+    appendEdit(edit) {
+        const file = dreamEditsPath(this.context.batch.localDate, this.context.memoriesDir);
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        this.editSeq += 1;
+        const record = {
+            batchId: this.context.batch.batchId,
+            seq: this.editSeq,
+            at: (this.context.now?.() ?? new Date()).toISOString(),
+            ...edit,
+        };
+        withMemoryLock(this.context.memoriesDir, () => {
+            fs.appendFileSync(file, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+        });
+    }
+    /** The content hash of a file this batch has viewed in full at its current content; null otherwise. */
+    fullyViewedHash(virtualPath) {
+        const seen = this.viewed.get(virtualPath);
+        if (!seen)
+            return null;
+        let content;
+        try {
+            content = fs.readFileSync(resolveMemoryPath(this.context.stores, virtualPath, "file").fullPath, "utf8");
+        }
+        catch {
+            return null;
+        }
+        if (contentHash(content) !== seen.hash)
+            return null;
+        const all = splitLines(content);
+        for (let line = 1; line <= all.length; line += 1) {
+            if (DreamingMemorySession.isRangeViewed(seen, line, line))
+                continue;
+            return null;
+        }
+        return seen.hash;
+    }
+    relativeOf(virtualPath) {
+        const store = this.context.stores.find((candidate) => virtualPath === candidate.prefix || virtualPath.startsWith(`${candidate.prefix}/`));
+        return store ? virtualPath.slice(store.prefix.length + 1) : null;
+    }
+    // ---------------------------------------------------------------- report
+    /**
+     * Record the batch outcome once. Each vocabulary candidate is validated on
+     * its own: an invalid one, or one citing a source outside this batch, is
+     * dropped and counted, never echoed back. A file reported as reviewed
+     * (tidied or unchanged) must have been viewed in full at its current
+     * content; the report carries the hash it was reviewed at.
+     */
+    submitReport(raw) {
+        if (this.report)
+            return reply("The batch report was already submitted", true);
+        const { batch } = this.context;
+        if (batch.kind === "ingestion") {
+            if (!raw.ingestion)
+                return reply("An ingestion batch must report ingestion.status", true);
+            if (raw.ingestion.status === "no_new_facts" && !raw.ingestion.reason?.trim()) {
+                return reply("no_new_facts requires a short reason", true);
+            }
+            if (raw.ingestion.status === "ingested" && this.touched.size === 0) {
+                return reply("ingested means new facts were saved, but this batch committed no memory edit. Save them first, or report no_new_facts with a reason.", true);
+            }
+        }
+        const candidates = [];
+        let rejected = 0;
+        for (const item of raw.vocabularyCandidates ?? []) {
+            const parsed = VocabularyCandidateSchema.safeParse(item);
+            if (parsed.success && batch.vocabularyLearning && Object.hasOwn(batch.sources, parsed.data.sourceId)) {
+                candidates.push(parsed.data);
+            }
+            else {
+                rejected += 1;
+            }
+        }
+        const planned = new Set(batch.files.map((file) => file.path));
+        const files = [];
+        const unread = [];
+        for (const file of raw.files ?? []) {
+            if (!planned.has(file.path))
+                continue;
+            if (file.status === "not_done") {
+                files.push({ path: file.path, status: "not_done" });
+                continue;
+            }
+            const hash = this.fullyViewedHash(file.path);
+            if (hash === null)
+                unread.push(file.path);
+            else
+                files.push({ path: file.path, status: file.status, hash });
+        }
+        if (unread.length > 0) {
+            return reply(`A reviewed file must be viewed in full at its current content. View every page of ${unread.join(", ")}, or report it not_done.`, true);
+        }
+        const data = DreamingReportDataSchema.parse({
+            kind: batch.kind,
+            ...(batch.kind === "ingestion" ? { ingestion: raw.ingestion } : {}),
+            files,
+            vocabularyCandidates: candidates,
+            rejectedVocabulary: rejected,
+        });
+        const runtime = getWorkerExecutionRuntime();
+        if (!runtime)
+            return reply("No Dreaming batch is active", true);
+        const outcome = runtime.reportResult({ status: "succeeded", summary: "Dreaming batch reported", data });
+        if (!outcome.accepted) {
+            return reply(outcome.reason === "pending_input"
+                ? "New input arrived before this report. Read it, then report again."
+                : "A result was already reported for this batch", true);
+        }
+        this.report = data;
+        return reply(JSON.stringify({
+            ok: true,
+            acceptedVocabulary: candidates.length,
+            rejectedVocabulary: rejected,
+            next: "End your turn now with no further tool calls.",
+        }));
+    }
+}
+let active = null;
+export function installDreamingMemorySession(session) {
+    active = session;
+}
+export function getDreamingMemorySession() {
+    return active;
+}
+function withSession(run) {
+    const session = active;
+    if (!session)
+        return Promise.resolve(reply("No Dreaming batch is active", true));
+    try {
+        return Promise.resolve(run(session));
+    }
+    catch (error) {
+        // Path and lock refusals reach the model as tool errors, without content or host paths.
+        return Promise.resolve(reply(errorText(error), true));
+    }
+}
+export const dreamMemoryTool = tool("dream_memory", "Read and edit memory files during a Dreaming batch. view lists a directory or shows one page of a file with line numbers; follow 'Next page' to read further. str_replace and insert change only lines you have viewed at the file's current content; create makes a new file. There is no delete or rename. Paths start with /memories or /auto-memory.", {
+    command: z.enum(["view", "str_replace", "insert", "create"]),
+    path: z.string().min(1).max(512),
+    view_range: z.tuple([z.number().int(), z.number().int()]).optional()
+        .describe("1-based inclusive [start, end] for view; -1 as end means end of file"),
+    old_str: z.string().optional().describe("Exact unique text to replace (str_replace)"),
+    new_str: z.string().optional().describe("Replacement text (str_replace)"),
+    insert_line: z.number().int().optional().describe("Insert after this line; 0 inserts at the top (insert)"),
+    insert_text: z.string().optional().describe("Text to insert (insert)"),
+    file_text: z.string().optional().describe("Content of a new file (create)"),
+}, (args) => withSession((session) => {
+    switch (args.command) {
+        case "view":
+            return session.view(args.path, args.view_range);
+        case "str_replace":
+            if (args.old_str === undefined || args.new_str === undefined)
+                return reply("str_replace needs old_str and new_str", true);
+            return session.strReplace(args.path, args.old_str, args.new_str);
+        case "insert":
+            if (args.insert_line === undefined || args.insert_text === undefined)
+                return reply("insert needs insert_line and insert_text", true);
+            return session.insert(args.path, args.insert_line, args.insert_text);
+        case "create":
+            if (args.file_text === undefined)
+                return reply("create needs file_text", true);
+            return session.create(args.path, args.file_text);
+    }
+}));
+export const dreamingReportTool = tool("dreaming_report", "Report this Dreaming batch's outcome once, at the end. Ingestion batch: ingestion.status is ingested (new facts were saved to memory), no_new_facts (give a reason), or not_done. Review batch: one entry per listed file, tidied, unchanged, or not_done; tidied and unchanged require having viewed every page of the file at its current content. Optional vocabularyCandidates must cite a sourceId copied exactly from the transcript.", {
+    ingestion: z.object({
+        status: z.enum(["ingested", "no_new_facts", "not_done"]),
+        reason: z.string().max(1_000).optional(),
+    }).optional(),
+    files: z.array(z.object({
+        path: z.string().max(512),
+        status: z.enum(["tidied", "unchanged", "not_done"]),
+    })).max(64).optional(),
+    vocabularyCandidates: z.array(z.unknown()).max(200).optional()
+        .describe("Each: term, category, evidenceKind, sourceId; optional spokenForms, language, confidence"),
+}, (args) => withSession((session) => session.submitReport(args)));
+//# sourceMappingURL=dream-memory.js.map