dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/service.d.ts

@@ -3,7 +3,7 @@
  * Every mutation path goes through here so snapshot-before-write, apply
  * accounting, persistence, and result history are enforced in one place.
  */
-import type { EntrySource, HarnessScope, RefinementProposal, RefinementResult } from "./types.js";
+import type { EntrySource, HarnessScope, HarnessState, 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. */
@@ -37,13 +37,27 @@ export interface EvolutionEngineOptions {
     historyRetain?: Partial<HistoryRetention>;
 }
 export declare function createEvolutionEngine(baseDir: string, hooks?: EvolutionHooks, opts?: EvolutionEngineOptions): {
-    load: (scope: HarnessScope, sessionId: string | undefined) => import("./types.js").HarnessState;
+    load: (scope: HarnessScope, sessionId: string | undefined) => 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[];
+    exportStore: (scope: HarnessScope, sessionId: string | undefined) => ExportedStore;
+    importStore: (scope: HarnessScope, sessionId: string | undefined, payload: unknown) => {
+        entries: number;
+        refinements: number;
+    };
     baseDir: string;
     retention: HistoryRetention;
 };
+/** The on-disk shape `/evolve export` writes and `/evolve import` reads. */
+export interface ExportedStore {
+    version: number;
+    scope: HarnessScope;
+    schema: number;
+    entries: HarnessState["entries"];
+    refinements: HarnessState["refinements"];
+    history: RefinementResult[];
+}
 export type EvolutionEngine = ReturnType<typeof createEvolutionEngine>;
 //# sourceMappingURL=service.d.ts.map

package/lib/service.js

@@ -175,6 +175,79 @@ export function createEvolutionEngine(baseDir, hooks = {}, opts = {}) {
     function history(scope, sessionId) {
         return loadResults(storePaths(baseDir, scope, sessionId));
     }
-    return { load, apply, rollback, rollbackResult, history, baseDir, retention };
+    /** Serialize one store (entries + refinement history) for `/evolve export`. */
+    function exportStore(scope, sessionId) {
+        const state = load(scope, sessionId);
+        return {
+            version: 1,
+            scope,
+            schema: state.schema,
+            entries: state.entries,
+            refinements: state.refinements,
+            history: history(scope, sessionId),
+        };
+    }
+    /**
+     * Replace one store from an export payload (raw state write — the same
+     * semantics the command always had: no snapshot, no per-edit validation,
+     * the payload is trusted because a human handed over the file).
+     */
+    function importStore(scope, sessionId, payload) {
+        if (!isValidExport(payload)) {
+            throw new Error("invalid export file shape: expected {version, entries: {prompt, memory, skill, subagent}, refinements, history}");
+        }
+        const entriesBlock = payload["entries"];
+        const state = {
+            schema: typeof payload["schema"] === "number" ? payload["schema"] : 1,
+            entries: {
+                prompt: toEntryRecord(entriesBlock["prompt"]),
+                memory: toEntryRecord(entriesBlock["memory"]),
+                skill: toEntryRecord(entriesBlock["skill"]),
+                subagent: toEntryRecord(entriesBlock["subagent"]),
+            },
+            refinements: Array.isArray(payload["refinements"]) ? payload["refinements"] : [],
+        };
+        const paths = storePaths(baseDir, scope, sessionId);
+        saveHarnessState(paths.stateDir, state);
+        let refinements = 0;
+        if (Array.isArray(payload["history"])) {
+            for (const result of payload["history"]) {
+                if (isResultRecord(result)) {
+                    appendResult(paths, result);
+                    refinements += 1;
+                }
+            }
+            // Storage hygiene (#20): an imported history obeys the same tail
+            // budget as a live one.
+            try {
+                pruneJsonlFile(paths.resultsPath, retention.refinements);
+            }
+            catch {
+                // ignored — the next apply retries
+            }
+        }
+        const entries = Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
+        return { entries, refinements };
+    }
+    return { load, apply, rollback, rollbackResult, history, exportStore, importStore, baseDir, retention };
+}
+function toEntryRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function isValidExport(payload) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+        return false;
+    const record = payload;
+    const entries = record["entries"];
+    if (typeof entries !== "object" || entries === null || Array.isArray(entries))
+        return false;
+    const kinds = ["prompt", "memory", "skill", "subagent"];
+    return kinds.every((kind) => Object.prototype.hasOwnProperty.call(entries, kind));
+}
+function isResultRecord(value) {
+    return typeof value === "object" && value !== null && "id" in value && "appliedEdits" in value;
 }
 //# sourceMappingURL=service.js.map

