dsh-continual-evolve 0.15.6 → 0.15.8

package/lib/review.js

@@ -0,0 +1,467 @@
+/**
+ * The autonomous content-quality loop (the model's verdicts, code's
+ * consequences): cheap gate first, evolve pass only on approval, every
+ * terminal path ledgered as one `item-review` row, one day-rollup merge per
+ * run. No human in the loop — delete never lands automatically (verdicts
+ * only know keep/rewrite/quarantine) and oversized rewrites degrade to
+ * quarantine instead of landing.
+ *
+ * This track is independent from the extraction pipeline by construction:
+ * own prompts (`review-prompt.ts`), own budget (`review_daily`), own ledger
+ * (`review_log`), no cursor, no increment. It only shares the store's write
+ * gates (`applyProposals` / `applySkillProposals` / `quarantine`).
+ */
+import { normalizeUsage, zeroUsage } from "./token-usage.js";
+import { evolvePrompt, gatePrompt, parseEvolveAnswer, parseGateAnswer, REVIEW_CHEAP_SYSTEM_PROMPT, REVIEW_MEMORY_SYSTEM_PROMPT, REVIEW_SKILL_SYSTEM_PROMPT, } from "./review-prompt.js";
+import { cwdOf } from "./memory-section.js";
+/** A rewrite lands only when the body-length ratio stays within this bound. */
+export const REWRITE_MAGNITUDE_CAP = 0.3;
+/** Relative body change: |new-old| / max(old, 1). Above the cap → quarantine. */
+export function rewriteMagnitude(oldBody, newBody) {
+    return Math.abs(newBody.length - oldBody.length) / Math.max(oldBody.length, 1);
+}
+/**
+ * Collect review candidates across every workspace carrying active items:
+ * new items first (newest first), then corrects-linked requeues, then stale
+ * requeues (30 days untouched). bounded by `limit`.
+ */
+export function collectCandidates(store, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const staleMs = (opts.staleDays ?? 30) * 24 * 60 * 60 * 1000;
+    const limit = opts.limit ?? 100;
+    const fresh = [];
+    const requeued = [];
+    const stale = [];
+    // One push per enumerated row: store primary keys make (workspace, kind,
+    // id) unique, so no dedup set is needed — a duplicate here would mean a
+    // store invariant broke, and failing loud beats silently merging.
+    const push = (candidate) => {
+        (candidate.priority === 0 ? fresh : candidate.priority === 1 ? requeued : stale).push(candidate);
+    };
+    const partitions = new Set();
+    for (const summary of store.listWorkspaces()) {
+        partitions.add(summary.workspaceId);
+    }
+    for (const summary of store.listSkillWorkspaces()) {
+        partitions.add(summary.workspaceId);
+    }
+    partitions.add("");
+    for (const workspaceId of partitions) {
+        const correctsTargets = new Set();
+        const memories = store.listAll(workspaceId);
+        for (const record of memories) {
+            if (record.corrects !== null && record.corrects.length > 0) {
+                correctsTargets.add(record.corrects);
+            }
+        }
+        for (const record of memories) {
+            if (record.status !== "active") {
+                continue;
+            }
+            const state = store.reviewStateOf(workspaceId, "memory", record.id);
+            const updatedAt = Date.parse(record.updatedAt) || 0;
+            if (state === undefined) {
+                push({ workspaceId, kind: "memory", id: record.id, priority: 0, title: record.title, description: record.description, body: record.body, memoryType: record.type });
+            }
+            else if (correctsTargets.has(record.id)) {
+                push({ workspaceId, kind: "memory", id: record.id, priority: 1, title: record.title, description: record.description, body: record.body, memoryType: record.type });
+            }
+            else if (now - updatedAt >= staleMs) {
+                push({ workspaceId, kind: "memory", id: record.id, priority: 2, title: record.title, description: record.description, body: record.body, memoryType: record.type });
+            }
+        }
+        const projectSeen = new Set();
+        const skillsOf = (partition, scope) => {
+            for (const record of store.listAllSkills(partition)) {
+                if (record.status !== "active" || projectSeen.has(record.id)) {
+                    continue;
+                }
+                projectSeen.add(record.id);
+                const state = store.reviewStateOf(partition, "skill", record.id);
+                const updatedAt = Date.parse(record.updatedAt) || 0;
+                const candidate = {
+                    workspaceId: partition, kind: "skill", id: record.id,
+                    priority: state === undefined ? 0 : 2,
+                    title: record.title, description: record.description, body: record.body, scope,
+                };
+                if (state === undefined || now - updatedAt >= staleMs) {
+                    push(candidate);
+                }
+            }
+        };
+        if (workspaceId !== "") {
+            skillsOf(workspaceId, "project");
+        }
+    }
+    // Global skills ride along once (project rows shadow them per id).
+    skillsGlobal(store, now, staleMs, push);
+    const byPriority = (a, b) => (a.priority - b.priority);
+    return [...fresh, ...requeued, ...stale].sort(byPriority).slice(0, limit);
+}
+function skillsGlobal(store, now, staleMs, push) {
+    const projectIds = new Set();
+    for (const summary of store.listSkillWorkspaces()) {
+        if (summary.workspaceId === "") {
+            continue;
+        }
+        for (const record of store.listAllSkills(summary.workspaceId)) {
+            // Archived rows shadow nothing (readWithScope shows the global
+            // row once the project row archives after a move-to-global).
+            if (record.status === "active") {
+                projectIds.add(record.id);
+            }
+        }
+    }
+    for (const record of store.listAllSkills("")) {
+        if (record.status !== "active" || projectIds.has(record.id)) {
+            continue;
+        }
+        const state = store.reviewStateOf("", "skill", record.id);
+        const updatedAt = Date.parse(record.updatedAt) || 0;
+        if (state === undefined || now - updatedAt >= staleMs) {
+            push({
+                workspaceId: "", kind: "skill", id: record.id,
+                priority: state === undefined ? 0 : 2,
+                title: record.title, description: record.description, body: record.body, scope: "global",
+            });
+        }
+    }
+}
+/**
+ * Run one review batch: cheap gate per item, evolve pass on approval,
+ * safeguards before landing, one `item-review` row per terminal path, one
+ * daily merge at the end. Never throws: LLM and parse failures degrade to
+ * skip rows (the run keeps going), exactly like extraction's fail-ledgered
+ * discipline.
+ */
+export async function runReviewBatch(deps, candidates, opts) {
+    const summary = { reviewed: 0, approved: 0, applied: 0, dropped: 0, backlog: 0, cheapToken: 0, evolveToken: 0 };
+    const skipReasons = [];
+    const batch = candidates.slice(0, Math.max(1, opts.batchSize ?? 10));
+    const runId = opts.runId ?? `review:${opts.day}:${Date.now()}`;
+    let newItems = 0;
+    let requeued = 0;
+    const noRoute = deps.llm === undefined || opts.provider === undefined || opts.model === undefined;
+    let position = 0;
+    for (const candidate of batch) {
+        const remaining = deps.store.consumeReviewBudget(opts.day, opts.budget);
+        if (remaining < 0) {
+            // Hard cap hit: this item and everything after it drops (low
+            // priority never rolls over — it simply waits for a future run).
+            summary.dropped += batch.length - position;
+            for (const item of batch.slice(position)) {
+                deps.store.logReview({
+                    runId, workspaceId: item.workspaceId, itemKind: item.kind, itemId: item.id,
+                    verdict: "skip", reason: "budget-exhausted", applied: 0,
+                });
+            }
+            skipReasons.push("budget-exhausted");
+            break;
+        }
+        summary.reviewed += 1;
+        if (candidate.priority === 0) {
+            newItems += 1;
+        }
+        else {
+            requeued += 1;
+        }
+        if (noRoute) {
+            deps.store.logReview({
+                runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
+                verdict: "skip", reason: "no-route", applied: 0,
+            });
+            skipReasons.push("no-route");
+            position += 1;
+            continue;
+        }
+        await reviewOne(deps, runId, candidate, opts, summary, skipReasons);
+        position += 1;
+    }
+    summary.backlog = Math.max(0, candidates.length - summary.reviewed - summary.dropped);
+    deps.store.mergeDaily(opts.day, opts.budget, {
+        newItems, requeued, approved: summary.approved, applied: summary.applied,
+        cheapToken: summary.cheapToken, evolveToken: summary.evolveToken,
+        backlog: summary.backlog, dropped: summary.dropped,
+        skipReasons: skipReasons.length > 0 ? skipReasons : undefined,
+    });
+    return summary;
+}
+async function reviewOne(deps, runId, candidate, opts, summary, skipReasons) {
+    const base = {
+        runId, workspaceId: candidate.workspaceId, itemKind: candidate.kind, itemId: candidate.id,
+    };
+    // ── Cheap gate ──────────────────────────────────────────────
+    let gateUsage = zeroUsage();
+    let gateRaw;
+    try {
+        const answer = await streamOnce(deps.llm, opts, REVIEW_CHEAP_SYSTEM_PROMPT, gatePrompt(candidate), 512);
+        gateRaw = answer.usage;
+        const gate = parseGateAnswer(answer.text);
+        if (gate === null) {
+            deps.store.logReview({ ...base, verdict: "skip", reason: "gate-parse-failed", cheapUsage: gateRaw, applied: 0 });
+            skipReasons.push("gate-parse-failed");
+            return;
+        }
+        if (!gate.worthReview) {
+            summary.cheapToken += totalOf(gateRaw);
+            deps.store.logReview({ ...base, verdict: "skip", reason: gate.reason, cheapUsage: gateRaw, applied: 0 });
+            skipReasons.push("cheap-gate");
+            return;
+        }
+        summary.cheapToken += totalOf(gateRaw);
+        gateUsage = normalizedOf(gateRaw);
+    }
+    catch (error) {
+        // The error text rides the row: a bare `gate-llm-failed` hid a ~50%
+        // per-item failure rate in production (2026-10-12) with no way to
+        // tell transient route faults from systematic ones.
+        deps.store.logReview({ ...base, verdict: "skip", reason: `gate-llm-failed: ${failureHead(error)}`, applied: 0 });
+        skipReasons.push("gate-llm-failed");
+        return;
+    }
+    summary.approved += 1;
+    // ── Evolve pass ─────────────────────────────────────────────
+    const neighbors = neighborHooks(deps.store, candidate);
+    const extra = candidate.kind === "memory" && candidate.memoryType === "feedback"
+        ? "注意：feedback 类正文必须带 Why 与 How to apply 两行。"
+        : undefined;
+    let evolveRaw;
+    try {
+        const system = candidate.kind === "memory" ? REVIEW_MEMORY_SYSTEM_PROMPT : REVIEW_SKILL_SYSTEM_PROMPT;
+        const answer = await streamOnce(deps.llm, opts, system, evolvePrompt({ id: candidate.id, title: candidate.title, description: candidate.description, body: candidate.body, extra }, neighbors), 4096);
+        evolveRaw = answer.usage;
+        summary.evolveToken += totalOf(evolveRaw);
+        const evolved = parseEvolveAnswer(answer.text);
+        if (evolved === null) {
+            deps.store.logReview({ ...base, verdict: "skip", reason: "evolve-parse-failed", cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
+            skipReasons.push("evolve-parse-failed");
+            return;
+        }
+        if (evolved.verdict === "keep") {
+            deps.store.logReview({ ...base, verdict: "keep", reason: evolved.reason, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
+            return;
+        }
+        if (evolved.verdict === "quarantine") {
+            landQuarantine(deps, base, candidate, opts, evolved.reason, gateUsage, evolveRaw, summary);
+            return;
+        }
+        // ── Rewrite: magnitude cap first, dry-run second, gates last ──
+        const nextBody = evolved.body ?? candidate.body;
+        if (rewriteMagnitude(candidate.body, nextBody) > REWRITE_MAGNITUDE_CAP) {
+            landQuarantine(deps, base, candidate, opts, `幅度超限转隔离：${evolved.reason}`, gateUsage, evolveRaw, summary);
+            return;
+        }
+        if (opts.dryRun) {
+            deps.store.logReview({ ...base, verdict: "rewrite", reason: `试运行未落盘：${evolved.reason}`, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
+            return;
+        }
+        landRewrite(deps, base, candidate, opts, evolved, gateUsage, evolveRaw, summary);
+    }
+    catch (error) {
+        deps.store.logReview({ ...base, verdict: "skip", reason: `evolve-llm-failed: ${failureHead(error)}`, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0 });
+        skipReasons.push("evolve-llm-failed");
+    }
+}
+function neighborHooks(store, candidate) {
+    try {
+        if (candidate.kind === "memory") {
+            const query = candidate.title.slice(0, 60);
+            const hits = query.length >= 3 ? store.search(candidate.workspaceId, query, 5) : store.list(candidate.workspaceId).slice(0, 5);
+            return hits.filter((hit) => hit.id !== candidate.id).slice(0, 4).map((hit) => ({ id: hit.id, title: hit.title, description: hit.description }));
+        }
+        const hits = store.searchSkills(candidate.workspaceId, candidate.title.slice(0, 60), 5);
+        return hits.filter((hit) => hit.id !== candidate.id).slice(0, 4).map((hit) => ({ id: hit.id, title: hit.title, description: hit.description }));
+    }
+    catch {
+        return [];
+    }
+}
+function landQuarantine(deps, base, candidate, opts, reason, gateUsage, evolveRaw, summary) {
+    const prior = deps.store.reviewStateOf(candidate.workspaceId, candidate.kind, candidate.id)?.evolveCount ?? 0;
+    if (opts.dryRun) {
+        deps.store.logReview({ ...base, verdict: "quarantine", reason: `试运行未隔离：${reason}`, cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: 0, evolveCount: prior });
+        return;
+    }
+    const ok = deps.store.quarantine(candidate.workspaceId, candidate.kind, candidate.id);
+    deps.store.logReview({
+        ...base, verdict: "quarantine", reason, cheapUsage: gateUsage, evolveUsage: evolveRaw,
+        applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
+    });
+    if (ok) {
+        summary.applied += 1;
+    }
+}
+function landRewrite(deps, base, candidate, opts, evolved, gateUsage, evolveRaw, summary) {
+    const prior = deps.store.reviewStateOf(candidate.workspaceId, candidate.kind, candidate.id)?.evolveCount ?? 0;
+    const ctx = { workspaceId: candidate.workspaceId, trigger: "item-review", sessionId: opts.sessionId, runId: base.runId, model: opts.model, decision: evolved.reason };
+    if (candidate.kind === "memory") {
+        const [outcome] = deps.store.applyProposals(ctx, [{
+                action: "update", id: candidate.id,
+                title: evolved.title, description: evolved.description, body: evolved.body,
+                corrects: evolved.corrects,
+            }]);
+        const ok = outcome !== undefined && outcome.ok;
+        deps.store.logReview({
+            ...base, verdict: "rewrite", reason: ok ? evolved.reason : `门禁拒绝：${outcome?.reason ?? "未知原因"}`,
+            cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
+        });
+        if (ok) {
+            summary.applied += 1;
+        }
+        return;
+    }
+    const { outcomes } = deps.store.applySkillProposals(ctx, [{
+            action: "update", scope: candidate.scope ?? "project", id: candidate.id,
+            title: evolved.title, description: evolved.description, body: evolved.body,
+        }]);
+    const outcome = outcomes[0];
+    const ok = outcome !== undefined && outcome.ok;
+    deps.store.logReview({
+        ...base, verdict: "rewrite", reason: ok ? evolved.reason : `门禁拒绝：${outcome?.reason ?? "未知原因"}`,
+        cheapUsage: gateUsage, evolveUsage: evolveRaw, applied: ok ? 1 : 0, evolveCount: ok ? prior + 1 : prior,
+    });
+    if (ok) {
+        summary.applied += 1;
+    }
+}
+function totalOf(raw) {
+    return normalizeUsage(raw)?.total ?? 0;
+}
+/** One-line error head for ledger rows (fail-loud shape, capped length). */
+export function failureHead(error, max = 120) {
+    const message = error instanceof Error ? error.message : String(error);
+    const head = message.split("\n", 1)[0] ?? "";
+    return head.length > max ? `${head.slice(0, max)}…` : head;
+}
+function normalizedOf(raw) {
+    return normalizeUsage(raw) ?? zeroUsage();
+}
+/** One streaming text call with the host session identity forwarded. */
+async function streamOnce(llm, opts, system, prompt, maxTokens) {
+    if (llm === undefined) {
+        throw new Error("no llm route");
+    }
+    let text = "";
+    let usage;
+    let finish;
+    for await (const chunk of llm.stream({
+        provider: opts.provider,
+        model: opts.model,
+        messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+        system,
+        maxTokens,
+        sessionId: opts.sessionId,
+    })) {
+        const piece = chunk;
+        if (piece?.type === "text-delta" && typeof piece.text === "string") {
+            text += piece.text;
+        }
+        else if (piece?.type === "usage") {
+            usage = piece.usage;
+        }
+        else if (piece?.type === "finish") {
+            finish = piece.reason;
+        }
+    }
+    if (finish !== undefined && finish.kind !== "stop") {
+        throw new Error(`stream finished with ${finish.kind ?? "unknown"}`);
+    }
+    if (text.trim().length === 0) {
+        throw new Error("empty model output");
+    }
+    return { text, usage };
+}
+/** Current UTC day `YYYY-MM-DD` for the hard-cap account. */
+export function todayUtc() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * Wire the review triggers onto the host context. Global single-flight with
+ * a minimum interval: turn boundaries arm the pending workspace, compaction
+ * and session close drain immediately. Each drain reviews one batch bounded
+ * by the remaining daily budget — never more.
+ */
+export function createReviewScheduler(host, deps, config) {
+    const listeners = [];
+    let running = false;
+    let lastRunAt = 0;
+    let pendingWorkspace;
+    let lastRoute;
+    const drain = (triggerWorkspace) => {
+        if (!config.enabled || running) {
+            if (triggerWorkspace !== undefined) {
+                pendingWorkspace = triggerWorkspace;
+            }
+            return;
+        }
+        if (Date.now() - lastRunAt < config.minIntervalMs) {
+            if (triggerWorkspace !== undefined) {
+                pendingWorkspace = triggerWorkspace;
+            }
+            return;
+        }
+        if (deps.llm === undefined || lastRoute?.provider === undefined || lastRoute?.model === undefined) {
+            return;
+        }
+        running = true;
+        lastRunAt = Date.now();
+        const workspace = triggerWorkspace ?? pendingWorkspace;
+        pendingWorkspace = undefined;
+        void (async () => {
+            try {
+                const day = todayUtc();
+                const daily = deps.store.getDaily(day);
+                const remaining = config.dailyBudget - (daily?.reviewed ?? 0);
+                if (remaining <= 0) {
+                    return;
+                }
+                const candidates = collectCandidates(deps.store, { staleDays: config.staleDays, limit: config.batchSize * 2 });
+                const ordered = workspace === undefined
+                    ? candidates
+                    : [...candidates.filter((c) => c.workspaceId === workspace), ...candidates.filter((c) => c.workspaceId !== workspace)];
+                await runReviewBatch(deps, ordered.slice(0, config.batchSize), {
+                    day, budget: config.dailyBudget, dryRun: config.dryRun,
+                    batchSize: config.batchSize, staleDays: config.staleDays,
+                    provider: lastRoute?.provider, model: lastRoute?.model, sessionId: lastRoute?.sessionId,
+                });
+            }
+            catch (error) {
+                host.logger("continual-evolve").warn(`review drain failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                running = false;
+            }
+        })();
+    };
+    listeners.push(host.on("agent/turn-stopping", (payload) => {
+        const agent = payload.agent;
+        const id = agent?.id;
+        if (typeof id !== "string" || id.length === 0) {
+            return;
+        }
+        const provider = typeof agent?.options?.provider === "string" ? agent.options.provider : undefined;
+        const model = typeof agent?.options?.model === "string" ? agent.options.model : undefined;
+        lastRoute = { provider, model, sessionId: id };
+        drain(cwdOf(payload.agent));
+    }));
+    listeners.push(host.on("session/event", (session, event) => {
+        if (event?.type !== "compaction/start" || typeof session?.id !== "string") {
+            return;
+        }
+        drain(pendingWorkspace);
+    }));
+    listeners.push(host.on("agent/disposed", () => {
+        drain(pendingWorkspace);
+        pendingWorkspace = undefined;
+    }));
+    host.logger("continual-evolve").info(`review scheduler armed (daily cap ${config.dailyBudget}, dry-run ${config.dryRun ? "on" : "off"})`);
+    return () => {
+        pendingWorkspace = undefined;
+        for (const listener of listeners) {
+            if (typeof listener === "function") {
+                listener();
+            }
+        }
+    };
+}
+//# sourceMappingURL=review.js.map

package/lib/skill-tools.js

@@ -117,8 +117,9 @@ export function registerSkillTools(tools, store) {
             if (found === undefined) {
                 return `没有找到 id 为 "${args.id}" 的技能。`;
             }
-            // V2 usage loop: a served body is one real consumption.
-            // Search/list hits are noise and stay uncounted.
+            // Consulted set: a body served by id means the model opened
+            // it for the task at hand. Search/list hits are noise
+            // and stay uncounted; human card previews never count.
             store.recordSkillUse(skillUsagePartition(found.scope, cwd), found.record.id, found.scope);
             return formatSkill(found.record, found.scope);
         }

package/lib/store-apply.d.ts

@@ -26,6 +26,8 @@ export interface ProposalContext {
     runId?: string | undefined;
     model?: string | undefined;
     usage?: unknown;
+    /** Pre-gate call payload (extraction cheap gate); carried into the ledger row. */
+    cheapUsage?: unknown;
     /** One-line model decision summary for the ledger. */
     decision?: string | undefined;
 }

package/lib/store-apply.js

@@ -11,13 +11,14 @@ function recordOf(row) {
         sourceSession: row.source_session,
         sourceSeqs: row.source_seqs,
         sourceRun: row.source_run,
+        corrects: row.corrects ?? null,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
 }
-const INSERT_SQL = "INSERT INTO memories (workspace_id, id, type, title, description, body, status, source_session, source_seqs, source_run, created_at, updated_at) " +
-    "VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)";
-const UPDATE_SQL = "UPDATE memories SET type = ?, title = ?, description = ?, body = ?, updated_at = ? WHERE workspace_id = ? AND id = ?";
+const INSERT_SQL = "INSERT INTO memories (workspace_id, id, type, title, description, body, status, source_session, source_seqs, source_run, corrects, created_at, updated_at) " +
+    "VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)";
+const UPDATE_SQL = "UPDATE memories SET type = ?, title = ?, description = ?, body = ?, corrects = COALESCE(?, corrects), updated_at = ? WHERE workspace_id = ? AND id = ?";
 const DELETE_SQL = "DELETE FROM memories WHERE workspace_id = ? AND id = ?";
 const FTS_DROP_SQL = "DELETE FROM memories_fts WHERE rowid IN (SELECT rowid FROM memories_fts WHERE workspace_id = ? AND id = ?)";
 const FTS_INSERT_SQL = "INSERT INTO memories_fts (workspace_id, id, title, description, body) " +
@@ -61,6 +62,7 @@ export function applyProposals(db, ctx, proposals) {
         durationMs: Date.now() - started,
         model: ctx.model,
         usage: ctx.usage,
+        cheapUsage: ctx.cheapUsage,
         files: applied ? files : [],
     };
     if (!applied) {
@@ -69,10 +71,10 @@ export function applyProposals(db, ctx, proposals) {
     writeLedger(db.database.prepare(LEDGER_SQL), ledger);
     return { outcomes, applied };
 }
-const LEDGER_SQL = "INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
-    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+const LEDGER_SQL = "INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, cheap_usage, files) " +
+    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 function writeLedger(stmt, entry) {
-    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.files === undefined ? null : JSON.stringify(entry.files));
+    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.cheapUsage === undefined ? null : JSON.stringify(entry.cheapUsage), entry.files === undefined ? null : JSON.stringify(entry.files));
 }
 /** Validate one proposal and land it; appends the audit payload on success. */
 function applyOne(db, ctx, proposal, stmts, files) {
@@ -99,6 +101,10 @@ function applyOne(db, ctx, proposal, stmts, files) {
     if ("reason" in fields) {
         return fail(proposal, fields.reason);
     }
+    const link = checkCorrects(stmts.get, ctx.workspaceId, proposal, id);
+    if ("reason" in link) {
+        return fail(proposal, link.reason);
+    }
     const reasons = fieldGateReasons(fields.fields);
     if (reasons.length > 0) {
         return fail(proposal, reasons[0] ?? "invalid record");
@@ -108,7 +114,7 @@ function applyOne(db, ctx, proposal, stmts, files) {
             return fail(proposal, `memory "${id}" already exists — update it instead of creating a duplicate`);
         }
         const now = db.now();
-        stmts.insert.run(ctx.workspaceId, id, fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, ctx.sessionId ?? null, proposal.sourceSeqs ?? null, ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : null), now, now);
+        stmts.insert.run(ctx.workspaceId, id, fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, ctx.sessionId ?? null, proposal.sourceSeqs ?? null, ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : null), link.value, now, now);
         syncFts(db, ctx.workspaceId, id);
         files.push({
             id,
@@ -122,7 +128,7 @@ function applyOne(db, ctx, proposal, stmts, files) {
     if (existing === undefined) {
         return fail(proposal, `no memory "${id}" to update — create it instead`);
     }
-    stmts.update.run(fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, db.now(), ctx.workspaceId, id);
+    stmts.update.run(fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, link.value, db.now(), ctx.workspaceId, id);
     syncFts(db, ctx.workspaceId, id);
     files.push({ id, action, before: existing, after: recordOf(stmts.get.get(ctx.workspaceId, id)) });
     return { id, action, ok: true };
@@ -131,6 +137,36 @@ function applyOne(db, ctx, proposal, stmts, files) {
 function fail(proposal, reason) {
     return { id: proposal.id ?? "", action: proposal.action, ok: false, reason };
 }
+/**
+ * Resolve the correction link: absent (or explicitly empty-checked) proposals
+ * carry `null`, which keeps an existing link on update and stores null on
+ * create. A named target must be a well-formed id in the same workspace,
+ * must exist, must be active, and must not be the row itself.
+ */
+function checkCorrects(get, workspaceId, proposal, id) {
+    const raw = proposal.corrects;
+    if (raw === undefined) {
+        return { value: null };
+    }
+    const target = raw.trim();
+    if (target.length === 0) {
+        return { reason: "corrects must not be empty — omit it instead" };
+    }
+    if (!isValidMemoryId(target)) {
+        return { reason: `malformed corrects target "${target}"` };
+    }
+    if (target === id) {
+        return { reason: `memory "${id}" cannot correct itself` };
+    }
+    const row = get.get(workspaceId, target);
+    if (row === undefined) {
+        return { reason: `no memory "${target}" to correct` };
+    }
+    if (row.status !== "active") {
+        return { reason: `memory "${target}" is not active and cannot be corrected` };
+    }
+    return { value: target };
+}
 /** The proposal id, derived from the title (slug, CJK-hash fallback) on create. */
 function idFor(proposal) {
     if (proposal.id !== undefined && proposal.id.trim().length > 0) {