dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/copy.js

@@ -1,14 +1,3 @@
-/**
- * Backend user-visible copy for the four evolution confirmation dialogs,
- * in both shipped languages. Labels stay literal per language (the parsers
- * match them); guidance lives in `description`.
- *
- * Language is never hardcoded at a call site: every builder takes an
- * explicit `lang`, and dialog entry points resolve it per call
- * (explicit config upstream, else the durable DSH client preference,
- * else `en`) when the caller does not supply one.
- */
-import { resolveRecordLanguage } from "./record-language.js";
 /** Maximum edit-summary chars carried into a dialog; longer text truncates. */
 export const COPY_WHAT_MAX_CHARS = 300;
 function compactWhat(what) {
@@ -42,46 +31,6 @@ export function approvalCopy(scope, what, lang) {
         ],
     };
 }
-/**
- * Local-fate homing consult (`evolve-fate-consult`).
- *
- * @param sections Pre-rendered per-item lines per group.
- * @param lang Dialog language.
- */
-export function fateConsultCopy(sections, lang) {
-    if (lang === "zh") {
-        const lines = ["自进化门禁：本会话 local 条目需要归宿处理"];
-        if (sections.promotable.length > 0 || sections.splits.length > 0) {
-            lines.push("【提升到全局（写入全局 store）】", ...sections.promotable, ...sections.splits);
-        }
-        if (sections.reviewArchives.length > 0) {
-            lines.push("【归档（本地隐藏，可恢复）】", ...sections.reviewArchives);
-        }
-        lines.push("提升写入后所有会话可见，归档隐藏但可恢复。是否执行？");
-        return {
-            question: lines.join("\n"),
-            options: [
-                { label: "执行", description: "提升写全局，归档隐藏本地（均可恢复）" },
-                { label: "不执行", description: "全部保留，10 回合内不再打扰" },
-            ],
-        };
-    }
-    const lines = ["Evolution gate: this session's local entries need homing"];
-    if (sections.promotable.length > 0 || sections.splits.length > 0) {
-        lines.push("[Promote to global (write to the global store)]", ...sections.promotable, ...sections.splits);
-    }
-    if (sections.reviewArchives.length > 0) {
-        lines.push("[Archive (hidden locally, restorable)]", ...sections.reviewArchives);
-    }
-    lines.push("Promotions become visible to all sessions; archives hide but stay restorable. Proceed?");
-    return {
-        question: lines.join("\n"),
-        options: [
-            { label: "Proceed", description: "Promote to global, archive locally (all reversible)" },
-            { label: "Skip", description: "Keep everything, cooldown 10 turns" },
-        ],
-    };
-}
 /**
  * Single-entry wrap-up archive confirm (`evolve-wrapup-archive-review`).
  *
@@ -106,55 +55,4 @@ export function wrapupArchiveCopy(title, lang) {
         ],
     };
 }
-/**
- * Skill solidification consult (`evolve-skill-consult`).
- *
- * @param description Pre-rendered per-edit lines.
- * @param lang Dialog language.
- */
-export function skillConsultCopy(description, lang) {
-    if (lang === "zh") {
-        return {
-            question: `发现可复用的流程，建议固化为技能\n${description}\n\n固化后以后同类任务自动复用，可回滚。是否固化？`,
-            options: [
-                { label: "固化", description: "生成技能，以后复用" },
-                { label: "不固化", description: "本次跳过，10 回合内不再打扰" },
-            ],
-        };
-    }
-    return {
-        question: `Reusable workflow found, suggest solidifying as a skill\n${description}\n\nSolidified skills are reused by similar tasks later, reversible. Solidify?`,
-        options: [
-            { label: "Solidify", description: "Create the skill for reuse" },
-            { label: "Skip", description: "Skip this time, cooldown 10 turns" },
-        ],
-    };
-}
-/**
- * One skill-edit line inside the solidification consult.
- *
- * @param action Edit action (`create` etc.).
- * @param title Entry title or id fallback.
- * @param skillKind `guidance` skills are SKILL.md documents.
- * @param lang Dialog language.
- */
-export function skillEditLine(action, title, skillKind, lang) {
-    if (lang === "zh") {
-        const form = skillKind === "guidance" ? "guidance 技能（SKILL.md 文档）" : "可执行技能";
-        return `- ${action}「${title}」(${form})`;
-    }
-    const form = skillKind === "guidance" ? "guidance skill (SKILL.md document)" : "executable skill";
-    return `- ${action} "${title}" (${form})`;
-}
-/**
- * Resolve the dialog language for a call site that holds no explicit
- * choice: durable client preference first, `en` otherwise. (Dialogs carry
- * no trajectory text, so there is no detection tier here.)
- *
- * @param ctx Host context for the durable-preference read.
- * @returns The dialog language.
- */
-export function resolveDialogLanguage(ctx) {
-    return resolveRecordLanguage({ ctx });
-}
 //# sourceMappingURL=copy.js.map