package/lib/store.d.ts

@@ -8,8 +8,7 @@ export declare const EVOLVE_DIR = "evolve";
  * full past. Tunable via the `historyRetain` plugin config.
  */
 export declare const DEFAULT_SNAPSHOT_RETAIN = 20;
-export declare const DEFAULT_REFINEMENTS_RETAIN = 500;
-export declare const DEFAULT_REVIEWS_RETAIN = 500;
+export { DEFAULT_REFINEMENTS_RETAIN, DEFAULT_REVIEWS_RETAIN } from "./types.js";
 export declare const DEFAULT_TOKEN_USAGE_RETAIN = 500;
 /** Resolved retention set: how many snapshots / JSONL tail lines to keep. */
 export interface HistoryRetention {

package/lib/store.js

@@ -14,6 +14,7 @@
  * no way to skip it — it runs inside the service, not in a prompt.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { DEFAULT_REFINEMENTS_RETAIN, DEFAULT_REVIEWS_RETAIN } from "./types.js";
 import { join } from "node:path";
 import { sanitizeProjectKey } from "./project.js";
 import { stateFilePath } from "./state.js";
@@ -26,8 +27,7 @@ export const EVOLVE_DIR = "evolve";
  * full past. Tunable via the `historyRetain` plugin config.
  */
 export const DEFAULT_SNAPSHOT_RETAIN = 20;
-export const DEFAULT_REFINEMENTS_RETAIN = 500;
-export const DEFAULT_REVIEWS_RETAIN = 500;
+export { DEFAULT_REFINEMENTS_RETAIN, DEFAULT_REVIEWS_RETAIN } from "./types.js";
 export const DEFAULT_TOKEN_USAGE_RETAIN = 500;
 /** Defaults applied for absent / non-positive retention fields (fail loud never: clamp, don't throw). */
 export function resolveHistoryRetention(raw) {

package/lib/tool.d.ts

@@ -4,6 +4,7 @@
  * the engine. `global: true` is required explicitly for cross-session edits.
  */
 import type { Context } from "@deepseek-ai/cordis";
+import type { RecordLanguagePreference } from "./record-language.js";
 import type { HarnessScope } from "./types.js";
 import type { EvolutionEngine } from "./service.js";
 /**
@@ -22,6 +23,12 @@ export declare function scopeOf(value: unknown, fallback: HarnessScope): Harness
 export declare function collectDeleteIds(id: unknown, ids: unknown): string[];
 export interface ToolGateOptions {
     requireGlobalApproval: boolean;
+    /**
+     * Plugin `recordLanguage` preference for the approval dialog copy;
+     * `auto`/absent defers to the durable client preference and the session's
+     * own user text (see `approval.ts`).
+     */
+    recordLanguage?: RecordLanguagePreference;
 }
 export declare function registerEvolveTools(ctx: Context, engine: EvolutionEngine, opts: ToolGateOptions): void;
 //# sourceMappingURL=tool.d.ts.map

package/lib/tool.js

@@ -8,7 +8,7 @@ import { entrySourceOf } from "./source.js";
 import { formatRecallResult, recallMemories } from "./recall.js";
 import { getUsageCount, loadUsage } from "./usage.js";
 import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
-import { DEFAULT_REVIEWS_RETAIN } from "./store.js";
+import { DEFAULT_REVIEWS_RETAIN } from "./types.js";
 const SCOPES = ["local", "project", "global"];
 /**
  * Accept the string form (`scope: "project"`) with the legacy boolean tool
@@ -186,7 +186,7 @@ export function registerEvolveTools(ctx, engine, opts) {
                 const targetState = engine.load(scope, storeId);
                 const hit = mostSimilarEntry(Object.values(targetState.entries[args.kind]), args.title ?? "", args.content ?? "", CONFLICT_WARN_SCORE);
                 const conflictNote = hit ? ` ⚠️ ${buildConflictNotice(hit)}——建议改用 evolve_update` : "";
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → ${storeLabel(scope)}${conflictNote}`);
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_add ${args.kind} "${args.title}" → ${storeLabel(scope)}${conflictNote}`, opts.recordLanguage);
             }
             const edit = {
                 action: "create",
@@ -228,7 +228,7 @@ export function registerEvolveTools(ctx, engine, opts) {
             const scope = scopeOf(args.scope ?? args.global, "local");
             const storeId = storeIdFor(scope, exec);
             if (needsApproval(scope) && opts.requireGlobalApproval) {
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_update ${args.kind}:${args.id} → ${storeLabel(scope)}`);
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_update ${args.kind}:${args.id} → ${storeLabel(scope)}`, opts.recordLanguage);
             }
             const edit = { action: "update", kind: args.kind, id: args.id };
             if (args.title !== undefined)
@@ -263,7 +263,7 @@ export function registerEvolveTools(ctx, engine, opts) {
             const storeId = storeIdFor(scope, exec);
             const ids = collectDeleteIds(args.id, args.ids);
             if (needsApproval(scope) && opts.requireGlobalApproval) {
-                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_delete ${args.kind}:${ids.length > 1 ? `${ids.length} entries (${ids.join(", ")})` : ids[0]} → ${storeLabel(scope)}`);
+                await requireGlobalApproval(ctx, exec.agent, exec.signal, `evolve_delete ${args.kind}:${ids.length > 1 ? `${ids.length} entries (${ids.join(", ")})` : ids[0]} → ${storeLabel(scope)}`, opts.recordLanguage);
             }
             const edits = ids.map((id) => ({ action: "delete", kind: args.kind, id }));
             return textResult(applyEditsText(engine, scope, storeId, edits, exec.agent, sessionIdOf(exec)));

package/lib/turn-snapshot.d.ts

@@ -9,7 +9,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 /** Why a scheduler snapshot was captured. */
-export type TurnSnapshotReason = "turn_snapshot" | "compact";
+export type TurnSnapshotReason = "compact" | "session_close" | "goal_blocked";
 /** Mechanical reasons a snapshot can be skipped without an LLM call. */
 export type SnapshotSkipReason = "no-new-events" | "internal-agent" | "direct-memory-write" | "no-user-prose";
 /** One immutable scheduler input. The cursor is a durable event boundary. */
@@ -69,4 +69,10 @@ export declare function containsDirectMemoryWrite(events: readonly unknown[]): b
 export declare function serializeSnapshotEvents(events: readonly unknown[], maxChars: number): string;
 /** A DSH subagent header is an internal source when its origin says so. */
 export declare function isInternalAgent(agent: Agent | undefined): boolean;
+/**
+ * Durable-boundary ordering shared by the scheduler and the extraction
+ * phase: returns a positive number when `left` is newer than `right`,
+ * negative when older, and undefined when the two shapes are incomparable.
+ */
+export declare function compareReviewCursors(left: string, right: string): number | undefined;
 //# sourceMappingURL=turn-snapshot.d.ts.map

package/lib/turn-snapshot.js

@@ -235,4 +235,18 @@ function readNestedString(value, keys) {
     }
     return undefined;
 }
