dsh-continual-evolve 0.7.2 → 0.7.4

package/lib/review-scheduler.js

@@ -1,90 +1,172 @@
 /**
- * Serial latest-pending scheduler for automatic review snapshots.
+ * Serial latest-boundary scheduler for automatic memory+review snapshots.
  *
- * This is the DSH equivalent of ZCode's memory extraction scheduler: one
- * runner per session, at most one running snapshot, and one replaceable
- * pending snapshot while the runner is busy. A cursor advances only after a
- * successful or no-op execution; errors and aborts leave it untouched so the
- * next snapshot retries the same durable boundary.
+ * 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 coalescing and cursor semantics.
+ * 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 latestPending;
     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 || shutdownController.signal.aborted)
+        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: shutdownController.signal });
+            status = await execute({ snapshot, signal });
         }
         catch {
-            // A failed acquisition/extraction is deliberately contained. The
-            // cursor remains unchanged and the next snapshot retries it.
             return;
         }
-        if (!shuttingDown && (status === "success" || status === "no-op")) {
-            cursor = cursorOf(snapshot);
+        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 current = first;
-            while (current && !shuttingDown) {
-                const acquisition = await waitForSnapshotAcquisitionOrShutdown(current, shutdownController.signal);
-                if (acquisition.status === "shutdown" || shuttingDown)
-                    break;
-                if (acquisition.status === "acquired") {
+            let acquisition = await waitForSnapshotAcquisitionOrShutdown(first, signal);
+            while (acquisition.status !== "shutdown" && !shuttingDown) {
+                if (acquisition.status === "acquired")
                     await processSnapshot(acquisition.snapshot);
-                }
-                current = shuttingDown ? undefined : latestPending;
-                latestPending = undefined;
+                const next = await takeHighestPending();
+                if (!next)
+                    break;
+                acquisition = next;
             }
         }
         finally {
-            if (shuttingDown)
-                latestPending = undefined;
+            if (shuttingDown) {
+                pending.length = 0;
+                wakePending?.();
+                wakePending = undefined;
+            }
             running = undefined;
         }
     };
     return {
         async drain() {
-            while (running) {
+            while (running)
                 await running;
-            }
         },
         getCursor() {
             return cursor;
         },
         hasPendingWork() {
-            return running !== undefined || latestPending !== undefined;
+            return running !== undefined || pending.length > 0;
         },
         schedule(snapshot) {
             if (shuttingDown)
                 return;
             const acquisition = acquireSnapshot(snapshot);
-            if (running) {
-                // Replace, never queue: a burst of turns contributes one latest
-                // boundary and the next extraction consumes all intervening rows.
-                latestPending = acquisition;
-                return;
-            }
-            running = run(acquisition);
+            if (running)
+                trackPending(acquisition);
+            else
+                running = run(acquisition);
         },
         shutdown() {
             if (shuttingDown)
                 return;
             shuttingDown = true;
-            latestPending = undefined;
+            pending.length = 0;
             shutdownController.abort();
+            wakePending?.();
+            wakePending = undefined;
         },
     };
 }

package/lib/review.d.ts

@@ -44,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

@@ -2,15 +2,16 @@ import { extractJsonObject } from "./plan.js";
 import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
 import { sessionEventsOf } from "./inject.js";
 import { buildPrefixMessages, detectPlannerRoute, resolvePrefixCache } from "./prefix-cache.js";
-import { streamText } from "./llm-text.js";
+import { asLlmSessionId, 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
@@ -125,6 +126,7 @@ export async function reviewAutoRefine(ctx, options) {
     const text = await streamText(ctx, {
         provider,
         model,
+        sessionId: asLlmSessionId(agent.id),
         system: AUTO_REVIEW_SYSTEM_PROMPT,
         prompt: userPrompt,
         maxTokens: options.budgetTokens ?? 8000,

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) {

package/lib/turn-snapshot.d.ts

@@ -23,6 +23,9 @@ export interface TurnSnapshot {
     readonly trajectory: string;
     readonly userText: string;
     readonly sourceSeqs: readonly number[];
+    readonly maxChars: number;
+    /** Cursor supplied by the shared scheduler before this snapshot selected events. */
+    readonly capturedAfterCursor?: string;
     readonly eligible: boolean;
     readonly skipReason?: SnapshotSkipReason;
 }
@@ -43,6 +46,13 @@ export declare function captureTurnSnapshot(ctx: Context, agent: Agent, opts: {
     cursor?: string;
     maxChars: number;
 }): Promise<TurnSnapshot>;