package/lib/declines.d.ts

@@ -97,5 +97,7 @@ export interface DeclinedCheckpointHit {
  * @param checkpointTokens - tokens of the pending checkpoint trajectory.
  * @returns the strongest hit, or undefined when nothing clears the floor.
  */
+/** Convenience: load the declined ledger and match one trajectory slice. */
+export declare function matchDeclinedTrajectory(baseDir: string, trajectory: string): DeclinedCheckpointHit | undefined;
 export declare function matchDeclinedCheckpoint(entries: readonly DeclinedMemoryBatch[], checkpointTokens: readonly string[]): DeclinedCheckpointHit | undefined;
 //# sourceMappingURL=declines.d.ts.map

package/lib/declines.js

@@ -151,6 +151,10 @@ export function declinedContentTokens(edits) {
  * @param checkpointTokens - tokens of the pending checkpoint trajectory.
  * @returns the strongest hit, or undefined when nothing clears the floor.
  */
+/** Convenience: load the declined ledger and match one trajectory slice. */
+export function matchDeclinedTrajectory(baseDir, trajectory) {
+    return matchDeclinedCheckpoint(loadDeclinedMemory(baseDir), tokenize(trajectory));
+}
 export function matchDeclinedCheckpoint(entries, checkpointTokens) {
     const pending = new Set(checkpointTokens);
     let best;

package/lib/evolve-event.js

@@ -11,7 +11,8 @@
  */
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { DEFAULT_REVIEWS_RETAIN, pruneJsonlFile, reviewsPath } from "./store.js";
+import { DEFAULT_REVIEWS_RETAIN } from "./types.js";
+import { pruneJsonlFile, reviewsPath } from "./store.js";
 /** Build a structured evolve-complete event from a refinement result. */
 export function buildEvolveCompleteEvent(result, trigger, sessionId) {
     return {

package/lib/extraction-phase.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The dedicated memory extraction phase: one bounded ZCode-style loop over a
+ * scheduler snapshot. Owns its request loop, frozen manifest, scope approval
+ * bookkeeping, and the phase-specific memory checkpoint that advances after a
+ * successful/no-op outcome — memory failures leave the boundary retryable.
+ *
+ * Triggered only by the low-frequency moments wired in `listener.ts`;
+ * per-turn extraction was removed with the 2026-10-03 B verdict.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { EvolutionEngine } from "./service.js";
+import { type TurnSnapshot } from "./turn-snapshot.js";
+import type { HarnessState, ScopeApprovalDecision } from "./types.js";
+import type { PlannerPrefixCacheMode } from "./types.js";
+import { type RecordLanguagePreference } from "./record-language.js";
+export interface GateState {
+    turns: number;
+    /** Latest successful turn boundary seen by the listener. */
+    completedTurn: number;
+    /** Latest successful/no-op memory boundary. */
+    memoryCheckpoint?: string;
+    /** Per-boundary/scope approval decisions retained until the memory phase settles. */
+    memoryDecisions: Record<string, ScopeApprovalDecision>;
+    lastReviewAt: number;
+    /**
+     * Consecutive idle probes that observed the goal phase "blocked".
+     * Reset to 0 by any non-blocked probe and after a triggered moment.
+     */
+    goalBlockStreak: number;
+}
+export interface AutoReviewConfig {
+    /** Initial runtime state when no runtime.json exists. */
+    enabledByDefault?: boolean;
+    /** ZCode-style minimum lexical words in one direct user text part. */
+    memoryMinUserWords?: number;
+    /** Trajectory slice handed to the extractor, in characters. */
+    maxInputChars: number;
+    /** Output budget for the extraction loop. */
+    budgetTokens: number;
+    /** Queue a visible receipt follow-up after an applied goal-blocked moment. */
+    notifyOnAutoReview: boolean;
+    /**
+     * Optional model override for the extractor (cheaper model).
+     * Format: "provider/model" or just "model" (same provider as the agent).
+     * When absent, the extractor uses the agent's own provider/model.
+     */
+    reviewModel?: string;
+    /** Dedicated memory-agent writes to project/global require the normal human approval boundary. */
+    requireGlobalApproval?: boolean;
+    /**
+     * Authoring language for this run's records. Absent/`auto` resolves per
+     * call through the record-language chain (durable client preference,
+     * then trajectory detection, then `en`); `zh`/`en` pin it.
+     */
+    recordLanguage?: RecordLanguagePreference;
+    /**
+     * Prefix-cache routing for the extraction input. Absent mode → auto-detect;
+     * absent budget → the default prefix budget.
+     */
+    prefixCacheMode?: PlannerPrefixCacheMode;
+    prefixMaxChars?: number;
+    /**
+     * Goal-blocked trigger: after this many CONSECUTIVE idle probes that
+     * observe the session goal in phase "blocked", run one memory extraction
+     * so the blocked encounter is distilled. 0 disables. The streak resets on
+     * any non-blocked probe and after each triggered moment.
+     */
+    goalBlockedWrapupTurns: number;
+    /**
+     * Storage hygiene (#20): tail lines kept in the shared reviews.jsonl
+     * audit trail. Absent → the store default (readers need a recent
+     * window, not the full past).
+     */
+    reviewsRetain?: number;
+    /**
+     * Session-close bounded drain: how long a disposed session's in-flight
+     * extraction may settle before its owner signal aborts. Absent → 15s;
+     * 0 restores the legacy immediate abort.
+     */
+    sessionCloseDrainMs?: number;
+}
+export interface ReviewRecord {
+    timestamp: string;
+    sessionId: string;
+    reason: TurnSnapshot["reason"];
+    turnsSinceLastReview: number;
+    outcome: "approved" | "declined" | "failed" | "assessed" | "deferred" | "skipped" | "armed" | "applied" | "noop";
+    rationale?: string;
+    refinementId?: string;
+    /** P1 extraction stats (§6.7): wall time of the memory phase. */
+    durationMs?: number;
+    /** Extractor loop turns / manifest searches behind this row. */
+    memoryTurns?: number;
+    memorySearches?: number;
+    /** Applied edit count carried by an applied row. */
+    appliedEdits?: number;
+}
+export type ReviewRecorder = (entry: Omit<ReviewRecord, "timestamp">) => void;
+export declare function stateFor(map: Map<string, GateState>, sessionId: string): GateState;
+export declare function advanceMemoryCheckpoint(state: GateState, next: string): void;
+/**
+ * The state view the extractor judges: the session's local entries merged
+ * with the project and global stores, each entry carrying its real scope.
+ * Without the global half the extractor cannot see that a topic is already
+ * covered cross-session and happily re-sediments a local duplicate of it.
+ *
+ * The merged view is read-only context — applying still targets the raw
+ * local state (baseline checks compare local entries only).
+ */
+export declare function loadGateHarnessView(engine: EvolutionEngine, sessionId: string, opts?: {
+    projectKey?: string;
+}): HarnessState;
+/**
+ * Gap C1: parse a "provider/model" or "model" string into its components.
+ * Returns undefined when the input is empty (no override). A bare model name
+ * falls back to the agent's provider, then "deepseek".
+ * Exported for unit testing; production resolves it inside
+ * runMemoryExtractionPhase.
+ */
+export declare function parseReviewModel(reviewModel: string | undefined, fallbackProvider: string | undefined): {
+    provider: string;
+    model: string;
+} | undefined;
+/**
+ * One extraction run over a scheduler snapshot. Records noop / applied /
+ * declined audit rows with duration and loop stats, advances the memory
+ * checkpoint on settled outcomes, and queues a visible receipt only for an
+ * applied goal-blocked moment (compaction and session-close stay audit-only).
+ */
+export declare function runMemoryExtractionPhase(ctx: Context, engine: EvolutionEngine, agent: Agent, config: AutoReviewConfig, state: GateState, snapshot: TurnSnapshot, record: ReviewRecorder, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=extraction-phase.d.ts.map

package/lib/extraction-phase.js

@@ -0,0 +1,236 @@
+import { notifyMemoryExtraction } from "./notify.js";
+import { mergeHarnessStates } from "./state.js";
+import { projectKeyOf } from "./project.js";
+import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
+import { compareReviewCursors, sliceTurnSnapshot } from "./turn-snapshot.js";
+import { matchDeclinedTrajectory } from "./declines.js";
+import { runMemoryAgent, } from "./memory-agent.js";
+import { applyMemoryExtractionProposal } from "./memory-apply.js";
+import { buildMemoryManifest } from "./memory-manifest.js";
+import { DEFAULT_REVIEWS_RETAIN } from "./types.js";
+import { resolveRecordLanguage } from "./record-language.js";
+export function stateFor(map, sessionId) {
+    let state = map.get(sessionId);
+    if (!state) {
+        state = {
+            turns: 0,
+            completedTurn: 0,
+            memoryDecisions: {},
+            lastReviewAt: 0,
+            goalBlockStreak: 0,
+        };
+        map.set(sessionId, state);
+    }
+    return state;
+}
+export 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 extractor judges: the session's local entries merged
+ * with the project and global stores, each entry carrying its real scope.
+ * Without the global half the extractor cannot see that a topic is already
+ * covered cross-session and happily re-sediments a local duplicate of it.
+ *
+ * The merged view is read-only context — applying still targets the raw
+ * local state (baseline checks compare local entries only).
+ */
+export function loadGateHarnessView(engine, sessionId, opts) {
+    const projectState = opts?.projectKey ? engine.load("project", opts.projectKey) : undefined;
+    return mergeHarnessStates(engine.load("global", undefined), engine.load("local", sessionId), projectState ? { projectState } : undefined);
+}
+/**
+ * Gap C1: parse a "provider/model" or "model" string into its components.
+ * Returns undefined when the input is empty (no override). A bare model name
+ * falls back to the agent's provider, then "deepseek".
+ * Exported for unit testing; production resolves it inside
+ * runMemoryExtractionPhase.
+ */
+export function parseReviewModel(reviewModel, fallbackProvider) {
+    if (!reviewModel || reviewModel.trim().length === 0)
+        return undefined;
+    const slash = reviewModel.indexOf("/");
+    if (slash > 0) {
+        return { provider: reviewModel.slice(0, slash), model: reviewModel.slice(slash + 1) };
+    }
+    return { provider: fallbackProvider ?? "deepseek", model: reviewModel };
+}
+/**
+ * One extraction run over a scheduler snapshot. Records noop / applied /
+ * declined audit rows with duration and loop stats, advances the memory
+ * checkpoint on settled outcomes, and queues a visible receipt only for an
+ * applied goal-blocked moment (compaction and session-close stay audit-only).
+ */
+export async function runMemoryExtractionPhase(ctx, engine, agent, config, state, snapshot, record, signal) {
+    const sessionId = agent.id;
+    const turnsSinceLastReview = state.turns - state.lastReviewAt;
+    // This invocation becomes the new reference point for the next audit row.
+    state.lastReviewAt = state.turns;
+    const startedAt = Date.now();
+    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`);
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "noop",
+            rationale: `memory no-op (${snapshot.reason}): no new eligible evidence after checkpoint`,
+            durationMs: Date.now() - startedAt,
+            memoryTurns: 0,
+            memorySearches: 0,
+            appliedEdits: 0,
+        });
+        return;
+    }
+    const declinedHit = matchDeclinedTrajectory(engine.baseDir, memorySnapshot.trajectory);
+    if (declinedHit !== undefined) {
+        advanceMemoryCheckpoint(state, memorySnapshot.cursor);
+        ctx.logger("continual-evolve").info(`memory agent pre-suppressed (${snapshot.reason}) [${agent.id}]: checkpoint overlaps declined ${declinedHit.entry.scope}:${declinedHit.entry.fingerprint} (coverage ${(declinedHit.coverage * 100).toFixed(0)}%, ${declinedHit.hits} tokens) — agent not invoked`);
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "noop",
+            rationale: `memory pre-suppressed (${snapshot.reason}): checkpoint overlaps declined ${declinedHit.entry.scope}:${declinedHit.entry.fingerprint} — agent not invoked`,
+            durationMs: Date.now() - startedAt,
+            memoryTurns: 0,
+            memorySearches: 0,
+            appliedEdits: 0,
+        });
+        return;
+    }
+    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,
+        sessionId,
+        manifest,
+        trajectory: memorySnapshot.trajectory,
+        trajectoryEvents: memorySnapshot.events,
+        maxOutputTokens: config.budgetTokens,
+        ...(signal ? { signal } : {}),
+        tokenUsage,
+        language: resolveRecordLanguage({ configured: config.recordLanguage, ctx, trajectoryText: memorySnapshot.trajectory }),
+        ...((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}`);
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "noop",
+            rationale: `memory no-op (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}`,
+            durationMs: Date.now() - startedAt,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: 0,
+        });
+        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),
+        ...(config.recordLanguage !== undefined ? { recordLanguage: config.recordLanguage } : {}),
+        ...(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(",")}` : "";
+    const durationMs = Date.now() - startedAt;
+    for (const result of application.results) {
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "applied",
+            rationale: `memory applied (${snapshot.reason}) after ${run.turns} turn(s): ${run.proposal.rationale}${declined}`,
+            refinementId: result.id,
+            durationMs,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: result.appliedEdits.filter((edit) => edit.applied).length,
+        });
+    }
+    if (application.declinedScopes.length > 0) {
+        record({
+            sessionId,
+            reason: snapshot.reason,
+            turnsSinceLastReview,
+            outcome: "declined",
+            rationale: `memory scopes declined (${snapshot.reason}): ${application.declinedScopes.join(",")}`,
+            durationMs,
+            memoryTurns: run.turns,
+            memorySearches: run.searches,
+            appliedEdits: 0,
+        });
+    }
+    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}`);
+    // Visibility (P1 unified receipt): only applied outcomes wake the agent
+    // with a follow-up — and only on the goal-blocked moment, which runs
+    // mid-session; compaction and session-close stay audit-only
+    // (reviews.jsonl) so they never wake the agent mid-compaction or after
+    // disposal.
+    if (config.notifyOnAutoReview && snapshot.reason === "goal_blocked" && applied > 0) {
+        notifyMemoryExtraction(ctx, agent, {
+            outcome: "applied",
+            results: application.results,
+            ...(application.declinedScopes.length > 0 ? { declinedScopes: [...application.declinedScopes] } : {}),
+            turns: run.turns,
+            searches: run.searches,
+            durationMs,
+        });
+    }
+}
+//# sourceMappingURL=extraction-phase.js.map

package/lib/index.d.ts

@@ -19,9 +19,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * Absent → 15s; 0 restores the legacy immediate abort on dispose.
      */
     sessionCloseDrainMs: z<number, number, "defined">;
-    /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
-    reviewIntervalTurns: z<number, number, "defined">;
-    /** Trajectory slice handed to the gate, in characters. */
+    /** Trajectory slice handed to the extractor, in characters. */
     maxReviewInputChars: z<number, number, "defined">;
     /** Output budget for the cheap gate call. */
     reviewBudgetTokens: z<number, number, "defined">;
@@ -31,7 +29,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * cache-read evidence (dropping the redundant flat trajectory text),
      * `session` always prefixes, `off` keeps the legacy flat-text input.
      */
-    plannerPrefixCache: z<"session" | "off" | "auto", "session" | "off" | "auto", "defined">;
+    plannerPrefixCache: z<"session" | "auto" | "off", "session" | "auto" | "off", "defined">;
     /** Session-prefix budget for Route A planning inputs, in characters. */
     plannerPrefixMaxChars: z<number, number, "defined">;
     /** After an approved gate run with applied edits, queue a visible follow-up notice. */
@@ -44,7 +42,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * `auto` follows the DSH client language (durable `locale.preference`,
      * then trajectory detection, then `en`); `zh`/`en` pin it.
      */
-    recordLanguage: z<"zh" | "en" | "auto", "zh" | "en" | "auto", "defined">;
+    recordLanguage: z<"auto" | "zh" | "en", "auto" | "zh" | "en", "defined">;
     /** Skills root for materialized skill entries; defaults to <dshHome>/skills. */
     skillsDir: z<string, string, "plain">;
     /** Passphrase for rubric encryption; falls back to DSH_EVOLVE_RUBRIC_KEY, then a local key file. */
@@ -64,29 +62,23 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      */
     autoCase: z<boolean, boolean, "defined">;
     /**
-     * Gap C1: optional model override for the review gate (cheaper model).
+     * Optional model override for the memory extractor (cheaper model).
      * Format: "provider/model" or just "model" (same provider as the agent).
-     * When absent, the review gate uses the agent's own provider/model.
+     * When absent, the extractor uses the agent's own provider/model.
      */
     reviewModel: z<string, string, "plain">;
     /**
-     * Gate local-fate dimension (#11 P2): the gate audits the session's local
-     * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on;
-     * disabled by default even when the automatic pipeline is explicitly enabled.
+     * Goal-blocked moment: after this many CONSECUTIVE idle probes that
+     * observe the session goal in phase "blocked", run one memory extraction
+     * so the stuck encounter is distilled. 0 disables.
      */
-    localFate: z<boolean, boolean, "defined">;
-    /**
-     * Minimum turns between local-fate assessments on the turn-interval path
-     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
-     */
-    fateIntervalTurns: z<number, number, "plain">;
+    goalBlockedWrapupTurns: z<number, number, "defined">;
     /**
-     * Goal-blocked trigger (D3): after this many CONSECUTIVE gate runs that
-     * observe the session goal in phase "blocked", run one local-fate
-     * assessment so the encounter is distilled. 0 disables.
+     * Promotion policy (2026-08-22): regex sources whose match in a
+     * candidate's title/content marks it project-scoped — such entries are
+     * never promoted to the cross-session global store. Replaces the built-in
+     * defaults when set.
      */
-    goalBlockedWrapupTurns: z<number, number, "defined">;
     /**
      * Promotion policy (2026-08-22): regex sources whose match in a
      * candidate's title/content marks it project-scoped — such entries are
@@ -149,9 +141,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * Absent → 15s; 0 restores the legacy immediate abort on dispose.
      */
     sessionCloseDrainMs: z<number, number, "defined">;
-    /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
-    reviewIntervalTurns: z<number, number, "defined">;
-    /** Trajectory slice handed to the gate, in characters. */
+    /** Trajectory slice handed to the extractor, in characters. */
     maxReviewInputChars: z<number, number, "defined">;
     /** Output budget for the cheap gate call. */
     reviewBudgetTokens: z<number, number, "defined">;
@@ -161,7 +151,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * cache-read evidence (dropping the redundant flat trajectory text),
      * `session` always prefixes, `off` keeps the legacy flat-text input.
      */
-    plannerPrefixCache: z<"session" | "off" | "auto", "session" | "off" | "auto", "defined">;
+    plannerPrefixCache: z<"session" | "auto" | "off", "session" | "auto" | "off", "defined">;
     /** Session-prefix budget for Route A planning inputs, in characters. */
     plannerPrefixMaxChars: z<number, number, "defined">;
     /** After an approved gate run with applied edits, queue a visible follow-up notice. */
@@ -174,7 +164,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      * `auto` follows the DSH client language (durable `locale.preference`,
      * then trajectory detection, then `en`); `zh`/`en` pin it.
      */
-    recordLanguage: z<"zh" | "en" | "auto", "zh" | "en" | "auto", "defined">;
+    recordLanguage: z<"auto" | "zh" | "en", "auto" | "zh" | "en", "defined">;
     /** Skills root for materialized skill entries; defaults to <dshHome>/skills. */
     skillsDir: z<string, string, "plain">;
     /** Passphrase for rubric encryption; falls back to DSH_EVOLVE_RUBRIC_KEY, then a local key file. */
@@ -194,29 +184,23 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
      */
     autoCase: z<boolean, boolean, "defined">;
     /**
-     * Gap C1: optional model override for the review gate (cheaper model).
+     * Optional model override for the memory extractor (cheaper model).
      * Format: "provider/model" or just "model" (same provider as the agent).
-     * When absent, the review gate uses the agent's own provider/model.
+     * When absent, the extractor uses the agent's own provider/model.
      */
     reviewModel: z<string, string, "plain">;
     /**
-     * Gate local-fate dimension (#11 P2): the gate audits the session's local
-     * entries on its own cadence and proposes promote/archive — consulted
-     * first, never written silently. Only meaningful with autoReview on;
-     * disabled by default even when the automatic pipeline is explicitly enabled.
+     * Goal-blocked moment: after this many CONSECUTIVE idle probes that
+     * observe the session goal in phase "blocked", run one memory extraction
+     * so the stuck encounter is distilled. 0 disables.
      */
-    localFate: z<boolean, boolean, "defined">;
-    /**
-     * Minimum turns between local-fate assessments on the turn-interval path
-     * (compaction is unconditional). Absent → follows reviewIntervalTurns.
-     */
-    fateIntervalTurns: z<number, number, "plain">;
+    goalBlockedWrapupTurns: z<number, number, "defined">;
     /**
-     * Goal-blocked trigger (D3): after this many CONSECUTIVE gate runs that
-     * observe the session goal in phase "blocked", run one local-fate
-     * assessment so the encounter is distilled. 0 disables.
+     * Promotion policy (2026-08-22): regex sources whose match in a
+     * candidate's title/content marks it project-scoped — such entries are
+     * never promoted to the cross-session global store. Replaces the built-in
+     * defaults when set.
      */
-    goalBlockedWrapupTurns: z<number, number, "defined">;
     /**
      * Promotion policy (2026-08-22): regex sources whose match in a
      * candidate's title/content marks it project-scoped — such entries are