dsh-continual-evolve 0.7.1 → 0.7.3

package/lib/review-scheduler.js

@@ -0,0 +1,192 @@
+/**
+ * Serial latest-boundary scheduler for automatic memory+review snapshots.
+ *
+ * One runner exists per session. A burst is coalesced by durable cursor rather
+ * than promise arrival: once multiple pending captures settle, the highest
+ * comparable boundary runs first. A cursor advances only after success/no-op;
+ * errors, aborts, and stale boundaries leave it unchanged.
+ */
+/** Compare two scheduler cursors; undefined means the cursor families differ. */
+export function compareReviewCursors(left, right) {
+    if (left === right)
+        return 0;
+    const leftMatch = /^(seq|index):(\d+)$/.exec(left);
+    const rightMatch = /^(seq|index):(\d+)$/.exec(right);
+    if (!leftMatch || !rightMatch || leftMatch[1] !== rightMatch[1])
+        return undefined;
+    return Number(leftMatch[2]) - Number(rightMatch[2]);
+}
+/** Bound unresolved acquisitions; actual auto capture is serialized per session. */
+const MAX_PENDING_ACQUISITIONS = 16;
+/**
+ * Create a scheduler with ZCode-compatible serial/coalescing semantics.
+ *
+ * @param execute - one serial extraction/review operation
+ * @param cursorOf - extracts the durable boundary from a snapshot
+ */
+export function createReviewScheduler(execute, cursorOf) {
+    let cursor;
+    let running;
+    let shuttingDown = false;
+    let wakePending;
+    const pending = [];
+    const shutdownController = new AbortController();
+    const signal = shutdownController.signal;
+    const trackPending = (acquisition) => {
+        const entry = {};
+        entry.promise = acquisition.then((result) => {
+            entry.result = result;
+            wakePending?.();
+            return result;
+        });
+        pending.push(entry);
+        while (pending.length > MAX_PENDING_ACQUISITIONS)
+            pending.shift();
+    };
+    const takeHighestPending = async () => {
+        while (!signal.aborted) {
+            for (let index = pending.length - 1; index >= 0; index -= 1) {
+                if (pending[index]?.result?.status === "error")
+                    pending.splice(index, 1);
+            }
+            if (pending.length === 0)
+                return undefined;
+            const settled = pending.filter((entry) => entry.result !== undefined);
+            if (settled.length > 0) {
+                let bestIndex = -1;
+                let bestCursor;
+                for (let index = 0; index < settled.length; index += 1) {
+                    const entry = settled[index];
+                    if (!entry || entry.result?.status !== "acquired")
+                        continue;
+                    const candidate = cursorOf(entry.result.snapshot);
+                    const order = bestCursor === undefined || candidate === undefined
+                        ? 1
+                        : compareReviewCursors(candidate, bestCursor);
+                    if (bestIndex < 0 || order === undefined || order > 0) {
+                        bestIndex = pending.indexOf(entry);
+                        bestCursor = candidate;
+                    }
+                }
+                if (bestIndex < 0) {
+                    pending.length = 0;
+                    return undefined;
+                }
+                const chosen = pending[bestIndex];
+                pending.splice(bestIndex, 1);
+                for (let index = pending.length - 1; index >= 0; index -= 1) {
+                    if (pending[index]?.result !== undefined)
+                        pending.splice(index, 1);
+                }
+                return chosen?.result;
+            }
+            await new Promise((resolve) => {
+                const cleanup = () => signal.removeEventListener("abort", onAbort);
+                const onAbort = () => {
+                    cleanup();
+                    resolve();
+                };
+                wakePending = () => {
+                    cleanup();
+                    wakePending = undefined;
+                    resolve();
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+            });
+        }
+        return undefined;
+    };
+    const processSnapshot = async (snapshot) => {
+        if (shuttingDown || signal.aborted)
+            return;
+        const nextCursor = cursorOf(snapshot);
+        if (cursor !== undefined && nextCursor !== undefined) {
+            const order = compareReviewCursors(nextCursor, cursor);
+            if (order !== undefined && order <= 0)
+                return;
+        }
+        let status;
+        try {
+            status = await execute({ snapshot, signal });
+        }
+        catch {
+            return;
+        }
+        if (!shuttingDown && (status === "success" || status === "no-op") && nextCursor !== undefined) {
+            const order = cursor === undefined ? 1 : compareReviewCursors(nextCursor, cursor);
+            if (order === undefined || order > 0)
+                cursor = nextCursor;
+        }
+    };
+    const run = async (first) => {
+        try {
+            let acquisition = await waitForSnapshotAcquisitionOrShutdown(first, signal);
+            while (acquisition.status !== "shutdown" && !shuttingDown) {
+                if (acquisition.status === "acquired")
+                    await processSnapshot(acquisition.snapshot);
+                const next = await takeHighestPending();
+                if (!next)
+                    break;
+                acquisition = next;
+            }
+        }
+        finally {
+            if (shuttingDown) {
+                pending.length = 0;
+                wakePending?.();
+                wakePending = undefined;
+            }
+            running = undefined;
+        }
+    };
+    return {
+        async drain() {
+            while (running)
+                await running;
+        },
+        getCursor() {
+            return cursor;
+        },
+        hasPendingWork() {
+            return running !== undefined || pending.length > 0;
+        },
+        schedule(snapshot) {
+            if (shuttingDown)
+                return;
+            const acquisition = acquireSnapshot(snapshot);
+            if (running)
+                trackPending(acquisition);
+            else
+                running = run(acquisition);
+        },
+        shutdown() {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            pending.length = 0;
+            shutdownController.abort();
+            wakePending?.();
+            wakePending = undefined;
+        },
+    };
+}
+function acquireSnapshot(snapshot) {
+    return Promise.resolve(snapshot).then((value) => ({ status: "acquired", snapshot: value }), () => ({ status: "error" }));
+}
+function waitForSnapshotAcquisitionOrShutdown(acquisition, signal) {
+    if (signal.aborted)
+        return Promise.resolve({ status: "shutdown" });
+    return new Promise((resolve) => {
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        const onAbort = () => {
+            cleanup();
+            resolve({ status: "shutdown" });
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        void acquisition.then((result) => {
+            cleanup();
+            resolve(result);
+        });
+    });
+}
+//# sourceMappingURL=review-scheduler.js.map

package/lib/review.d.ts

@@ -15,7 +15,7 @@ export interface AutoRefineReview {
     rationale: string;
     instructions?: string;
 }
-export type AutoRefineReason = "turn_interval" | "compact" | "goal_blocked";
+export type AutoRefineReason = "turn_snapshot" | "turn_interval" | "compact" | "goal_blocked";
 export interface AutoRefineReviewContext {
     reason: AutoRefineReason;
     turnsSinceLastReview: number;
@@ -27,6 +27,8 @@ export interface ReviewOptions {
     context: AutoRefineReviewContext;
     /** Serialized trajectory text; when absent the gate is skipped by the caller. */
     trajectory?: string;
+    /** Incremental surface rows captured for this turn snapshot. */
+    trajectoryEvents?: readonly unknown[];
     signal?: AbortSignal;
     budgetTokens?: number;
     /** Gap C1: optional provider/model override for the review gate (cheaper model). */
@@ -42,7 +44,7 @@ export interface ReviewOptions {
     /** Direct-call token ledger destination; the review phase is fixed by this module. */
     tokenUsage?: TokenUsageTarget;
 }
-export declare const AUTO_REVIEW_SYSTEM_PROMPT = "You are the automatic /evolve review gate.\n\nDecide whether this checkpoint should run /evolve. Auto /evolve writes local\nharness state by default, so approve when the trajectory contains evidence\nuseful to this session's future turns: a repeated failure, a reusable tactic,\na repeated delegation role, a durable fact or preference, a user correction\nthat should persist, or a narrow behavioral policy.\n\nThe current harness state below includes GLOBAL entries (scope=global) plus\nthis session's local entries (scope=local). When a topic is already covered\nby a global entry, do NOT approve a local duplicate of it \u2014 decline and say\nin the rationale that the topic is already covered globally.\n\nReject one-off noise, unsupported hypotheses, transient tool outputs, and\nrequests that carry no reusable content.\n\nStale local entries (superseded, long-unused, obsolete facts) are a valid\nrefine target: approve with instructions naming the entry ids, and tell the\nplanner to archive them (archive hides from injection, data stays restorable)\nrather than delete.\n\nSkill-related trajectories (the evidence concerns creating or improving a\nskill entry) are judged against the DSH skill quality standard (skill-audit\ndimensions: frontmatter routing, the 7 structural features, paragraph\nskeleton, no duplication of the official 11 skills or covered skills).\nApprove only when the trajectory shows a REAL trigger scenario and the\nresulting skill would meet the standard; otherwise decline and say in the\nrationale what must improve \u2014 drafting follows skill-creator, and the\nplanner receives the standard as its <skill_quality_standard> block.\n\nRepeated multi-step workflows (session start/end routines, recurring\nwrap-up or handoff procedures) are a valid refine target: approve with\ninstructions telling the planner to propose a guidance skill (kind=skill,\nskill_kind=guidance \u2014 a SKILL.md document, no python reference). Only\npropose when the same workflow recurs in the trajectory \u2014 never for\none-off flows. Auto-created skills are always offered to the user for a\ndecision before they land; the gate never writes a skill silently.\n\nReturn JSON only:\n{\n  \"shouldRefine\": true|false,\n  \"rationale\": \"short reason\",\n  \"instructions\": \"optional concise instructions for /evolve if shouldRefine is true\"\n}";
+export declare const AUTO_REVIEW_SYSTEM_PROMPT = "You are the automatic /evolve review gate.\n\nDecide whether this checkpoint should continue the non-memory /evolve path.\nA dedicated memory extraction agent has already processed the same snapshot\nwith a frozen memory manifest, so do NOT approve solely to create, update,\narchive, or delete a memory entry. Decline with a rationale that the memory\nphase owns that evidence. For the remaining kinds, approve repeated failures,\nreusable tactics, repeated delegation roles, or narrow behavioral policies.\n\nThe current harness state below includes GLOBAL entries (scope=global) plus\nthis session's local entries (scope=local). When a topic is already covered\nby a global entry, do NOT approve a local duplicate of it \u2014 decline and say\nin the rationale that the topic is already covered globally.\n\nReject one-off noise, unsupported hypotheses, transient tool outputs, and\nrequests that carry no reusable content.\n\nStale local entries (superseded, long-unused, obsolete facts) are a valid\nrefine target: approve with instructions naming the entry ids, and tell the\nplanner to archive them (archive hides from injection, data stays restorable)\nrather than delete.\n\nSkill-related trajectories (the evidence concerns creating or improving a\nskill entry) are judged against the DSH skill quality standard (skill-audit\ndimensions: frontmatter routing, the 7 structural features, paragraph\nskeleton, no duplication of the official 11 skills or covered skills).\nApprove only when the trajectory shows a REAL trigger scenario and the\nresulting skill would meet the standard; otherwise decline and say in the\nrationale what must improve \u2014 drafting follows skill-creator, and the\nplanner receives the standard as its <skill_quality_standard> block.\n\nRepeated multi-step workflows (session start/end routines, recurring\nwrap-up or handoff procedures) are a valid refine target: approve with\ninstructions telling the planner to propose a guidance skill (kind=skill,\nskill_kind=guidance \u2014 a SKILL.md document, no python reference). Only\npropose when the same workflow recurs in the trajectory \u2014 never for\none-off flows. Auto-created skills are always offered to the user for a\ndecision before they land; the gate never writes a skill silently.\n\nReturn JSON only:\n{\n  \"shouldRefine\": true|false,\n  \"rationale\": \"short reason\",\n  \"instructions\": \"optional concise instructions for /evolve if shouldRefine is true\"\n}";
 /** Parse the gate's JSON reply. */
 export declare function parseAutoRefineReview(text: string): AutoRefineReview;
 /** Serialize surface events to bounded role-prefixed text. */

package/lib/review.js

@@ -6,11 +6,12 @@ import { streamText } from "./llm-text.js";
 import { createTokenUsageObserver } from "./token-usage.js";
 export const AUTO_REVIEW_SYSTEM_PROMPT = `You are the automatic /evolve review gate.
 
-Decide whether this checkpoint should run /evolve. Auto /evolve writes local
-harness state by default, so approve when the trajectory contains evidence
-useful to this session's future turns: a repeated failure, a reusable tactic,
-a repeated delegation role, a durable fact or preference, a user correction
-that should persist, or a narrow behavioral policy.
+Decide whether this checkpoint should continue the non-memory /evolve path.
+A dedicated memory extraction agent has already processed the same snapshot
+with a frozen memory manifest, so do NOT approve solely to create, update,
+archive, or delete a memory entry. Decline with a rationale that the memory
+phase owns that evidence. For the remaining kinds, approve repeated failures,
+reusable tactics, repeated delegation roles, or narrow behavioral policies.
 
 The current harness state below includes GLOBAL entries (scope=global) plus
 this session's local entries (scope=local). When a topic is already covered
@@ -101,7 +102,7 @@ export async function reviewAutoRefine(ctx, options) {
     }
     // Route A carries the judged conversation as a session-derived message
     // prefix and drops the flat block; an empty prefix falls back to B.
-    const events = sessionEventsOf(agent);
+    const events = options.trajectoryEvents ?? sessionEventsOf(agent);
     const routing = resolvePrefixCache(options.prefixCache);
     const route = detectPlannerRoute(events, routing.mode);
     let prefixMessages = [];

package/lib/runtime.d.ts

@@ -1,6 +1,9 @@
+/** On-disk runtime gate state. Version 2 adds an explicit enable bit. */
 export interface GateRuntime {
-    version: 1;
-    /** True while the human paused the automatic review gate. */
+    version: 2;
+    /** Whether the human has enabled automatic review. */
+    enabled: boolean;
+    /** Whether the human has explicitly paused automatic review. */
     paused: boolean;
     /** ISO timestamp of the last pause/resume write. */
     updatedAt: string;
@@ -8,17 +11,14 @@ export interface GateRuntime {
 /** Full path of the runtime switch file. */
 export declare function runtimePath(baseDir: string): string;
 /**
- * Load the runtime switch; fail open to "running" on any unreadable or
- * malformed content (called on every gate trigger, so it must never throw
- * for a bad file).
+ * Load the runtime switch. Missing, malformed, or legacy content uses the
+ * supplied configured default and never throws; this is a trigger-path read.
  */
-export declare function loadGateRuntime(baseDir: string): GateRuntime;
-/**
- * Persist the pause switch atomically (temp file + rename). Never throws
- * for a bad file — callers (pause/resume commands) surface real IO errors
- * through the command's own error path instead.
- */
-export declare function saveGateRuntime(baseDir: string, paused: boolean): string;
-/** True while the human paused the automatic review gate (fail-open). */
+export declare function loadGateRuntime(baseDir: string, defaultEnabled?: boolean): GateRuntime;
+/** Persist the runtime switch atomically (temp file + rename). */
+export declare function saveGateRuntime(baseDir: string, paused: boolean, enabled?: boolean): string;
+/** True while the human paused the automatic review gate. */
 export declare function isGatePaused(baseDir: string): boolean;
+/** Effective automatic-review state, including the explicit enable bit. */
+export declare function isGateEnabled(baseDir: string, defaultEnabled?: boolean): boolean;
 //# sourceMappingURL=runtime.d.ts.map

package/lib/runtime.js

@@ -1,18 +1,15 @@
 /**
- * Runtime gate switch (#21 P2): a tiny human-owned file that pauses the
- * automatic review gate without touching the plugin config or restarting.
+ * Runtime gate switch: a small human-owned file that enables or pauses the
+ * automatic review listener without editing the profile or restarting DSH.
  *
- * - file: `<baseDir>/evolve/runtime.json` (`{version, paused, updatedAt}`)
- * - `/evolve pause` sets paused, `/evolve resume` clears it, `/evolve
- *   status` shows it alongside the static patch config.
- * - the gate consults it on every trigger (turn-interval AND compaction)
- *   and stays dormant while paused — manual tools/commands keep working.
- * - fail-open: a missing or corrupt file means "running". Pausing is the
- *   exceptional state; a broken file must never silently wedge the gate
- *   shut (the next save rewrites it cleanly).
+ * - file: `<baseDir>/evolve/runtime.json` (`{version: 2, enabled, paused, updatedAt}`)
+ * - the file is consulted at every trigger and before scheduler execution;
+ * - `/evolve pause` sets `paused`, `/evolve resume` sets `enabled=true` and
+ *   clears the pause, while manual tools and commands remain independent;
+ * - a missing or malformed file uses the caller's configured default. A
+ *   legacy v1 `{paused}` file is readable and preserves its pause state.
  */
-import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { EVOLVE_DIR } from "./store.js";
@@ -21,57 +18,54 @@ const RUNTIME_FILE = "runtime.json";
 export function runtimePath(baseDir) {
     return join(baseDir, EVOLVE_DIR, RUNTIME_FILE);
 }
-function running() {
-    return { version: 1, paused: false, updatedAt: new Date(0).toISOString() };
+function state(enabled, paused) {
+    return { version: 2, enabled, paused, updatedAt: new Date(0).toISOString() };
 }
 /**
- * Load the runtime switch; fail open to "running" on any unreadable or
- * malformed content (called on every gate trigger, so it must never throw
- * for a bad file).
+ * Load the runtime switch. Missing, malformed, or legacy content uses the
+ * supplied configured default and never throws; this is a trigger-path read.
  */
-export function loadGateRuntime(baseDir) {
+export function loadGateRuntime(baseDir, defaultEnabled = false) {
     const path = runtimePath(baseDir);
-    if (!existsSync(path)) {
-        return running();
-    }
+    if (!existsSync(path))
+        return state(defaultEnabled, false);
     try {
         const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-            return running();
-        }
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return state(defaultEnabled, false);
         const record = raw;
+        const paused = record["paused"] === true;
+        // v1 had no enable bit. Its only meaningful state was pause, so retain
+        // the configured default when it is not paused.
+        const enabled = typeof record["enabled"] === "boolean" ? record["enabled"] : defaultEnabled;
         return {
-            version: 1,
-            paused: record["paused"] === true,
+            version: 2,
+            enabled,
+            paused,
             updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : new Date(0).toISOString(),
         };
     }
     catch {
-        return running();
+        return state(defaultEnabled, false);
     }
 }
-/**
- * Persist the pause switch atomically (temp file + rename). Never throws
- * for a bad file — callers (pause/resume commands) surface real IO errors
- * through the command's own error path instead.
- */
-export function saveGateRuntime(baseDir, paused) {
+/** Persist the runtime switch atomically (temp file + rename). */
+export function saveGateRuntime(baseDir, paused, enabled = true) {
     const path = runtimePath(baseDir);
     mkdirSync(join(baseDir, EVOLVE_DIR), { recursive: true });
     const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    const payload = { version: 1, paused, updatedAt: new Date().toISOString() };
+    const payload = { version: 2, enabled, paused, updatedAt: new Date().toISOString() };
     writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
     try {
         renameSync(tempPath, path);
     }
     finally {
-        if (existsSync(tempPath)) {
+        if (existsSync(tempPath))
             unlinkSync(tempPath);
-        }
     }
     return path;
 }
-/** True while the human paused the automatic review gate (fail-open). */
+/** True while the human paused the automatic review gate. */
 export function isGatePaused(baseDir) {
     try {
         return loadGateRuntime(baseDir).paused;
@@ -80,4 +74,14 @@ export function isGatePaused(baseDir) {
         return false;
     }
 }
+/** Effective automatic-review state, including the explicit enable bit. */
+export function isGateEnabled(baseDir, defaultEnabled = false) {
+    try {
+        const current = loadGateRuntime(baseDir, defaultEnabled);
+        return current.enabled && !current.paused;
+    }
+    catch {
+        return defaultEnabled;
+    }
+}
 //# sourceMappingURL=runtime.js.map

package/lib/service.d.ts

@@ -6,6 +6,14 @@
 import type { EntrySource, HarnessScope, RefinementProposal, RefinementResult } from "./types.js";
 import { applyRefinementProposal } from "./apply.js";
 import type { HistoryRetention } from "./store.js";
+/** A post-commit apply failure that still carries the durable applied result. */
+export declare class EvolutionApplyPostCommitError extends Error {
+    readonly result: RefinementResult;
+    readonly scope: HarnessScope;
+    readonly storeId: string | undefined;
+    readonly cause: unknown;
+    constructor(message: string, result: RefinementResult, scope: HarnessScope, storeId: string | undefined, cause: unknown);
+}
 export interface ApplyContext {
     scope: HarnessScope;
     sessionId?: string;
@@ -32,6 +40,7 @@ export declare function createEvolutionEngine(baseDir: string, hooks?: Evolution
     load: (scope: HarnessScope, sessionId: string | undefined) => import("./types.js").HarnessState;
     apply: (scope: HarnessScope, sessionId: string | undefined, proposal: RefinementProposal, context?: ApplyContext) => RefinementResult;
     rollback: (scope: HarnessScope, sessionId: string | undefined, refinementId: string) => RefinementResult;
+    rollbackResult: (scope: HarnessScope, sessionId: string | undefined, target: RefinementResult) => RefinementResult;
     history: (scope: HarnessScope, sessionId: string | undefined) => RefinementResult[];
     baseDir: string;
     retention: HistoryRetention;

package/lib/service.js

@@ -5,6 +5,20 @@ import { rollbackProposal } from "./rollback.js";
 import { loadHarnessState, saveHarnessState } from "./state.js";
 import { appendResult, loadResults, pruneJsonlFile, pruneSnapshots, resolveHistoryRetention, snapshotBefore, storePaths } from "./store.js";
 import { CONFLICT_BLOCK_SCORE, CONFLICT_WARN_SCORE, buildConflictNotice, mostSimilarEntry, secretLeakReason } from "./promotion.js";
+/** A post-commit apply failure that still carries the durable applied result. */
+export class EvolutionApplyPostCommitError extends Error {
+    result;
+    scope;
+    storeId;
+    cause;
+    constructor(message, result, scope, storeId, cause) {
+        super(message);
+        this.result = result;
+        this.scope = scope;
+        this.storeId = storeId;
+        this.cause = cause;
+    }
+}
 export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
     const retention = resolveHistoryRetention(opts.historyRetain);
     /**
@@ -26,27 +40,29 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
         // 2026-08-28 B1: the two roles were previously folded into one object,
         // which made the advertised guard unreachable).
         const state = load(scope, sessionId);
-        // Write-time conflict guard (R2): global creates are checked against
-        // the existing same-kind entries BEFORE any side effect — a
-        // near-duplicate is rejected with an actionable error (evolve_update
-        // instead), a moderate overlap proceeds stamped with
+        // Write-time conflict guard (R2): persistent-scope creates are
+        // checked against the existing same-kind entries BEFORE any side
+        // effect — a near-duplicate is rejected with an actionable error
+        // (evolve_update instead), a moderate overlap proceeds stamped with
         // CONFLICT_HINT_KEY. Rollbacks bypass the guard: re-creating an entry
         // that resembles its successor is the point of rollback. Local scope
         // is never blocked (scratch space); the wrapup/fate promotion path
         // already enforces its own overlap policy there.
         //
-        // Secret-leak guard (P0, same throat): global creates AND updates are
-        // screened for credential-shaped literals before any side effect — a
-        // secret reaching the cross-session store is a leak even when the
-        // entry itself is legitimate. The screen covers every field the edit
-        // can plant: title, content, and the JSON forms of reference,
-        // arguments, and metadata (mount embeds reference verbatim into the
-        // generated plugin file). Fixed patterns, not policy-configurable.
+        // Secret-leak guard (P0, same throat): every persistent-scope create
+        // and update is screened before any side effect. Project and global
+        // stores both outlive the current session, so approval never turns a
+        // credential-shaped literal into an allowed write. The screen covers
+        // every field the edit can plant: title, content, and the JSON forms
+        // of reference, arguments, and metadata. Fixed patterns, not policy-
+        // configurable.
         const warnHits = new Map();
-        if (scope === "global" && !context?.rollbackOf) {
+        if ((scope === "project" || scope === "global") && !context?.rollbackOf) {
             for (const [index, edit] of proposal.edits.entries()) {
                 if (edit.action === "create" || edit.action === "update") {
                     const screenable = [
+                        typeof edit.id === "string" ? edit.id : "",
+                        typeof edit.path === "string" ? edit.path : "",
                         typeof edit.title === "string" ? edit.title : "",
                         typeof edit.content === "string" ? edit.content : "",
                         edit.reference !== undefined ? JSON.stringify(edit.reference) : "",
@@ -100,7 +116,12 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
             }
         }
         saveHarnessState(paths.stateDir, state);
-        appendResult(paths, result);
+        try {
+            appendResult(paths, result);
+        }
+        catch (cause) {
+            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but failed to append history: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
+        }
         // Storage hygiene (#20): bound the append-only past at write time —
         // snapshots keep the newest N, the per-store history keeps its tail.
         // Best-effort (never throws): a prune failure must not fail the apply.
@@ -116,9 +137,18 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
         catch {
             // ignored — the next apply retries
         }
-        hooks.onApplied?.(result);
+        try {
+            hooks.onApplied?.(result);
+        }
+        catch (cause) {
+            throw new EvolutionApplyPostCommitError(`Refinement ${result.id} persisted state but a post-commit hook failed: ${cause instanceof Error ? cause.message : String(cause)}`, result, scope, sessionId, cause);
+        }
         return result;
     }
+    /** Roll back an already-observed result without consulting history. */
+    function rollbackResult(scope, sessionId, target) {
+        return apply(scope, sessionId, rollbackProposal(target), { scope, rollbackOf: target.id });
+    }
     function rollback(scope, sessionId, refinementId) {
         const paths = storePaths(baseDir, scope, sessionId);
         const history = loadResults(paths);
@@ -126,15 +156,11 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
         if (!target) {
             throw new Error(`Refinement ${refinementId} not found in ${scope} history`);
         }
-        const proposal = rollbackProposal(target);
-        // The rollback refinement carries rollbackOf so the audit chain links
-        // the inverse operation back to its origin (previously the rollback
-        // record only echoed "Rollback refinement <id>" in its summary text).
-        return apply(scope, sessionId, proposal, { scope, rollbackOf: refinementId });
+        return rollbackResult(scope, sessionId, target);
     }
     function history(scope, sessionId) {
         return loadResults(storePaths(baseDir, scope, sessionId));
     }
-    return { load, apply, rollback, history, baseDir, retention };
+    return { load, apply, rollback, rollbackResult, history, baseDir, retention };
 }
 //# sourceMappingURL=service.js.map

package/lib/token-usage.d.ts

@@ -2,7 +2,7 @@ import type { TokenUsage } from "@deepseek-ai/dsh-llm";
 import type { StreamTextObservation, StreamTextUsageObserver } from "./llm-text.js";
 export declare const TOKEN_USAGE_LEDGER_VERSION = 1;
 /** Plugin-owned direct call paths represented in the ledger. */
-export declare const TOKEN_USAGE_PHASES: readonly ["review", "planner", "wrapup", "fate"];
+export declare const TOKEN_USAGE_PHASES: readonly ["review", "memory", "planner", "wrapup", "fate"];
 export type TokenUsagePhase = (typeof TOKEN_USAGE_PHASES)[number];
 /** Whether the provider supplied a usage sample; missing is never treated as zero. */
 export type TokenUsageStatus = "reported" | "missing";

package/lib/token-usage.js

@@ -1,11 +1,11 @@
 /**
  * Provider-reported token accounting for plugin-owned direct LLM calls.
  *
- * The review gate, planner, wrap-up command, and local-fate classifier all use
- * the shared `streamText` helper. These calls do not belong to an Agent turn
- * (they pass no sessionId), so the host session token-meter cannot attribute
- * them. This ledger records the exact `TokenUsage` emitted by the adapter at
- * the one shared stream boundary instead.
+ * The review gate, planner, dedicated memory agent, wrap-up command, and
+ * local-fate classifier all use the shared model-call boundary. These calls do
+ * not belong to an Agent turn (they pass no sessionId), so the host session
+ * token-meter cannot attribute them. This ledger records the exact
+ * `TokenUsage` emitted by the adapter at the one shared stream boundary.
  *
  * Storage: `<baseDir>/evolve/token-usage.jsonl`. The file contains route and
  * count metadata only — never prompts, responses, or tool arguments — and is
@@ -17,7 +17,7 @@ import { EVOLVE_DIR, pruneJsonlFile } from "./store.js";
 const TOKEN_USAGE_FILE = "token-usage.jsonl";
 export const TOKEN_USAGE_LEDGER_VERSION = 1;
 /** Plugin-owned direct call paths represented in the ledger. */
-export const TOKEN_USAGE_PHASES = ["review", "planner", "wrapup", "fate"];
+export const TOKEN_USAGE_PHASES = ["review", "memory", "planner", "wrapup", "fate"];
 /** Absolute path of the direct-call token ledger. */
 export function tokenUsagePath(baseDir) {
     return join(baseDir, EVOLVE_DIR, TOKEN_USAGE_FILE);
@@ -139,7 +139,7 @@ export function renderTokenUsageReport(ledger, retain) {
         return [
             `direct LLM token usage: no valid calls in the retained tail.${corrupt}`,
             `window: last ${retain} call(s), not a lifetime total.`,
-            "scope: review/planner/wrapup/fate only; host benchmark subagents, their agent-loop calls, and per-entry injection cost are excluded.",
+            "scope: review/memory/planner/wrapup/fate only; host benchmark subagents, their agent-loop calls, and per-entry injection cost are excluded.",
         ];
     }
     const totals = aggregateTokenUsage(records);
@@ -166,7 +166,7 @@ export function renderTokenUsageReport(ledger, retain) {
         const lastTotal = last.usage ? exactTokenTotal(last.usage) : "usage unavailable";
         lines.push(`last: ${last.phase} ${last.provider}/${last.model} · ${last.outcome} · ${lastTotal} tokens · ${last.timestamp}`);
     }
-    lines.push("scope: review/planner/wrapup/fate only; host benchmark subagents, their agent-loop calls, and per-entry injection cost are excluded.");
+    lines.push("scope: review/memory/planner/wrapup/fate only; host benchmark subagents, their agent-loop calls, and per-entry injection cost are excluded.");
     return lines;
 }
 function isTokenUsageRecord(value) {