dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/memory-section.js

@@ -0,0 +1,189 @@
+/**
+ * The whole runtime of the plugin after the 2026-10-04 ZCode-alignment
+ * teardown: the session-start memory section.
+ *
+ * The store is plain markdown inside the workspace — `<cwd>/.evolve/memory/`
+ * with a `MEMORY.md` index and one file per fact — so the model reads and
+ * writes it with its native file tools (DSH fences only out-of-workspace
+ * writes; dot-directories inside the workspace pass both ways). This module
+ * hands out the absolute path, injects the index content, and wraps the
+ * when-to-save guide around it. There are no tools, no scopes, and no
+ * governance: the files are the store, and a bad memory is a visible file
+ * the user deletes.
+ *
+ * Session-freeze contract (the prompt-cache guard): the section is computed
+ * once per agent id and reused byte-for-byte afterwards, so the system
+ * prompt stays stable within a session and cache reads keep hitting. A
+ * memory written mid-session becomes visible in the NEXT session; the model
+ * can always read the directory directly for the immediate need.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { MEMORY_GUIDE_RULES, memoryGuideIntro } from "./memory-guide.js";
+/** Name of the injected section (unique — duplicate names throw upstream). */
+export const MEMORY_SECTION_NAME = "evolve:memory-index";
+/** Default prompt-section order (empty 1–499 slot; upstream named slots start at 500). */
+export const DEFAULT_MEMORY_SECTION_ORDER = 400;
+/** Default hard character budget for the injected index. */
+export const DEFAULT_MAX_CHARS = 6000;
+/** Sessions whose frozen section text is kept before LRU eviction. */
+export const DEFAULT_FROZEN_SESSIONS = 32;
+const MEMORY_DIR_SEGMENTS = [".evolve", "memory"];
+const INDEX_FILE = "MEMORY.md";
+/** Starter index written on first use; the model maintains every line after. */
+const STARTER_INDEX = "# 记忆索引\n\n<!-- 一行一条：- [标题](文件名.md) — 一句话相关性钩子；写新记忆后在此追加一行 -->\n";
+/** Appended to the workspace .gitignore on bootstrap (git workspaces only). */
+const GITIGNORE_ENTRY = "# workspace memory (dsh-continual-evolve)\n.evolve/\n";
+/** The assembling agent's validated absolute cwd, or undefined when absent. */
+export function cwdOf(agent) {
+    try {
+        const header = agent?.session?.header;
+        const raw = header?.cwd ?? header?.meta?.cwd;
+        if (typeof raw !== "string" || raw.trim().length === 0) {
+            return undefined;
+        }
+        const cwd = raw.trim();
+        if (!isAbsolute(cwd)) {
+            return undefined;
+        }
+        return resolve(cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Absolute memory directory for a workspace root. */
+export function memoryDirFor(cwd) {
+    return join(resolve(cwd), ...MEMORY_DIR_SEGMENTS);
+}
+/**
+ * Ensure `.evolve/` is ignored when the workspace is a git repository, so
+ * the memory store never shows up in git status. Best-effort hygiene: a
+ * non-git workspace (no `.git` entry at the cwd) is left untouched — no
+ * `.gitignore` is created — and any write failure is swallowed.
+ */
+export function ensureGitIgnored(cwd) {
+    try {
+        if (!existsSync(join(cwd, ".git"))) {
+            return;
+        }
+        const gitignore = join(cwd, ".gitignore");
+        const existing = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
+        if (existing.split("\n").some((line) => line.trim() === ".evolve/")) {
+            return;
+        }
+        const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+        writeFileSync(gitignore, `${existing}${prefix}${GITIGNORE_ENTRY}`, "utf8");
+    }
+    catch {
+        // Never blocks the store; worst case is a visible .evolve/ in git status.
+    }
+}
+/**
+ * Ensure the store exists (creating the directory and a starter index on
+ * first use), then return the trimmed index text. Any filesystem failure
+ * degrades to "" — injection must never break an assembly.
+ */
+export function readMemoryIndex(dir, bootstrap = true) {
+    try {
+        if (bootstrap && !existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, INDEX_FILE), STARTER_INDEX, "utf8");
+            ensureGitIgnored(resolve(dir, "..", ".."));
+        }
+        return readFileSync(join(dir, INDEX_FILE), "utf8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Whole-line-preserving truncation of the index to `maxChars` characters.
+ * Only index rows that fit whole are shown — a partial markdown row would
+ * corrupt the line the model reads. When not even one row fits, `text` is
+ * "" and `dropped` carries the full length.
+ */
+export function fitIndex(index, maxChars) {
+    const budget = Math.max(0, maxChars);
+    if (index.length <= budget) {
+        return { text: index, dropped: 0 };
+    }
+    const cut = index.slice(0, budget);
+    const lastLine = cut.lastIndexOf("\n");
+    if (lastLine <= 0) {
+        return { text: "", dropped: index.length };
+    }
+    const text = cut.slice(0, lastLine);
+    return { text, dropped: index.length - text.length };
+}
+/**
+ * Compose the full memory section for one assembling agent: the guide
+ * wrapped around the budget-bounded index, with the absolute store path
+ * handed out so the model can read and write the files directly. With the
+ * guide off and an empty index the result is "" — the prompt renderer then
+ * drops the section, so an empty workspace costs zero tokens.
+ */
+export function memorySectionText(agent, opts) {
+    const guide = opts?.guide ?? true;
+    const maxChars = opts?.maxChars ?? DEFAULT_MAX_CHARS;
+    const cwd = cwdOf(agent);
+    if (!cwd) {
+        return "";
+    }
+    const dir = memoryDirFor(cwd);
+    const index = readMemoryIndex(dir, opts?.bootstrap ?? true);
+    const { text, dropped } = fitIndex(index, maxChars);
+    const parts = [];
+    if (index.length === 0) {
+        parts.push("<memories>\n（暂无记忆）\n</memories>");
+    }
+    else if (text.length > 0) {
+        parts.push(`<memories>\n${text}\n</memories>`);
+        if (dropped > 0) {
+            parts.push(`（索引超出 ${maxChars} 字符预算，已截断——其余记忆直接读取 \`${dir}/\` 目录）`);
+        }
+    }
+    else {
+        parts.push(`（索引超出 ${maxChars} 字符预算，一行都放不下——记忆直接读取 \`${dir}/\` 目录）`);
+    }
+    if (!guide) {
+        return index.length === 0 ? "" : parts.join("\n\n");
+    }
+    return [memoryGuideIntro(dir), ...parts, MEMORY_GUIDE_RULES].join("\n\n");
+}
+/**
+ * Freeze the section text per agent id. The frozen value is what keeps the
+ * system prompt stable across a session's assemblies (prompt-cache guard);
+ * bounded by `maxSessions` with insertion-order (LRU) eviction, so a
+ * long-lived process cannot grow without limit.
+ */
+export function createFrozenMemorySection(maxSessions = DEFAULT_FROZEN_SESSIONS) {
+    const limit = Math.max(1, maxSessions);
+    const frozen = new Map();
+    return {
+        textFor(agent, build) {
+            const id = agent?.id;
+            const key = typeof id === "string" && id.length > 0 ? id : undefined;
+            if (key === undefined) {
+                return build(agent);
+            }
+            const cached = frozen.get(key);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const text = build(agent);
+            frozen.set(key, text);
+            while (frozen.size > limit) {
+                const oldest = frozen.keys().next();
+                if (oldest.done === true) {
+                    break;
+                }
+                frozen.delete(oldest.value);
+            }
+            return text;
+        },
+        size: () => frozen.size,
+        clear: () => frozen.clear(),
+    };
+}
+//# sourceMappingURL=memory-section.js.map

package/lib/memory-snapshot.d.ts

@@ -0,0 +1,54 @@
+/** The index file name (same store contract as the injection path). */
+export declare const MEMORY_SNAPSHOT_INDEX_FILE = "MEMORY.md";
+/** One memory file with its frontmatter fields ("" when absent). */
+export interface MemoryFileInfo {
+    file: string;
+    name: string;
+    description: string;
+    type: string;
+}
+/** One parsed index row: `- [title](file.md) — hook`. */
+export interface MemoryIndexRow {
+    title: string;
+    file: string;
+}
+/** The full read-only snapshot the card renders for one workspace root. */
+export interface MemorySnapshot {
+    root: string;
+    memoryDir: string;
+    exists: boolean;
+    fileCount: number;
+    indexEntryCount: number;
+    files: MemoryFileInfo[];
+    /** Index rows whose referenced file no longer exists on disk. */
+    missingFiles: string[];
+    /** .md files on disk that no index row references. */
+    unindexedFiles: string[];
+    /** Set when the store exists but could not be read; null otherwise. */
+    readError: string | null;
+}
+/** Minimal frontmatter fields the card shows. */
+export interface MemoryFrontmatter {
+    name: string;
+    description: string;
+    type: string;
+}
+/**
+ * Parse `- [title](file.md) …` rows out of an index text. Anything else
+ * (headings, the bootstrap hint comment, blank lines) is ignored.
+ */
+export declare function parseMemoryIndexRows(indexText: string): MemoryIndexRow[];
+/**
+ * Read the card-relevant frontmatter fields (`name`, `description`, `type`)
+ * from a leading `---` block. A missing or malformed block yields "" fields —
+ * the body text remains the source of truth the user opens in the editor.
+ */
+export declare function parseMemoryFrontmatter(text: string): MemoryFrontmatter;
+/**
+ * The read-only memory snapshot for one workspace root. A missing store
+ * reports `exists: false` (the card shows the empty state); a store that
+ * exists but fails to read reports `readError` instead of throwing — the
+ * card must observe, never break.
+ */
+export declare function memorySnapshot(root: string): MemorySnapshot;
+//# sourceMappingURL=memory-snapshot.d.ts.map

package/lib/memory-snapshot.js

@@ -0,0 +1,125 @@
+/**
+ * Read-only projection of one workspace memory store for the plugin
+ * management card. Everything here is computed from disk at call time — the
+ * card is a viewer, never a second store: no caching, no writes, no bootstrap
+ * (unlike the injection path, a missing store is reported, not created).
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { memoryDirFor } from "./memory-section.js";
+/** The index file name (same store contract as the injection path). */
+export const MEMORY_SNAPSHOT_INDEX_FILE = "MEMORY.md";
+/**
+ * Parse `- [title](file.md) …` rows out of an index text. Anything else
+ * (headings, the bootstrap hint comment, blank lines) is ignored.
+ */
+export function parseMemoryIndexRows(indexText) {
+    const rows = [];
+    for (const line of indexText.split("\n")) {
+        const match = /^-\s+\[(.+?)\]\(([^()\s]+\.md)\)/.exec(line.trim());
+        if (match?.[1] !== undefined && match?.[2] !== undefined) {
+            rows.push({ title: match[1], file: match[2] });
+        }
+    }
+    return rows;
+}
+/**
+ * Read the card-relevant frontmatter fields (`name`, `description`, `type`)
+ * from a leading `---` block. A missing or malformed block yields "" fields —
+ * the body text remains the source of truth the user opens in the editor.
+ */
+export function parseMemoryFrontmatter(text) {
+    const fields = { name: "", description: "", type: "" };
+    if (!text.startsWith("---")) {
+        return fields;
+    }
+    const blockEnd = text.indexOf("\n---", 3);
+    if (blockEnd < 0) {
+        return fields;
+    }
+    for (const line of text.slice(3, blockEnd).split("\n")) {
+        const match = /^(name|description|type):\s*(.*)$/.exec(line.trim());
+        if (match?.[1] === undefined || match?.[2] === undefined) {
+            continue;
+        }
+        const value = match[2].trim().replace(/^["']|["']$/g, "");
+        if (match[1] === "name") {
+            fields.name = value;
+        }
+        else if (match[1] === "description") {
+            fields.description = value;
+        }
+        else {
+            fields.type = value;
+        }
+    }
+    return fields;
+}
+/** Store files the card inspects: every .md except the index, sorted. */
+function listStoreFiles(memoryDir) {
+    return readdirSync(memoryDir)
+        .filter((file) => file.endsWith(".md") && file !== MEMORY_SNAPSHOT_INDEX_FILE)
+        .sort();
+}
+/** Single read pass over the store; throws on any filesystem failure. */
+function readStoreState(memoryDir) {
+    const indexText = readFileSync(join(memoryDir, MEMORY_SNAPSHOT_INDEX_FILE), "utf8");
+    const diskFiles = listStoreFiles(memoryDir);
+    const files = diskFiles.map((file) => {
+        const frontmatter = parseMemoryFrontmatter(readFileSync(join(memoryDir, file), "utf8"));
+        return { file, name: frontmatter.name, description: frontmatter.description, type: frontmatter.type };
+    });
+    return { indexRows: parseMemoryIndexRows(indexText), diskFiles, files };
+}
+/**
+ * The read-only memory snapshot for one workspace root. A missing store
+ * reports `exists: false` (the card shows the empty state); a store that
+ * exists but fails to read reports `readError` instead of throwing — the
+ * card must observe, never break.
+ */
+export function memorySnapshot(root) {
+    const workspaceRoot = resolve(root);
+    const memoryDir = memoryDirFor(workspaceRoot);
+    const absent = {
+        root: workspaceRoot,
+        memoryDir,
+        exists: false,
+        fileCount: 0,
+        indexEntryCount: 0,
+        files: [],
+        missingFiles: [],
+        unindexedFiles: [],
+        readError: null,
+    };
+    if (!existsSync(memoryDir)) {
+        return absent;
+    }
+    let state;
+    try {
+        state = readStoreState(memoryDir);
+    }
+    catch (error) {
+        // Filesystem read failure degrades to an error field: the card shows
+        // what went wrong instead of taking the host down with it.
+        return {
+            ...absent,
+            exists: true,
+            readError: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const referenced = new Set(state.indexRows.map((row) => row.file));
+    return {
+        root: workspaceRoot,
+        memoryDir,
+        exists: true,
+        fileCount: state.diskFiles.length,
+        indexEntryCount: state.indexRows.length,
+        files: state.files,
+        missingFiles: state.indexRows
+            .map((row) => row.file)
+            .filter((file) => !state.diskFiles.includes(file)),
+        unindexedFiles: state.diskFiles.filter((file) => !referenced.has(file)),
+        readError: null,
+    };
+}
+//# sourceMappingURL=memory-snapshot.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.11.0",
-  "description": "Continual self-evolution plugin for DeepSeek Harness: versioned, auditable, rollback-safe harness state (prompt notes, memories, skills, subagent specs) refined from session trajectories.",
+  "version": "0.12.1",
+  "description": "ZCode-style workspace memory for DeepSeek Harness: a per-workspace markdown store (<workspace>/.evolve/memory/) with session-start index injection — the model reads and writes the files with its native tools.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,15 +19,13 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./types": {
-      "types": "./lib/types.d.ts",
-      "default": "./lib/types.js"
-    },
+    "./client": "./client/client.js",
     "./package.json": "./package.json"
   },
   "files": [
     "lib/**/*.js",
     "lib/**/*.d.ts",
+    "client/client.js",
     "cordis.patch.yml",
     "README.md",
     "LICENSE"
@@ -35,6 +33,10 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [],
+      "platform": "web"
     }
   },
   "engines": {
@@ -51,7 +53,6 @@
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.scripts.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "coverage:gaps": "tsx scripts/coverage-gaps.ts",
     "test:watch": "vitest",
     "lint": "oxlint src test",
     "clean": "rm -rf lib",
@@ -60,19 +61,9 @@
     "check:governance": "tsx scripts/verify-governance.ts"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6 || ^0.1.7-rc.1 || ^0.2.0-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.7-rc.1 || ^0.2.0-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.7-rc.1 || ^0.2.0-rc.1",
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "4.0.4",
-    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-commands": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-home-paths": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
     "@deepseek-ai/schemastery": "3.18.4",
     "@types/node": "^22.10.0",
     "@vitest/coverage-v8": "^3.2.0",

package/lib/apply.d.ts

@@ -1,22 +0,0 @@
-/**
- * The apply pass: turn a validated proposal into state changes with full
- * per-edit accounting. Every failure is recorded per edit — a bad edit never
- * invalidates the whole proposal — and optimistic-concurrency checks reject
- * edits whose target entry changed while planning was in flight.
- */
-import type { EntrySource, HarnessScope, HarnessState, RefinementProposal, RefinementResult } from "./types.js";
-export interface ApplyOptions {
-    id: string;
-    scope?: HarnessScope;
-    rollbackOf?: string;
-    /** State captured before planning; used to reject conflicting edits. */
-    baselineState?: HarnessState;
-    /**
-     * Trajectory citation stamped into newly created entries' metadata
-     * (sourceSession + sourceSeqs); updates keep whatever the entry already
-     * carries. Omitted entirely when the caller cannot determine it.
-     */
-    source?: EntrySource;
-}
-export declare function applyRefinementProposal(state: HarnessState, proposal: RefinementProposal, options: ApplyOptions): RefinementResult;
-//# sourceMappingURL=apply.d.ts.map

package/lib/apply.js

@@ -1,157 +0,0 @@
-import { SOURCE_SESSION_KEY, SOURCE_SEQS_KEY, ARCHIVED_AT_KEY, cloneEntry, isArchived, slug } from "./types.js";
-import { entryChangedSince } from "./state.js";
-import { validateEdit } from "./validate.js";
-export function applyRefinementProposal(state, proposal, options) {
-    const appliedEdits = [];
-    const touched = new Set();
-    const now = new Date().toISOString();
-    for (const edit of proposal.edits) {
-        // Store-prefix hygiene: planner edits are written against the MERGED
-        // view, where colliding project/local ids carry a `project:` /
-        // `local:` / `global:` prefix. A CREATE must never bake that view
-        // prefix into a permanent id (observed: global entries literally
-        // named "local:handoff_todo_…").
-        // Non-create edits address existing entries: the literal id wins —
-        // legacy stores contain entries whose literal id carries a colon
-        // prefix, and stripping unconditionally would resolve them to a
-        // sibling that does not exist ("entry not found", forcing file-level
-        // surgery). Only when the literal id is absent does the stripped
-        // form serve as the merged-view fallback.
-        // (Review audit 2026-08-28 S7 origin; literal-first fix 2026-09-24.)
-        const strippedId = edit.id?.replace(/^(?:local|project|global):/, "");
-        const requestedId = edit.action === "create"
-            ? strippedId
-            : edit.id !== undefined && state.entries[edit.kind]?.[edit.id] !== undefined
-                ? edit.id
-                : edit.id && strippedId;
-        const computedId = requestedId ?? (edit.action === "create" ? slug(edit.title ?? edit.kind, edit.kind) : undefined);
-        const id = computedId ?? "";
-        // Unknown kinds fail per-edit — a malformed proposal must never crash
-        // the whole pass (review audit 2026-08-28 S1).
-        const records = state.entries[edit.kind];
-        if (!records) {
-            appliedEdits.push({ ...edit, id, applied: false, error: `unsupported kind ${String(edit.kind)}` });
-            continue;
-        }
-        const before = cloneEntry(records[id]);
-        const entryKey = `${edit.kind}:${id}`;
-        if (options.baselineState && !touched.has(entryKey) && entryChangedSince(options.baselineState, state, edit.kind, id)) {
-            appliedEdits.push({
-                ...edit,
-                id,
-                ...(before ? { before } : {}),
-                applied: false,
-                error: "entry changed during planning",
-            });
-            continue;
-        }
-        // Validation sees the current entry so update rules can distinguish
-        // "carrying the persisted value" from "changing it" (skill_kind).
-        const validationError = validateEdit(edit, computedId, options.scope, before);
-        if (validationError) {
-            appliedEdits.push({ ...edit, id, applied: false, error: validationError });
-            continue;
-        }
-        if (edit.action === "delete") {
-            if (!before) {
-                appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
-                continue;
-            }
-            delete records[id];
-            touched.add(entryKey);
-            appliedEdits.push({ ...edit, id, before, applied: true });
-            continue;
-        }
-        if (edit.action === "archive") {
-            // Archive hides an entry from injection but never deletes it:
-            // metadata.archivedAt is stamped through the normal apply path, so
-            // the edit gets a before/after snapshot, a version bump, and a
-            // rollback inverse like any other edit (restoring the snapshot
-            // clears the stamp). Idempotency is explicit: re-archiving an
-            // already-archived entry is an error, not a silent no-op.
-            if (!before) {
-                appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
-                continue;
-            }
-            if (isArchived(before)) {
-                appliedEdits.push({ ...edit, id, before, applied: false, error: "entry already archived" });
-                continue;
-            }
-            const after = {
-                ...before,
-                metadata: { ...before.metadata, [ARCHIVED_AT_KEY]: now },
-                updated_at: now,
-                version: before.version + 1,
-            };
-            records[id] = after;
-            touched.add(entryKey);
-            appliedEdits.push({ ...edit, id, before, after: cloneEntry(after) ?? after, applied: true });
-            continue;
-        }
-        if (edit.action === "create" && before) {
-            appliedEdits.push({ ...edit, id, before, applied: false, error: "entry already exists" });
-            continue;
-        }
-        if (edit.action === "update" && !before) {
-            appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
-            continue;
-        }
-        // Trajectory citation: stamped on create (the distillation moment),
-        // never re-stamped on update (the entry keeps its original source).
-        // Model-supplied metadata wins on key collision.
-        const sourceMetadata = !before && options.source
-            ? {
-                [SOURCE_SESSION_KEY]: options.source.sessionId,
-                ...(options.source.seqs && options.source.seqs.length > 0
-                    ? { [SOURCE_SEQS_KEY]: options.source.seqs }
-                    : {}),
-            }
-            : {};
-        const skillKind = edit.skill_kind ?? before?.skill_kind;
-        const after = {
-            id,
-            kind: edit.kind,
-            title: edit.title ?? before?.title ?? id,
-            content: edit.content ?? before?.content ?? "",
-            path: edit.path ?? before?.path ?? "general",
-            scope: before?.scope ?? options.scope ?? "local",
-            reference: edit.reference ?? before?.reference ?? {},
-            arguments: edit.arguments ?? before?.arguments ?? {},
-            ...(skillKind !== undefined ? { skill_kind: skillKind } : {}),
-            metadata: { ...sourceMetadata, ...(edit.metadata ?? before?.metadata ?? {}) },
-            source: "evolve",
-            created_at: before?.created_at ?? now,
-            updated_at: now,
-            version: before ? before.version + 1 : 1,
-        };
-        records[id] = after;
-        touched.add(entryKey);
-        appliedEdits.push({
-            ...edit,
-            id,
-            ...(before ? { before } : {}),
-            after: cloneEntry(after) ?? after,
-            applied: true,
-        });
-    }
-    const changes = appliedEdits.filter((edit) => edit.applied).map((edit) => `${edit.action} ${edit.kind}:${edit.id}`);
-    state.refinements.push({
-        id: options.id,
-        trigger: proposal.summary,
-        changes,
-        evidence: proposal.rationale,
-        outcome: proposal.expectedOutcome,
-        created_at: now,
-    });
-    return {
-        id: options.id,
-        summary: proposal.summary,
-        rationale: proposal.rationale,
-        expectedOutcome: proposal.expectedOutcome,
-        appliedEdits,
-        harnessStatePath: "",
-        ...(options.rollbackOf ? { rollbackOf: options.rollbackOf } : {}),
-        ...(options.scope ? { scope: options.scope } : {}),
-    };
-}
-//# sourceMappingURL=apply.js.map