+/**
+ * Rebase one captured snapshot onto a phase-specific cursor while preserving
+ * its outer boundary. The memory phase uses this after a downstream review or
+ * fate failure: already-processed evidence is removed, but newly captured rows
+ * remain available without moving the shared scheduler cursor backwards.
+ */
+export declare function sliceTurnSnapshot(snapshot: TurnSnapshot, cursor: string): TurnSnapshot;
 /**
  * Decide whether the incremental rows deserve a model call. This intentionally
  * does not decide whether a fact is valuable; that remains the review model's

package/lib/turn-snapshot.js

@@ -21,6 +21,27 @@ export async function captureTurnSnapshot(ctx, agent, opts) {
         trajectory: eligibility.eligible ? serializeSnapshotEvents(events, opts.maxChars) : "",
         userText: eligibility.userText,
         sourceSeqs: directUserSeqs(events),
+        maxChars: opts.maxChars,
+        ...(opts.cursor === undefined ? {} : { capturedAfterCursor: opts.cursor }),
+        eligible: eligibility.eligible,
+        ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
+    };
+}
+/**
+ * Rebase one captured snapshot onto a phase-specific cursor while preserving
+ * its outer boundary. The memory phase uses this after a downstream review or
+ * fate failure: already-processed evidence is removed, but newly captured rows
+ * remain available without moving the shared scheduler cursor backwards.
+ */
+export function sliceTurnSnapshot(snapshot, cursor) {
+    const events = sliceSnapshotEvents(snapshot, cursor);
+    const eligibility = evaluateSnapshotEligibility(events, false);
+    return {
+        ...snapshot,
+        events,
+        trajectory: eligibility.eligible ? serializeSnapshotEvents(events, snapshot.maxChars) : "",
+        userText: eligibility.userText,
+        sourceSeqs: directUserSeqs(events),
         eligible: eligibility.eligible,
         ...(eligibility.reason ? { skipReason: eligibility.reason } : {}),
     };
@@ -93,6 +114,19 @@ function boundaryCursor(events) {
     const seqs = events.map(eventSeq).filter((seq) => seq !== undefined);
     return seqs.length > 0 ? `seq:${Math.max(...seqs)}` : `index:${events.length}`;
 }
+function sliceSnapshotEvents(snapshot, cursor) {
+    if (snapshot.cursor.startsWith("index:") && cursor.startsWith("index:") && snapshot.capturedAfterCursor?.startsWith("index:")) {
+        const start = Number(snapshot.capturedAfterCursor.slice("index:".length));
+        const phaseBoundary = Number(cursor.slice("index:".length));
+        if (!Number.isInteger(start) || !Number.isInteger(phaseBoundary))
+            return snapshot.events;
+        const relative = phaseBoundary - start;
+        if (relative <= 0)
+            return snapshot.events;
+        return relative >= snapshot.events.length ? [] : snapshot.events.slice(relative);
+    }
+    return eventsAfterCursor(snapshot.events, cursor);
+}
 function eventsAfterCursor(events, cursor) {
     if (cursor === undefined)
         return events;

package/lib/wrapup.js

@@ -2,7 +2,7 @@ import { ARCHIVED_AT_KEY, PROMOTED_AT_KEY, PROMOTED_TO_KEY, SOURCE_SEQS_KEY, SOU
 import { MEMORY_TYPE_KEY, isMemoryType } from "./types.js";
 import { extractJsonObject } from "./plan.js";
 import { compactText } from "./render.js";
-import { streamText } from "./llm-text.js";
+import { asLlmSessionId, streamText } from "./llm-text.js";
 import { getUsageCount, loadUsage } from "./usage.js";
 import { createTokenUsageObserver } from "./token-usage.js";
 import { recencyScore } from "./inject.js";
@@ -522,6 +522,7 @@ export async function assessLocalEntries(ctx, agent, candidates, options = {}) {
     const text = await streamText(ctx, {
         provider: agent.options.provider,
         model: agent.options.model,
+        sessionId: asLlmSessionId(agent.id),
         system: WRAPUP_ASSESS_SYSTEM_PROMPT,
         prompt: userPrompt,
         maxTokens: options.maxOutputTokens ?? 4096,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Continual self-evolution plugin for DeepSeek Harness: versioned, auditable, rollback-safe harness state (prompt notes, memories, skills, subagent specs) refined from session trajectories.",
   "license": "MIT",
   "repository": {