+/**
+ * Durable-boundary ordering shared by the scheduler and the extraction
+ * phase: returns a positive number when `left` is newer than `right`,
+ * negative when older, and undefined when the two shapes are incomparable.
+ */
+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]);
+}
 //# sourceMappingURL=turn-snapshot.js.map

package/lib/types.d.ts

@@ -205,4 +205,14 @@ export declare function slug(raw: string, fallback: string): string;
 export declare function emptyHarnessState(): HarnessState;
 /** Deep clone helper (state is plain JSON data). */
 export declare function cloneEntry(entry: HarnessEntry | undefined): HarnessEntry | undefined;
+/**
+ * Storage-hygiene defaults (#20): JSONL tail lines kept per store history
+ * and per shared audit trail when no explicit `historyRetain` is set.
+ */
+export declare const DEFAULT_REFINEMENTS_RETAIN = 500;
+export declare const DEFAULT_REVIEWS_RETAIN = 500;
+/** Prefix-cache routing modes for extractor/planner inputs (see prefix-cache.ts). */
+export type PlannerPrefixCacheMode = "auto" | "session" | "off";
+/** The only two durable outcomes a scope-approval dialog may produce. */
+export type ScopeApprovalDecision = "approved" | "declined";
 //# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -124,4 +124,10 @@ export function emptyHarnessState() {
 export function cloneEntry(entry) {
     return entry ? JSON.parse(JSON.stringify(entry)) : undefined;
 }
