dsh-continual-evolve 0.7.1 → 0.7.3

package/lib/auto.js

@@ -5,38 +5,45 @@
  * fire-and-forget with error containment: an auto-review failure never
  * disturbs the agent loop.
  *
- * Every gate decision (approved / declined / failed) is appended to
+ * Every gate decision (approved / declined / failed / skipped) is appended to
  * `<dshHome>/evolve/reviews.jsonl` so auto-review activity is durably
  * auditable — the server console is not a reliable place to look.
  *
  * Hook wiring:
- * - `agent/turn-stopping` increments a per-session turn counter (sync, cheap).
- * - `agent/status` (idle) checks the interval and may start the gate.
- * - `session/event` (compaction/start) starts an unconditional gate run so
- *   experiences about to be summarized away are persisted first.
+ * - `agent/turn-stopping` records the successful turn boundary.
+ * - `agent/status` (idle) captures an incremental snapshot and feeds the
+ *   per-session latest-pending serial scheduler.
+ * - `session/event` (compaction/start) forces a snapshot flush before data is
+ *   summarized away.
  */
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { slug } from "./types.js";
 import { planWithLlm } from "./planner.js";
-import { reviewAutoRefine, serializeSurface } from "./review.js";
-import { goalDrivesRounds, goalServiceOf } from "./goal.js";
+import { reviewAutoRefine } from "./review.js";
+import { goalServiceOf } from "./goal.js";
 import { notifyAutoReview } from "./notify.js";
 import { runLocalFatePhase } from "./fate.js";
-import { entrySourceOf } from "./source.js";
 import { mergeHarnessStates } from "./state.js";
 import { projectKeyOf } from "./project.js";
 import { questionServiceOf } from "./approval.js";
 import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
 import { DEFAULT_REVIEWS_RETAIN, pruneJsonlFile } from "./store.js";
-import { isGatePaused } from "./runtime.js";
+import { isGateEnabled } from "./runtime.js";
+import { compareReviewCursors, createReviewScheduler } from "./review-scheduler.js";
+import { captureTurnSnapshot, sliceTurnSnapshot } from "./turn-snapshot.js";
 import { captureAutoCase } from "./autocase.js";