+/**
+ * Storage-hygiene defaults (#20): JSONL tail lines kept per store history
+ * and per shared audit trail when no explicit `historyRetain` is set.
+ */
+export const DEFAULT_REFINEMENTS_RETAIN = 500;
+export const DEFAULT_REVIEWS_RETAIN = 500;
 //# sourceMappingURL=types.js.map

package/lib/wrapup-candidates.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Wrap-up candidate domain: the mechanical audit of a session's local
+ * entries (candidates, global coverage detection, usage hints), the LLM
+ * assessment parser, and the shared wrap-up types. Pure logic — the LLM
+ * call lives in `wrapup.ts`, the proposal builders in
+ * `wrapup-proposals.ts`.
+ */
+import type { HarnessEntry, HarnessState, RefinementKind } from "./types.js";
+export type WrapupVerdict = "promote" | "archive" | "keep";
+/** A classified local entry: `key` matches one audited candidate exactly. */
+export interface WrapupItem {
+    /** `kind:id` of the candidate this verdict refers to. */
+    key: string;
+    verdict: WrapupVerdict;
+    reason: string;
+    /**
+     * Optional split-promotion payload (verdict "archive" only): the entry is
+     * archived as a whole, but a CLEANED cross-session-reusable part is
+     * offered for promotion — the durable fact distilled out of the mixed
+     * entry, with the ephemeral snapshot left behind in the archive.
+     */
+    promote?: {
+        title: string;
+        content: string;
+    };
+    /**
+     * Valence signal (P1 效价反馈): the assessor found trajectory or global
+     * evidence contradicting this entry's content (user correction, overridden
+     * fact). Strictly parsed — only an explicit JSON `true` sets it. Keep
+     * verdicts with this flag get a negative-valence stamp; the assessor is
+     * instructed to prefer "archive" for contradicted entries.
+     */
+    contradicted?: boolean;
+}
+/** A real global entry worth showing the assessor for the same topic. */
+export interface GlobalHint {
+    id: string;
+    title: string;
+}
+/** The model's full classification of a session's local entries. */
+export interface WrapupAssessment {
+    items: WrapupItem[];
+    rationale: string;
+}
+/** A local entry offered for assessment, plus its deterministic audit flags. */
+export interface WrapupCandidate {
+    kind: RefinementKind;
+    id: string;
+    title: string;
+    content: string;
+    path: string;
+    version: number;
+    metadata: Record<string, unknown>;
+    /**
+     * True when the global store already covers this topic by a STRONG
+     * signal: a title that normalizes equal to, or (beyond a length floor)
+     * contains, the candidate's title. Collisions on id alone with a wildly
+     * different title are deliberately NOT coverage — see {@link globalHintsFor}.
+     */
+    coveredGlobally: boolean;
+    /**
+     * Actual global entries that touch the same topic (same id, equal
+     * normalized title, or title overlap). Shown to the assessor so it judges
+     * against real titles instead of a bare boolean; a bare same-id collision
+     * shows up here precisely so the model can tell whether the global copy
+     * really covers the local content.
+     */
+    globalHints: GlobalHint[];
+    /**
+     * Injection usage count (gap B1): how many times this entry was included
+     * in a system-prompt assembly. Zero means the entry was never used — a
+     * strong staleness signal the assessor can weigh.
+     */
+    injectionCount: number;
+    /**
+     * Staleness flag (gap B2): true when the entry has both zero injection
+     * usage AND a recency score below the staleness threshold (old + unused).
+     * The assessor is instructed to prefer "archive" for stale entries.
+     */
+    stale: boolean;
+    /**
+     * Negative-valence counter (P1 效价反馈): how many prior assessments marked
+     * this entry contradicted (metadata {@link VALENCE_NEGATIVE_KEY}). Shown to
+     * the assessor so it can prefer "archive"; also demotes the entry in
+     * injection ranking (inject.ts rankEntries).
+     */
+    negativeCount: number;
+}
+export declare function candidateKey(kind: RefinementKind, id: string): string;
+/**
+ * Deterministic global-coverage check (STRONG signal): the global store
+ * already covers a topic when it holds a title that normalizes equal to, or
+ * (beyond a length floor) contains, the candidate's normalized title.
+ * Archived global entries count too — the topic was already judged
+ * cross-session; a local duplicate would only re-sediment it.
+ *
+ * The bare same-id case is deliberately NOT coverage: ids are slugs derived
+ * from titles, so a real collision is usually caught by the title check
+ * below. A same-id entry with a wildly different title is a weak signal — the
+ * caller routes it through {@link globalHintsFor} for the assessor to judge
+ * against the actual global title (real case: local `memory` "用户产品愿景与
+ * 收入需求（本会话）" vs global `memory` "用户画像（持续更新）").
+ */
+export declare function globalCoverageDetected(globalState: HarnessState, kind: RefinementKind, entry: Pick<HarnessEntry, "id" | "title">): boolean;
+/**
+ * The actual global entries that touch the same topic as a local candidate:
+ * same id (regardless of title — the weak collision signal that is NOT
+ * coverage on its own), equal normalized title, or title overlap. The raw ids
+ * and titles let the assessor judge enrichment against real global content
+ * (does the global copy already hold what the local one adds?) rather than a
+ * bare boolean. Bounded: a handful of best matches, never the whole store.
+ */
+export declare function globalHintsFor(globalState: HarnessState, kind: RefinementKind, entry: Pick<HarnessEntry, "id" | "title">): GlobalHint[];
+export declare function listLocalCandidates(state: HarnessState, globalState: HarnessState, baseDir?: string): WrapupCandidate[];
+/**
+ * Parse and validate the model's assessment JSON. Defense is mechanical:
+ * keys outside the candidate list are dropped, verdicts outside the enum
+ * collapse to "keep", and candidates the model omitted default to "keep" —
+ * a malformed reply can never change an entry's fate by itself.
+ *
+ * Split promotion (verdict "archive" with a `promote` sub-object): the
+ * sub-object is accepted ONLY on archive verdicts and ONLY when both cleaned
+ * title and content are non-empty strings — a dropped/malformed sub-object
+ * silently degrades to a plain archive (the entry is never half-promoted).
+ */
+export declare function parseWrapupAssessment(text: string, candidates: readonly WrapupCandidate[]): WrapupAssessment;
+//# sourceMappingURL=wrapup-candidates.d.ts.map

package/lib/wrapup-candidates.js

@@ -0,0 +1,161 @@
+import { PROMOTED_TO_KEY, VALENCE_NEGATIVE_KEY, isArchived } from "./types.js";
+import { extractJsonObject } from "./plan.js";
+import { getUsageCount, loadUsage } from "./usage.js";
+import { recencyScore } from "./injection-rank.js";
+export function candidateKey(kind, id) {
+    return `${kind}:${id}`;
+}
+/** Lowercase, punctuation-stripped title used for cheap coverage matching. */
+function normalizeKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9\u3400-\u9fff]+/g, "").trim();
+}
+/**
+ * Deterministic global-coverage check (STRONG signal): the global store
+ * already covers a topic when it holds a title that normalizes equal to, or
+ * (beyond a length floor) contains, the candidate's normalized title.
+ * Archived global entries count too — the topic was already judged
+ * cross-session; a local duplicate would only re-sediment it.
+ *
+ * The bare same-id case is deliberately NOT coverage: ids are slugs derived
+ * from titles, so a real collision is usually caught by the title check
+ * below. A same-id entry with a wildly different title is a weak signal — the
+ * caller routes it through {@link globalHintsFor} for the assessor to judge
+ * against the actual global title (real case: local `memory` "用户产品愿景与
+ * 收入需求（本会话）" vs global `memory` "用户画像（持续更新）").
+ */
+export function globalCoverageDetected(globalState, kind, entry) {
+    const records = globalState.entries[kind];
+    const title = normalizeKey(entry.title);
+    if (title.length === 0)
+        return false;
+    for (const other of Object.values(records)) {
+        const otherTitle = normalizeKey(other.title);
+        if (otherTitle.length === 0)
+            continue;
+        if (otherTitle === title)
+            return true;
+        if (title.length >= 4 && otherTitle.length >= 4 && (title.includes(otherTitle) || otherTitle.includes(title))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The actual global entries that touch the same topic as a local candidate:
+ * same id (regardless of title — the weak collision signal that is NOT
+ * coverage on its own), equal normalized title, or title overlap. The raw ids
+ * and titles let the assessor judge enrichment against real global content
+ * (does the global copy already hold what the local one adds?) rather than a
+ * bare boolean. Bounded: a handful of best matches, never the whole store.
+ */
+export function globalHintsFor(globalState, kind, entry) {
+    const records = globalState.entries[kind];
+    const title = normalizeKey(entry.title);
+    const hints = [];
+    for (const other of Object.values(records)) {
+        const otherTitle = normalizeKey(other.title);
+        if (otherTitle.length === 0 && other.id !== entry.id)
+            continue;
+        const matches = other.id === entry.id ||
+            (otherTitle.length > 0 && (otherTitle === title || (title.length >= 4 && otherTitle.length >= 4 && (title.includes(otherTitle) || otherTitle.includes(title)))));
+        if (matches) {
+            hints.push({ id: other.id, title: other.title });
+        }
+    }
+    return hints;
+}
+/**
+ * The auditable local candidates of a session: every non-archived local
+ * entry that has not already been promoted (a promoted entry's lifecycle is
+ * finished — the global copy is the live one). Each carries its
+ * `coveredGlobally` flag so the assessor never wastes a promote on a topic
+ * the global store already owns.
+ */
+/** Staleness threshold: entries with recency below this AND zero usage are stale. */
+const STALE_RECENCY_THRESHOLD = 0.1;
+export function listLocalCandidates(state, globalState, baseDir) {
+    const usage = baseDir ? loadUsage(baseDir) : undefined;
+    const now = Date.now();
+    const candidates = [];
+    for (const kind of Object.keys(state.entries)) {
+        for (const entry of Object.values(state.entries[kind])) {
+            if (entry.scope !== "local")
+                continue;
+            if (isArchived(entry))
+                continue;
+            if (typeof entry.metadata[PROMOTED_TO_KEY] === "string")
+                continue;
+            const injectionCount = usage ? getUsageCount(usage, kind, entry.id) : 0;
+            const stale = injectionCount === 0 && recencyScore(entry, now) < STALE_RECENCY_THRESHOLD;
+            const rawNegative = entry.metadata[VALENCE_NEGATIVE_KEY];
+            const negativeCount = typeof rawNegative === "number" && Number.isFinite(rawNegative) && rawNegative > 0 ? rawNegative : 0;
+            candidates.push({
+                kind,
+                id: entry.id,
+                title: entry.title,
+                content: entry.content,
+                path: entry.path,
+                version: entry.version,
+                metadata: entry.metadata,
+                coveredGlobally: globalCoverageDetected(globalState, kind, entry),
+                globalHints: globalHintsFor(globalState, kind, entry),
+                injectionCount,
+                stale,
+                negativeCount,
+            });
+        }
+    }
+    return candidates;
+}
+/**
+ * Parse and validate the model's assessment JSON. Defense is mechanical:
+ * keys outside the candidate list are dropped, verdicts outside the enum
+ * collapse to "keep", and candidates the model omitted default to "keep" —
+ * a malformed reply can never change an entry's fate by itself.
+ *
+ * Split promotion (verdict "archive" with a `promote` sub-object): the
+ * sub-object is accepted ONLY on archive verdicts and ONLY when both cleaned
+ * title and content are non-empty strings — a dropped/malformed sub-object
+ * silently degrades to a plain archive (the entry is never half-promoted).
+ */
+export function parseWrapupAssessment(text, candidates) {
+    const value = extractJsonObject(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("wrap-up assessment JSON must be an object");
+    }
+    const record = value;
+    const allowed = new Set(candidates.map((candidate) => candidateKey(candidate.kind, candidate.id)));
+    const items = [];
+    if (Array.isArray(record["items"])) {
+        for (const raw of record["items"]) {
+            if (typeof raw !== "object" || raw === null)
+                continue;
+            const item = raw;
+            const key = typeof item["key"] === "string" ? item["key"] : "";
+            if (!allowed.has(key))
+                continue;
+            const verdict = item["verdict"] === "promote" || item["verdict"] === "archive" ? item["verdict"] : "keep";
+            const built = { key, verdict, reason: typeof item["reason"] === "string" ? item["reason"] : "" };
+            if (item["contradicted"] === true) {
+                built.contradicted = true;
+            }
+            if (verdict === "archive" && typeof item["promote"] === "object" && item["promote"] !== null) {
+                const sub = item["promote"];
+                const subTitle = typeof sub["title"] === "string" ? sub["title"].trim() : "";
+                const subContent = typeof sub["content"] === "string" ? sub["content"].trim() : "";
+                if (subTitle.length > 0 && subContent.length > 0) {
+                    built.promote = { title: subTitle, content: subContent };
+                }
+            }
+            items.push(built);
+        }
+    }
+    for (const candidate of candidates) {
+        const key = candidateKey(candidate.kind, candidate.id);
+        if (!items.some((item) => item.key === key)) {
+            items.push({ key, verdict: "keep", reason: "not mentioned by the assessor" });
+        }
+    }
+    return { items, rationale: typeof record["rationale"] === "string" ? record["rationale"] : "" };
+}
+//# sourceMappingURL=wrapup-candidates.js.map

package/lib/wrapup-command.d.ts

@@ -5,5 +5,6 @@ import type { Context } from "@deepseek-ai/cordis";
 import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
 import type { EvolutionEngine } from "./service.js";
 import { type PromotionPolicy } from "./promotion.js";
-export declare function executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, policy?: PromotionPolicy): Promise<CommandResult>;
+import { type RecordLanguagePreference } from "./record-language.js";
+export declare function executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, policy?: PromotionPolicy, recordLanguage?: RecordLanguagePreference): Promise<CommandResult>;
 //# sourceMappingURL=wrapup-command.d.ts.map

package/lib/wrapup-command.js

@@ -1,11 +1,13 @@
 import { questionServiceOf, requireGlobalApproval } from "./approval.js";
-import { resolveDialogLanguage, wrapupArchiveCopy } from "./copy.js";
+import { wrapupArchiveCopy } from "./copy.js";
 import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, valenceStampProposal, wholePromoteProposals } from "./wrapup.js";
 import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