+import { applyMemoryExtractionProposal, buildMemoryManifest, runMemoryAgent, } from "./memory-agent.js";
 /** Turns a rejected skill candidate stays silent before being offered again. */
 export const SKILL_CONSULT_COOLDOWN_TURNS = 10;
 export function registerAutoReview(ctx, engine, config) {
     const perSession = new Map();
+    const schedulers = new Map();
+    const captureTails = new Map();
+    const disposedSessions = new Set();
     const logger = ctx.logger("continual-evolve");
     const reviewsPath = join(engine.baseDir, "evolve", "reviews.jsonl");
+    const defaultEnabled = config.enabledByDefault ?? true;
     const record = (entry) => {
         try {
             mkdirSync(join(engine.baseDir, "evolve"), { recursive: true });
@@ -54,9 +61,83 @@ export function registerAutoReview(ctx, engine, config) {
             // ignored — the next record retries
         }
     };
-    // Turn counting uses `agent/turn-stopping` — empirically the only event
-    // whose payload carries the agent subject in every dispatch (verified: the
-    // gate fired under it at 20:56). `agent/status` serves as the idle trigger.
+    const schedulerFor = (agent, state) => {
+        const existing = schedulers.get(agent.id);
+        if (existing)
+            return existing;
+        const scheduler = createReviewScheduler(async ({ snapshot, signal }) => {
+            if (!isGateEnabled(engine.baseDir, defaultEnabled))
+                return "aborted";
+            if (!snapshot.eligible) {
+                record({
+                    sessionId: snapshot.sessionId,
+                    reason: snapshot.reason,
+                    turnsSinceLastReview: state.turns - state.lastReviewAt,
+                    outcome: "skipped",
+                    rationale: `snapshot ${snapshot.cursor} skipped: ${snapshot.skipReason ?? "not eligible"}`,
+                });
+                return "no-op";
+            }
+            try {
+                await runGate(ctx, engine, agent, config, state, snapshot, record, signal);
+                return "success";
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                logger.warn(`auto-review failed for ${agent.id}: ${message}`);
+                record({
+                    sessionId: agent.id,
+                    reason: snapshot.reason,
+                    turnsSinceLastReview: state.turns - state.lastReviewAt,
+                    outcome: "failed",
+                    rationale: `gate error: ${message}`,
+                });
+                return "error";
+            }
+        }, (snapshot) => snapshot.cursor);
+        schedulers.set(agent.id, scheduler);
+        return scheduler;
+    };
+    const captureAndSchedule = (agent, state, reason) => {
+        if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
+            return;
+        const turn = state.completedTurn;
+        const previousSnapshotTurn = state.lastSnapshotTurn;
+        if (reason === "turn_snapshot" && turn <= previousSnapshotTurn)
+            return;
+        if (reason === "turn_snapshot")
+            state.lastSnapshotTurn = turn;
+        const previousCapture = captureTails.get(agent.id) ?? Promise.resolve();
+        const captureTask = previousCapture.then(async () => {
+            if (disposedSessions.has(agent.id) || !isGateEnabled(engine.baseDir, defaultEnabled))
+                return;
+            const cursor = schedulerFor(agent, state).getCursor();
+            const snapshot = await captureTurnSnapshot(ctx, agent, {
+                turn,
+                reason,
+                ...(cursor !== undefined ? { cursor } : {}),
+                maxChars: config.maxInputChars,
+            });
+            if (!disposedSessions.has(agent.id))
+                schedulerFor(agent, state).schedule(snapshot);
+        }).catch((cause) => {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            logger.warn(`auto-review snapshot failed for ${agent.id}: ${message}`);
+            record({
+                sessionId: agent.id,
+                reason,
+                turnsSinceLastReview: state.turns - state.lastReviewAt,
+                outcome: "failed",
+                rationale: `snapshot error: ${message}`,
+            });
+            if (reason === "turn_snapshot" && state.lastSnapshotTurn === turn) {
+                state.lastSnapshotTurn = previousSnapshotTurn;
+            }
+        });
+        captureTails.set(agent.id, captureTask);
+    };
+    // DSH emits this awaited boundary when a turn is about to close. The idle
+    // transition is the safe point at which to read the durable surface.
     ctx.on("agent/turn-stopping", (payload) => {
         const agent = payload.agent;
         if (!agent) {
@@ -65,42 +146,20 @@ export function registerAutoReview(ctx, engine, config) {
         }
         const state = stateFor(perSession, agent.id);
         state.turns += 1;
+        if (typeof payload.turn === "number")
+            state.completedTurn = Math.max(state.completedTurn, payload.turn);
     });
     ctx.on("agent/status", (payload) => {
         const agent = payload.agent;
         if (!agent || payload.status !== "idle")
             return;
         const state = stateFor(perSession, agent.id);
-        // v3 optional: an active evolution goal drives the gate EVERY round
-        // (the goal's round machine keeps the session continuing); without a
-        // goal the plain turn interval applies.
-        const goalDriven = goalDrivesRounds(goalServiceOf(ctx)?.get(agent));
-        if (!goalDriven && state.turns - state.lastReviewAt < config.intervalTurns)
+        if (state.completedTurn <= state.lastSnapshotTurn)
             return;
-        // #21 P2 runtime switch: a paused gate stays fully dormant — no LLM
-        // calls, no fate assessments, no audit records. Checked after the
-        // cheap in-memory interval check so the paused path costs one file
-        // read at most. Manual tools/commands are unaffected (separate path).
-        if (isGatePaused(engine.baseDir))
-            return;
-        // Run the gate outside the listener turn: agent is idle, work is auxiliary.
-        // Every failure is durably recorded — nothing fails silently.
-        void runGate(ctx, engine, agent, config, state, "turn_interval", record).catch((cause) => {
-            const message = cause instanceof Error ? cause.message : String(cause);
-            logger.warn(`auto-review failed for ${agent.id}: ${message}`);
-            record({
-                sessionId: agent.id,
-                reason: "turn_interval",
-                turnsSinceLastReview: state.turns - state.lastReviewAt,
-                outcome: "failed",
-                rationale: `gate error: ${message}`,
-            });
-            state.lastReviewAt = state.turns; // back off until the interval elapses again
-        });
+        captureAndSchedule(agent, state, "turn_snapshot");
     });
-    // Diagnostic: the armed marker proves registerAutoReview ran with the
-    // configured interval; a restart that writes it but nothing after means the
-    // trigger events are not reaching this listener.
+    // Diagnostic: the armed marker proves the listener was registered even when
+    // its runtime default is off, distinguishing "not registered" from "off".
     try {
         mkdirSync(join(engine.baseDir, "evolve"), { recursive: true });
         appendFileSync(reviewsPath, `${JSON.stringify({
@@ -109,7 +168,7 @@ export function registerAutoReview(ctx, engine, config) {
             reason: "boot",
             turnsSinceLastReview: 0,
             outcome: "armed",
-            rationale: `auto-review gate registered (interval=${config.intervalTurns})`,
+            rationale: `auto-review gate registered (default=${defaultEnabled ? "on" : "off"}; per-success-turn snapshots; local-fate every ${config.fateIntervalTurns} turns)`,
         })}\n`, "utf8");
     }
     catch (cause) {
@@ -121,6 +180,16 @@ export function registerAutoReview(ctx, engine, config) {
     catch {
         // ignored — the next record retries
     }
+    ctx.on("agent/disposed", (payload) => {
+        const agent = payload.agent;
+        if (!agent)
+            return;
+        disposedSessions.add(agent.id);
+        schedulers.get(agent.id)?.shutdown();
+        schedulers.delete(agent.id);
+        captureTails.delete(agent.id);
+        perSession.delete(agent.id);
+    });
     ctx.on("session/event", (session, event) => {
         if (event.type !== "compaction/start")
             return;
@@ -129,21 +198,7 @@ export function registerAutoReview(ctx, engine, config) {
         if (!agent)
             return; // no live agent for that session (e.g. cold read)
         const state = stateFor(perSession, agent.id);
-        // Compaction is unconditional — unless the human paused the gate
-        // (#21): a paused gate skips even the compaction run, so "pause"
-        // is a true zero-LLM-call state.
-        if (isGatePaused(engine.baseDir))
-            return;
-        void runGate(ctx, engine, agent, config, state, "compact", record).catch((cause) => {
-            logger.warn(`auto-review failed at compaction for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
-            record({
-                sessionId: agent.id,
-                reason: "compact",
-                turnsSinceLastReview: state.turns - state.lastReviewAt,
-                outcome: "failed",
-                rationale: `gate error at compaction: ${cause instanceof Error ? cause.message : String(cause)}`,
-            });
-        });
+        captureAndSchedule(agent, state, "compact");
     });
 }
 /**
@@ -167,6 +222,9 @@ function stateFor(map, sessionId) {
     if (!state) {
         state = {
             turns: 0,
+            completedTurn: 0,
+            lastSnapshotTurn: 0,
+            memoryDecisions: {},
             lastReviewAt: 0,
             running: false,
             skillRejects: new Map(),
@@ -178,6 +236,21 @@ function stateFor(map, sessionId) {
     }
     return state;
 }
+function advanceMemoryCheckpoint(state, next) {
+    if (state.memoryCheckpoint === undefined) {
+        state.memoryCheckpoint = next;
+        return;
+    }
+    const order = compareReviewCursors(next, state.memoryCheckpoint);
+    if (order === undefined || order > 0)
+        state.memoryCheckpoint = next;
+}
+function rememberMemoryDecision(state, key, decision) {
+    state.memoryDecisions[key] = decision;
+    const keys = Object.keys(state.memoryDecisions);
+    while (keys.length > 128)
+        delete state.memoryDecisions[keys.shift() ?? ""];
+}
 /**
  * The state view the gate and planner judge: the session's local entries
  * merged with the project and global stores, each entry carrying its real
@@ -199,23 +272,23 @@ export function loadGateHarnessView(engine, sessionId, opts) {
  * review's baseline fresh — fate re-loads the store and never races the
  * review's optimistic-concurrency checks.
  */
-async function runGate(ctx, engine, agent, config, state, reason, record) {
+async function runGate(ctx, engine, agent, config, state, snapshot, record, signal) {
     // Reentry guard (review audit 2026-08-28 S3): a gate run holds LLM calls
     // and possibly a user question for a long time; an idle/compaction
     // trigger overlapping the run would start a second concurrent pipeline
     // whose stale whole-file saves clobber the first run's writes.
     if (state.running) {
-        ctx.logger("continual-evolve").info(`auto-review skipped [${agent.id}]: previous gate run still in flight`);
-        return;
+        throw new Error(`previous gate run still in flight for ${agent.id}`);
     }
     state.running = true;
     try {
-        await runReviewPhase(ctx, engine, agent, config, state, reason, record);
+        await runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal);
+        await runReviewPhase(ctx, engine, agent, config, state, snapshot, record, signal);
         // D3: a goal stuck in "blocked" for consecutive gate runs gets one
         // local-fate assessment (the pipeline below), so whatever led the
         // goal astray is distilled before the session moves on.
-        await runGoalBlockedFate(ctx, engine, agent, config, state, reason, record);
-        await runLocalFatePhase(ctx, engine, agent, config, state, reason, record);
+        await runGoalBlockedFate(ctx, engine, agent, config, state, snapshot.reason, record);
+        await runLocalFatePhase(ctx, engine, agent, config, state, snapshot.reason, record);
     }
     finally {
         state.running = false;
@@ -250,8 +323,87 @@ export async function runGoalBlockedFate(ctx, engine, agent, config, state, _rea
     logger.info(`auto-review goal-blocked trigger [${agent.id}]: ${config.goalBlockedWrapupTurns} consecutive blocked gate runs → local-fate assessment`);
     await runLocalFatePhase(ctx, engine, agent, config, state, "goal_blocked", record);
 }
-async function runReviewPhase(ctx, engine, agent, config, state, reason, record) {
+/**
+ * Dedicated ZCode-style memory phase. It shares the scheduler snapshot and
+ * snapshot with the general review, but owns its request loop, manifest and
+ * memory-only tool policy. Its phase-specific checkpoint advances after a
+ * successful/no-op memory outcome; later review/fate failures do not replay
+ * old memory decisions, while memory failures leave the boundary retryable.
+ */
+export async function runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, signal) {
+    const memorySnapshot = state.memoryCheckpoint ? sliceTurnSnapshot(snapshot, state.memoryCheckpoint) : snapshot;
+    if (!memorySnapshot.eligible || !memorySnapshot.trajectory) {
+        advanceMemoryCheckpoint(state, snapshot.cursor);
+        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${agent.id}]: no new eligible evidence after checkpoint`);
+        return;
+    }
+    const sessionId = agent.id;
+    const projectKey = snapshot.projectKey ?? projectKeyOf(agent);
+    const baselines = {
+        local: engine.load("local", sessionId),
+        global: engine.load("global", undefined),
+        ...(projectKey ? { project: engine.load("project", projectKey) } : {}),
+    };
+    const manifest = buildMemoryManifest(loadGateHarnessView(engine, sessionId, projectKey ? { projectKey } : undefined));
+    const overrideRoute = parseReviewModel(config.reviewModel, agent.options.provider);
+    const provider = overrideRoute?.provider ?? agent.options.provider;
+    const model = overrideRoute?.model ?? agent.options.model;
+    if (!provider || !model)
+        throw new Error("evolve: no provider/model route for the memory extraction agent");
+    const tokenUsage = {
+        baseDir: engine.baseDir,
+        sessionId,
+        retain: engine.retention.tokenUsage,
+        onError: (cause) => ctx
+            .logger("continual-evolve")
+            .warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
+    };
+    const run = await runMemoryAgent(ctx, {
+        provider,
+        model,
+        manifest,
+        trajectory: memorySnapshot.trajectory,
+        trajectoryEvents: memorySnapshot.events,
+        maxOutputTokens: config.budgetTokens,
+        ...(signal ? { signal } : {}),
+        tokenUsage,
+        ...((config.prefixCacheMode !== undefined || config.prefixMaxChars !== undefined
+            ? {
+                prefixCache: {
+                    ...(config.prefixCacheMode !== undefined ? { mode: config.prefixCacheMode } : {}),
+                    ...(config.prefixMaxChars !== undefined ? { maxChars: config.prefixMaxChars } : {}),
+                },
+            }
+            : {})),
+    });
+    if (run.proposal.edits.length === 0) {
+        advanceMemoryCheckpoint(state, memorySnapshot.cursor);
+        ctx.logger("continual-evolve").info(`memory agent no-op (${snapshot.reason}) [${sessionId}] after ${run.turns} turn(s): ${run.proposal.rationale}`);
+        return;
+    }
+    const source = { sessionId, ...(memorySnapshot.sourceSeqs.length > 0 ? { seqs: [...memorySnapshot.sourceSeqs] } : {}) };
+    const application = await applyMemoryExtractionProposal(ctx, engine, run.proposal, {
+        agent,
+        baselines,
+        ...(projectKey ? { projectKey } : {}),
+        requireApproval: config.requireGlobalApproval ?? true,
+        source,
+        decisionCursor: memorySnapshot.cursor,
+        scopeDecisions: state.memoryDecisions,
+        onScopeDecision: (key, decision) => rememberMemoryDecision(state, key, decision),
+        ...(signal ? { signal } : {}),
+    });
+    for (const result of application.results) {
+        emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, `memory_agent:${snapshot.reason}`, sessionId), config.reviewsRetain ?? DEFAULT_REVIEWS_RETAIN);
+    }
+    state.memoryCheckpoint = memorySnapshot.cursor;
+    const applied = application.results.reduce((count, result) => count + result.appliedEdits.filter((edit) => edit.applied).length, 0);
+    const declined = application.declinedScopes.length > 0 ? `; declined scopes=${application.declinedScopes.join(",")}` : "";
+    ctx.logger("continual-evolve").info(`memory agent applied ${applied} edit(s) across ${application.results.length} scope batch(es) [${sessionId}] after ${run.turns} turn(s)${declined}: ${run.proposal.rationale}`);
+}
+async function runReviewPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
     const sessionId = agent.id;
+    const reason = snapshot.reason;
     const turnsSinceLastReview = state.turns - state.lastReviewAt;
     const logger = ctx.logger("continual-evolve");
     const tokenUsage = {
@@ -260,14 +412,9 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         retain: engine.retention.tokenUsage,
         onError: (cause) => logger.warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
     };
-    const trajectory = await readTrajectory(ctx, agent, config.maxInputChars).catch((cause) => {
-        logger.warn(`auto-review skipped for ${sessionId}: trajectory unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
-        record({ sessionId, reason, turnsSinceLastReview, outcome: "failed", rationale: `trajectory unavailable: ${cause instanceof Error ? cause.message : String(cause)}` });
-        return undefined;
-    });
+    const trajectory = snapshot.trajectory;
     if (!trajectory) {
-        state.lastReviewAt = state.turns;
-        return;
+        throw new Error("eligible snapshot has no trajectory");
     }
     // The gate judges the merged view (global + local, scopes labeled) so it
     // can recognize topics already covered globally and decline duplicates;
@@ -283,6 +430,8 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         state: harnessState,
         history,
         trajectory,
+        trajectoryEvents: snapshot.events,
+        ...(signal ? { signal } : {}),
         context: { reason, turnsSinceLastReview },
         budgetTokens: config.budgetTokens,
         tokenUsage,
@@ -302,10 +451,13 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         record({ sessionId, reason, turnsSinceLastReview, outcome: "declined", rationale: review.rationale });
         return;
     }
-    const proposal = await planWithLlm(ctx, {
+    const plannedProposal = await planWithLlm(ctx, {
         agent,
         state: harnessState,
         history,
+        trajectory: snapshot.trajectory,
+        trajectoryEvents: snapshot.events,
+        ...(signal ? { signal } : {}),
         ...(review.instructions ? { instructions: review.instructions } : {}),
         global: false,
         // Read the skill-creator template facts (fallback: builtin distilled
@@ -321,6 +473,8 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
             }
             : {})),
     });
+    const proposal = stripDedicatedMemoryEdits(plannedProposal);
+    const memoryOnlyPlan = isDedicatedMemoryOnlyProposal(plannedProposal);
     // Skills are governed resources: an auto-created skill is OFFERED to the
     // user for a decision (固化/不固化) before it lands — the gate never
     // writes a skill silently. Without consent the skill edits are withheld
@@ -339,7 +493,7 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         logger.info(`auto-review declined (${reason}) [${sessionId}]: no consented edits${withheld} — ${review.rationale}`);
         // P1 auto-case capture: an attempted evolution that never landed is a
         // regression asset. Contained — capture failure must not disturb the gate.
-        if (config.autoCase) {
+        if (config.autoCase && !memoryOnlyPlan) {
             try {
                 const captured = captureAutoCase({
                     baseDir: engine.baseDir,
@@ -358,7 +512,7 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
         record({ sessionId, reason, turnsSinceLastReview, outcome: "declined", rationale: `${review.rationale}${withheld}` });
         return;
     }
-    const source = entrySourceOf(agent, sessionId);
+    const source = { sessionId, ...(snapshot.sourceSeqs.length > 0 ? { seqs: [...snapshot.sourceSeqs] } : {}) };
     const result = engine.apply("local", sessionId, finalProposal, {
         scope: "local",
         baselineState: localState,
@@ -369,20 +523,31 @@ async function runReviewPhase(ctx, engine, agent, config, state, reason, record)
     // Gap C4: emit structured evolve_complete event for third-party consumers.
     emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, `auto_review:${reason}`, sessionId), config.reviewsRetain ?? DEFAULT_REVIEWS_RETAIN);
     // Visibility: tell the user what the gate just persisted. Only the
-    // turn-interval path notifies — a compaction-triggered gate must not wake
+    // turn snapshot path notifies — a compaction-triggered gate must not wake
     // the agent mid-compaction — and only when something was actually applied
     // (a notice for zero edits is noise). Failure is contained in notifyAutoReview.
-    if (config.notifyOnAutoReview && reason === "turn_interval" && result.appliedEdits.some((e) => e.applied)) {
+    if (config.notifyOnAutoReview && reason === "turn_snapshot" && result.appliedEdits.some((e) => e.applied)) {
         notifyAutoReview(ctx, agent, result, turnsSinceLastReview);
     }
 }
-async function readTrajectory(ctx, agent, maxChars) {
-    const sessionQuery = ctx.sessionQuery;
-    if (!sessionQuery) {
-        throw new Error("sessionQuery unavailable");
-    }
-    const snapshot = await sessionQuery.readSurface(agent.id);
-    return serializeSurface(snapshot.events, maxChars);
+/** True when the general planner returned only edits owned by the memory phase. */
+export function isDedicatedMemoryOnlyProposal(proposal) {
+    return proposal.edits.length > 0 && proposal.edits.every((edit) => edit.kind === "memory");
+}
+/**
+ * Remove memory edits from the general auto-review planner. The dedicated
+ * memory phase owns this responsibility and has already run against the same
+ * snapshot; accepting a second memory proposal would reintroduce duplicates.
+ */
+export function stripDedicatedMemoryEdits(proposal) {
+    const edits = proposal.edits.filter((edit) => edit.kind !== "memory");
+    if (edits.length === proposal.edits.length)
+        return proposal;
+    return {
+        ...proposal,
+        edits,
+        summary: `${proposal.summary} (memory edits owned by dedicated extractor)`,
+    };
 }
 /**
  * Split a proposal into skill edits and everything else. Skill edits are the

package/lib/command.d.ts

@@ -18,9 +18,8 @@ export interface CommandRuntimeOptions {
     /** Mechanical promotion guards for wrapup/fate (2026-08-22 policy). */
     promotionPolicy: PromotionPolicy;
     /**
-     * Static patch flag for the auto-review gate (#21 status display).
-     * Absent (older wiring/tests) renders as unknown — the runtime pause
-     * switch still works.
+     * Initial auto-review default from plugin config. The listener is always
+     * registered; this is not a registration gate.
      */
     autoReview?: boolean;
 }

package/lib/command.js

@@ -376,18 +376,22 @@ async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
             }
             case "pause":
             case "resume": {
-                // #21 P2 runtime switch: pause the AUTOMATIC gate only. Manual
-                // evolve_* tools and /evolve commands keep working — the human
-                // is acting explicitly there, so no gate is being bypassed.
+                // The switch is independent of the static registration flag. A
+                // resume explicitly enables automatic snapshots; a pause leaves
+                // the enable bit intact so status explains the paused state.
                 const pausing = sub === "pause";
-                const current = loadGateRuntime(engine.baseDir);
-                if (current.paused === pausing) {
-                    return success(`auto-review gate is already ${pausing ? "paused" : "running"} (no change).`);
+                const defaultEnabled = runtime.autoReview ?? false;
+                const current = loadGateRuntime(engine.baseDir, defaultEnabled);
+                if (pausing && current.paused) {
+                    return success("auto-review gate is already paused (no change).");
                 }
-                saveGateRuntime(engine.baseDir, pausing);
+                if (!pausing && current.enabled && !current.paused) {
+                    return success("auto-review gate is already running (no change).");
+                }
+                saveGateRuntime(engine.baseDir, pausing, pausing ? current.enabled : true);
                 return success(pausing
-                    ? "auto-review gate paused: no automatic reviews, fate assessments, or gate LLM calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
-                    : "auto-review gate resumed: automatic reviews run again on their configured cadence.");
+                    ? "auto-review gate paused: no automatic snapshots, fate assessments, or gate LLM calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
+                    : "auto-review gate resumed: successful turns will produce incremental snapshots immediately.");
             }
             case "status": {
                 return success(renderGateStatus(engine, sessionId, projectKeyOf(invocation.agent), runtime));
@@ -454,16 +458,14 @@ function demoteEntry(engine, id, sessionId, projectKey) {
     return error(`entry ${id} not found in the global, project, or local store`);
 }
 /**
- * #21 status: one screen answering "is the gate on, and what is in the
- * stores". The patch flag says whether the gate was registered at boot;
- * the runtime switch says whether the human paused it since.
+ * Status answers whether the always-registered listener is enabled at runtime
+ * and what stores/retention it currently sees.
  */
 function renderGateStatus(engine, sessionId, projectKey, runtime) {
-    const paused = loadGateRuntime(engine.baseDir).paused;
-    const patch = runtime.autoReview === undefined ? "unknown" : runtime.autoReview ? "on" : "off";
-    const gateLine = patch === "off"
-        ? "gate: disabled in patch config (autoReview off — /evolve pause has nothing to pause)"
-        : `gate: ${patch === "unknown" ? "patch flag unknown" : "enabled in patch config"} · ${paused ? "PAUSED by /evolve pause (resume with /evolve resume)" : "running"}`;
+    const configuredDefault = runtime.autoReview === undefined ? "unknown" : runtime.autoReview ? "on" : "off";
+    const current = loadGateRuntime(engine.baseDir, runtime.autoReview ?? false);
+    const effective = current.paused ? "PAUSED (resume with /evolve resume)" : current.enabled ? "running" : "off (enable with /evolve resume)";
+    const gateLine = `gate: listener registered · config default ${configuredDefault} · runtime ${effective}`;
     const countEntries = (state) => Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
     const lines = [gateLine];
     lines.push(`stores: global ${countEntries(engine.load("global", undefined))} entries · local(${sessionId}) ${countEntries(engine.load("local", sessionId))} entries`);

package/lib/fate.d.ts

@@ -119,7 +119,7 @@ export interface FateApplyResult {
 export declare function applyLocalFates(engine: EvolutionEngine, sessionId: string, plan: FatePlan, localState: HarnessState, mode: FateApplyMode): FateApplyResult;
 /**
  * The gate's local-fate phase. Runs after the review phase on every gate
- * trigger (turn_interval / compact), subject to cadence and cooldown. All
+ * trigger (turn_snapshot / compact), subject to cadence and cooldown. All
  * failures are contained and recorded — a broken fate dimension never
  * disturbs the agent loop.
  */

package/lib/fate.js

@@ -192,7 +192,7 @@ export function applyLocalFates(engine, sessionId, plan, localState, mode) {
 }
 /**
  * The gate's local-fate phase. Runs after the review phase on every gate
- * trigger (turn_interval / compact), subject to cadence and cooldown. All
+ * trigger (turn_snapshot / compact), subject to cadence and cooldown. All
  * failures are contained and recorded — a broken fate dimension never
  * disturbs the agent loop.
  */
@@ -255,7 +255,7 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
             rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
             refinementId: results.map((result) => result.id).join(","),
         });
-        if (config.notifyOnAutoReview && reason === "turn_interval" && applied.length > 0) {
+        if (config.notifyOnAutoReview && (reason === "turn_snapshot" || reason === "turn_interval") && applied.length > 0) {
             notifyFateApplied(ctx, agent, applied);
         }
         return;
@@ -309,7 +309,7 @@ export async function runLocalFatePhase(ctx, engine, agent, config, state, reaso
             rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
             refinementId: results.map((result) => result.id).join(","),
         });
-        if (config.notifyOnAutoReview && reason === "turn_interval") {
+        if (config.notifyOnAutoReview && (reason === "turn_snapshot" || reason === "turn_interval")) {
             notifyFateApplied(ctx, agent, applied);
         }
         return;
@@ -333,7 +333,7 @@ export function buildFateNotice(applied) {
         "请用一句话简短确认即可，不要调用任何工具。",
     ].join("\n");
 }
-/** Queue the follow-up notice turn (turn_interval only, like the review notice). */
+/** Queue the follow-up notice turn (successful-turn path only). */
 function notifyFateApplied(ctx, agent, applied) {
     try {
         agent.followup(createUserMessage({

package/lib/index.d.ts

@@ -10,9 +10,9 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseDir: z<string, string, "plain">;
     /** System-prompt section order for the evolution guidance. */
     sectionOrder: z<number, number, "defined">;
-    /** Enable the automatic review gate (off by default: it costs model calls). */
+    /** Initial automatic-review default when no runtime switch exists (off by default: it costs model calls). */
     autoReview: z<boolean, boolean, "defined">;
-    /** Gate runs when this many turns have passed since the last review. */
+    /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */
     maxReviewInputChars: z<number, number, "defined">;
@@ -107,9 +107,9 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     baseDir: z<string, string, "plain">;
     /** System-prompt section order for the evolution guidance. */
     sectionOrder: z<number, number, "defined">;
-    /** Enable the automatic review gate (off by default: it costs model calls). */
+    /** Initial automatic-review default when no runtime switch exists (off by default: it costs model calls). */
     autoReview: z<boolean, boolean, "defined">;
-    /** Gate runs when this many turns have passed since the last review. */
+    /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */
     maxReviewInputChars: z<number, number, "defined">;