+import { normalizeRecordLanguage, resolveRecordLanguage } from "./record-language.js";
+import { recentUserText } from "./inject.js";
 function success(text) {
     return { kind: "success", text };
 }
-export async function executeWrapupCommand(ctx, engine, invocation, policy = DEFAULT_PROMOTION_POLICY) {
+export async function executeWrapupCommand(ctx, engine, invocation, policy = DEFAULT_PROMOTION_POLICY, recordLanguage) {
     const sessionId = invocation.agent.id;
     const localState = engine.load("local", sessionId);
     const globalState = engine.load("global", undefined);
@@ -102,7 +104,7 @@ export async function executeWrapupCommand(ctx, engine, invocation, policy = DEF
         ].join("\n")}`;
         let promoteAllowed = true;
         try {
-            await requireGlobalApproval(ctx, invocation.agent, invocation.signal, what);
+            await requireGlobalApproval(ctx, invocation.agent, invocation.signal, what, recordLanguage);
         }
         catch (cause) {
             promoteAllowed = false;
@@ -187,7 +189,8 @@ export async function executeWrapupCommand(ctx, engine, invocation, policy = DEF
         const questionId = "evolve-wrapup-archive-review";
         let archiveConfirmed = false;
         try {
-            const copy = wrapupArchiveCopy(candidate.title, resolveDialogLanguage(ctx));
+            const copy = wrapupArchiveCopy(candidate.title, normalizeRecordLanguage(recordLanguage) ??
+                resolveRecordLanguage({ ctx, trajectoryText: recentUserText(invocation.agent) }));
             const answer = await userQuestions.ask({
                 questions: [
                     {