dsh-continual-evolve 0.10.4 → 0.10.6

package/lib/memory-index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * evolve v2 — the passive read path: the `evolve:memory-index` system-prompt
+ * section that puts memory CONTENT in front of the model at session start.
+ *
+ * Why not just hand out a path: the memory store lives in `<dshHome>/evolve/`,
+ * outside the workspace sandbox, so the model's read tool cannot open it.
+ * The section therefore carries the entries themselves — full body while the
+ * character budget allows, then one-line index rows, then a `evolve_recall`
+ * pointer for the rest. Budget is hard: a bounded prompt beats an unbounded one.
+ *
+ * Session-freeze contract (the prompt-cache guard): the section is computed
+ * once per session and reused byte-for-byte afterwards, so the system prompt
+ * stays stable within a session and cache reads keep hitting. A memory written
+ * mid-session becomes visible in the NEXT session; `evolve_recall` covers the
+ * immediate need. See `.agents/notes/proposed/feature/2026-10-01-evolve-v2-passive-read-write.md`.
+ */
+import type { HarnessEntry } from "./types.js";
+import { type MemoryRecallType } from "./types.js";
+import type { EvolutionEngine } from "./service.js";
+import { type AgentLike } from "./inject.js";
+/** Hard character budget for the `<memories>` block. */
+export declare const DEFAULT_MEMORY_INDEX_MAX_CHARS = 6000;
+/** Prompt-section order of the memory index (empty 1–499 slot, see ADR). */
+export declare const DEFAULT_MEMORY_SECTION_ORDER = 400;
+/** Sessions whose frozen section text is kept before LRU eviction. */
+export declare const DEFAULT_FROZEN_SESSIONS = 32;
+/** Name of the injected section (unique — duplicate names throw upstream). */
+export declare const MEMORY_SECTION_NAME = "evolve:memory-index";
+/**
+ * Recall-type priority for the budget: durable, behavior-shaping types first.
+ * `project` (current work context) > `feedback` (how to behave) > `user` (who
+ * the user is) > `reference` (external pointers). Entries without a valid
+ * memoryType sink below every typed entry.
+ */
+export declare const MEMORY_TYPE_PRIORITY: Record<MemoryRecallType, number>;
+/** The entry's recall type, or undefined when the metadata key is absent/invalid. */
+export declare function memoryTypeOf(entry: HarnessEntry): MemoryRecallType | undefined;
+/**
+ * Order memories for injection: recall-type priority first
+ * ({@link MEMORY_TYPE_PRIORITY}), then recency (newest first), then the stable
+ * dictionary order — deterministic for equal inputs, so a frozen section is
+ * reproducible across builds. The input is never mutated.
+ */
+export declare function rankMemories(entries: readonly HarnessEntry[], now?: number): HarnessEntry[];
+/** One memory rendered in full, as a list item with the body indented. */
+export declare function memoryFullLine(entry: HarnessEntry): string;
+/** What a budget-bounded memory block shows. */
+export interface MemorySelection {
+    /** Entries rendered with their full body, in display order. */
+    full: HarnessEntry[];
+    /** Entries degraded to a one-line index row (`id` + title hook). */
+    indexed: HarnessEntry[];
+    /** Entries that fit neither and are only counted. */
+    dropped: number;
+    /** Entries actually shown (full + indexed), in display order. */
+    shown: HarnessEntry[];
+}
+/**
+ * Greedy budget fill over {@link rankMemories}: each entry takes the full body
+ * while it fits, otherwise degrades to an index row, otherwise is dropped —
+ * and because the ranking is fixed, the first entry that fits neither means
+ * every later one is dropped too (their rows are no smaller).
+ */
+export declare function selectMemoryInjection(entries: readonly HarnessEntry[], maxChars?: number): MemorySelection;
+/** The `evolve_recall` pointer appended when rows had to be degraded or dropped. */
+export declare const MEMORY_OVERFLOW_HINT = "- \u66F4\u591A\u8BB0\u5FC6\u53EF\u7528 evolve_recall \u6309\u9700\u8BFB\u53D6";
+/**
+ * Render a selection as the `<memories>` block, or "" when nothing is shown.
+ * Full bodies come first in display order, then the degraded index rows, then
+ * the `evolve_recall` pointer with the degradation/drop counts.
+ */
+export declare function renderMemorySelection(selection: MemorySelection): string;
+/** {@link renderMemorySelection} over a fresh selection (convenience). */
+export declare function formatMemoriesBlock(entries: readonly HarnessEntry[], maxChars?: number): string;
+/** Options for {@link memoryIndexSectionText}. */
+export interface MemoryIndexOptions {
+    /** Hard budget for the memories block (default 6000). */
+    maxChars?: number;
+    /** Include the when_to_save guide (default true). */
+    guide?: boolean;
+    /** Pin the project layer explicitly (tests/tools); otherwise derived from cwd. */
+    projectKey?: string;
+}
+/**
+ * Compose the full `evolve:memory-index` section for one assembling agent:
+ * the persistent-memory guide (when to save / how to maintain) wrapped around
+ * the budget-bounded memories block. With the guide off and no memories the
+ * result is "" — the prompt renderer then drops the section, so an empty store
+ * keeps costing zero tokens.
+ *
+ * Injection usage is recorded for everything shown (best-effort; a failure
+ * never blocks injection), deduped per session by {@link recordInjection}.
+ */
+export declare function memoryIndexSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, opts?: MemoryIndexOptions): string;
+/** A per-session frozen view of the memory section text. */
+export interface FrozenMemorySection {
+    /**
+     * The section text for this agent: built on first use per `agent.id` and
+     * reused byte-for-byte afterwards. `undefined` agent → "" (unbuilt).
+     */
+    textFor(agent: AgentLike | undefined, build: (agent: AgentLike) => string): string;
+    /** Sessions currently frozen (test/observability hook). */
+    size(): number;
+    /** Drop every frozen session (tests; a restart rebuilds naturally). */
+    clear(): void;
+}
+/**
+ * Freeze the section text per session id. The frozen value is what keeps the
+ * system prompt stable across a session's assemblies (prompt-cache guard);
+ * bounded by `maxSessions` with insertion-order (LRU) eviction, so a long-lived
+ * process cannot grow without limit.
+ */
+export declare function createFrozenMemorySection(maxSessions?: number): FrozenMemorySection;
+//# sourceMappingURL=memory-index.d.ts.map

package/lib/memory-index.js

@@ -0,0 +1,197 @@
+import { MEMORY_TYPE_KEY, isArchived, isMemoryType } from "./types.js";
+import { recordInjection } from "./usage.js";
+import { MEMORY_GUIDE_INTRO, MEMORY_GUIDE_RULES } from "./memory-guide.js";
+import { directoryLine, mergedInjectionState, recencyScore } from "./inject.js";
+/** Hard character budget for the `<memories>` block. */
+export const DEFAULT_MEMORY_INDEX_MAX_CHARS = 6000;
+/** Prompt-section order of the memory index (empty 1–499 slot, see ADR). */
+export const DEFAULT_MEMORY_SECTION_ORDER = 400;
+/** Sessions whose frozen section text is kept before LRU eviction. */
+export const DEFAULT_FROZEN_SESSIONS = 32;
+/** Name of the injected section (unique — duplicate names throw upstream). */
+export const MEMORY_SECTION_NAME = "evolve:memory-index";
+/**
+ * Recall-type priority for the budget: durable, behavior-shaping types first.
+ * `project` (current work context) > `feedback` (how to behave) > `user` (who
+ * the user is) > `reference` (external pointers). Entries without a valid
+ * memoryType sink below every typed entry.
+ */
+export const MEMORY_TYPE_PRIORITY = {
+    project: 0,
+    feedback: 1,
+    user: 2,
+    reference: 3,
+};
+/** Priority of an entry whose metadata carries no valid recall type. */
+const UNTYPED_PRIORITY = 4;
+/** The entry's recall type, or undefined when the metadata key is absent/invalid. */
+export function memoryTypeOf(entry) {
+    const value = entry.metadata[MEMORY_TYPE_KEY];
+    return isMemoryType(value) ? value : undefined;
+}
+/** Deterministic final tiebreak (matches `inject.ts` ranking). */
+function stableCompare(a, b) {
+    return [a.path, a.title, a.id].join("\0").localeCompare([b.path, b.title, b.id].join("\0"));
+}
+/**
+ * Order memories for injection: recall-type priority first
+ * ({@link MEMORY_TYPE_PRIORITY}), then recency (newest first), then the stable
+ * dictionary order — deterministic for equal inputs, so a frozen section is
+ * reproducible across builds. The input is never mutated.
+ */
+export function rankMemories(entries, now = Date.now()) {
+    return [...entries].sort((a, b) => {
+        const aType = memoryTypeOf(a);
+        const bType = memoryTypeOf(b);
+        const priorityDelta = (aType ? MEMORY_TYPE_PRIORITY[aType] : UNTYPED_PRIORITY) - (bType ? MEMORY_TYPE_PRIORITY[bType] : UNTYPED_PRIORITY);
+        if (priorityDelta !== 0) {
+            return priorityDelta;
+        }
+        const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
+        if (recencyDelta !== 0) {
+            return recencyDelta;
+        }
+        return stableCompare(a, b);
+    });
+}
+/** One memory rendered in full, as a list item with the body indented. */
+export function memoryFullLine(entry) {
+    const type = memoryTypeOf(entry);
+    const body = entry.content.trim().replace(/\n/g, "\n  ");
+    const head = `- [memory${type ? `:${type}` : ""}:${entry.id}] ${entry.title}`;
+    return body.length > 0 ? `${head}\n  ${body}` : head;
+}
+/**
+ * Greedy budget fill over {@link rankMemories}: each entry takes the full body
+ * while it fits, otherwise degrades to an index row, otherwise is dropped —
+ * and because the ranking is fixed, the first entry that fits neither means
+ * every later one is dropped too (their rows are no smaller).
+ */
+export function selectMemoryInjection(entries, maxChars = DEFAULT_MEMORY_INDEX_MAX_CHARS) {
+    const visible = entries.filter((entry) => !isArchived(entry));
+    const ranked = rankMemories(visible);
+    const budget = Math.max(0, maxChars);
+    const full = [];
+    const indexed = [];
+    const shown = [];
+    let used = 0;
+    let dropped = 0;
+    for (const entry of ranked) {
+        const fullLine = memoryFullLine(entry);
+        if (used + fullLine.length <= budget) {
+            full.push(entry);
+            shown.push(entry);
+            used += fullLine.length;
+            continue;
+        }
+        const indexLine = directoryLine(entry);
+        if (used + indexLine.length <= budget) {
+            indexed.push(entry);
+            shown.push(entry);
+            used += indexLine.length;
+            continue;
+        }
+        dropped = ranked.length - shown.length;
+        break;
+    }
+    return { full, indexed, dropped, shown };
+}
+/** The `evolve_recall` pointer appended when rows had to be degraded or dropped. */
+export const MEMORY_OVERFLOW_HINT = "- 更多记忆可用 evolve_recall 按需读取";
+/**
+ * Render a selection as the `<memories>` block, or "" when nothing is shown.
+ * Full bodies come first in display order, then the degraded index rows, then
+ * the `evolve_recall` pointer with the degradation/drop counts.
+ */
+export function renderMemorySelection(selection) {
+    const { full, indexed, dropped, shown } = selection;
+    if (shown.length === 0) {
+        return "";
+    }
+    const lines = [];
+    for (const entry of full) {
+        lines.push(memoryFullLine(entry));
+    }
+    for (const entry of indexed) {
+        lines.push(directoryLine(entry));
+    }
+    const omitted = [];
+    if (indexed.length > 0) {
+        omitted.push(`${indexed.length} 条仅列索引`);
+    }
+    if (dropped > 0) {
+        omitted.push(`${dropped} 条未列出`);
+    }
+    lines.push(omitted.length > 0 ? `${MEMORY_OVERFLOW_HINT}（${omitted.join("，")}）` : MEMORY_OVERFLOW_HINT);
+    return `<memories>\n${lines.join("\n")}\n</memories>`;
+}
+/** {@link renderMemorySelection} over a fresh selection (convenience). */
+export function formatMemoriesBlock(entries, maxChars = DEFAULT_MEMORY_INDEX_MAX_CHARS) {
+    return renderMemorySelection(selectMemoryInjection(entries, maxChars));
+}
+/**
+ * Compose the full `evolve:memory-index` section for one assembling agent:
+ * the persistent-memory guide (when to save / how to maintain) wrapped around
+ * the budget-bounded memories block. With the guide off and no memories the
+ * result is "" — the prompt renderer then drops the section, so an empty store
+ * keeps costing zero tokens.
+ *
+ * Injection usage is recorded for everything shown (best-effort; a failure
+ * never blocks injection), deduped per session by {@link recordInjection}.
+ */
+export function memoryIndexSectionText(engine, agent, opts) {
+    if (!agent) {
+        return "";
+    }
+    const guide = opts?.guide ?? true;
+    const maxChars = opts?.maxChars ?? DEFAULT_MEMORY_INDEX_MAX_CHARS;
+    const merged = mergedInjectionState(engine, agent, opts);
+    const selection = selectMemoryInjection(Object.values(merged.entries.memory), maxChars);
+    const block = renderMemorySelection(selection);
+    if (selection.shown.length > 0) {
+        try {
+            recordInjection(engine.baseDir, selection.shown.map((entry) => `${entry.kind}:${entry.id}`), agent.id);
+        }
+        catch {
+            // Usage recording is diagnostic; never interrupt the injection path.
+        }
+    }
+    if (!guide) {
+        return block;
+    }
+    return [MEMORY_GUIDE_INTRO, block.length > 0 ? block : "<memories>\n（暂无记忆）\n</memories>", MEMORY_GUIDE_RULES].join("\n\n");
+}
+/**
+ * Freeze the section text per session id. The frozen value is what keeps the
+ * system prompt stable across a session's assemblies (prompt-cache guard);
+ * bounded by `maxSessions` with insertion-order (LRU) eviction, so a long-lived
+ * process cannot grow without limit.
+ */
+export function createFrozenMemorySection(maxSessions = DEFAULT_FROZEN_SESSIONS) {
+    const limit = Math.max(1, maxSessions);
+    const frozen = new Map();
+    return {
+        textFor(agent, build) {
+            if (!agent) {
+                return "";
+            }
+            const cached = frozen.get(agent.id);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const text = build(agent);
+            frozen.set(agent.id, text);
+            while (frozen.size > limit) {
+                const oldest = frozen.keys().next();
+                if (oldest.done === true) {
+                    break;
+                }
+                frozen.delete(oldest.value);
+            }
+            return text;
+        },
+        size: () => frozen.size,
+        clear: () => frozen.clear(),
+    };
+}
+//# sourceMappingURL=memory-index.js.map

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

@@ -83,12 +83,12 @@ function textResult(text) {
 export function registerEvolveTools(ctx, engine, opts) {
     ctx.tools.register(defineTool({
         name: "evolve_list",
-        description: "List the continual harness state (prompt notes, memories, skills, subagent specs) for the current session (local), the current project (project), or across projects (global).",
+        description: "List the harness state (prompt notes, memories, skills, subagent specs) for one store.",
         parameters: {
             scope: {
                 type: "string",
                 enum: SCOPES,
-                description: "Which store to list: 'local' (default), 'project', or 'global'.",
+                description: "'local' (default), 'project', or 'global'.",
             },
         },
         output: {
@@ -118,25 +118,25 @@ export function registerEvolveTools(ctx, engine, opts) {
     }));
     ctx.tools.register(defineTool({
         name: "evolve_recall",
-        description: "Targeted recall over the harness stores: filter memories (or other kinds) by query, kind, scope, and memory type, and read back full content with version, source, and staleness signals. Read-only — it never mutates a store. Prefer this over evolve_list when looking for something specific.",
+        description: "Read-only targeted recall across the harness stores: filter by query, kind, scope, and memory type; returns full content with version, source, and staleness signals. Prefer this over evolve_list when looking for something specific.",
         parameters: {
-            query: { type: "string", description: "Free-text relevance query. Empty means most-recently-updated first." },
+            query: { type: "string", description: "Free-text relevance query. Empty → most-recently-updated first." },
             kinds: {
                 type: "array",
                 items: { type: "string" },
-                description: "Entry kinds to search (default memory only).",
+                description: "Entry kinds (default memory only).",
             },
             scopes: {
                 type: "array",
                 items: { type: "string" },
-                description: "Stores to search (default local, project, and global).",
+                description: "Stores to search (default all three).",
             },
             memoryTypes: {
                 type: "array",
                 items: { type: "string" },
-                description: "Memory-type filter: user, feedback, project, reference (memory entries only).",
+                description: "Memory types: user, feedback, project, reference.",
             },
-            limit: { type: "number", description: "Maximum hits (default 10, at most 50)." },
+            limit: { type: "number", description: "Max hits (default 10, max 50)." },
             includeArchived: { type: "boolean", description: "Include archived entries (default false)." },
         },
         output: {
@@ -157,18 +157,18 @@ export function registerEvolveTools(ctx, engine, opts) {
     }));
     ctx.tools.register(defineTool({
         name: "evolve_add",
-        description: "Create one harness entry (prompt/memory/skill/subagent). Executable skills require reference {type:python, import, callable} and an arguments contract; guidance skills (skill_kind=guidance) are SKILL.md documents — recurring multi-step workflows — and must NOT carry a reference. Snapshot, version, and history are handled automatically.",
+        description: "Create one harness entry (prompt/memory/skill/subagent). Snapshots, versioning, and audit are automatic.",
         parameters: {
             kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true, description: "Entry kind." },
             title: { type: "string", required: true, description: "Stable title." },
             content: { type: "string", required: true, description: "Entry body." },
             path: { type: "string", description: "Optional grouping path." },
-            skill_kind: { type: "string", enum: ["executable", "guidance"], description: "For skills: executable (python reference, default) or guidance (SKILL.md document, no reference)." },
-            reference: { type: "object", additionalProperties: true, description: "For executable skills: {type:'python', import, callable}." },
-            arguments: { type: "object", additionalProperties: true, description: "For executable skills: accepted input contract." },
-            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Required for memory: one fact per entry (feedback/project must carry Why + How to apply)." },
-            scope: { type: "string", enum: SCOPES, description: "Target store: 'local' (default), 'project', or 'global'. Wins over the legacy global flag." },
-            global: { type: "boolean", description: "Set true to write the cross-session store (requires human approval; only for durable, reusable lessons)." },
+            skill_kind: { type: "string", enum: ["executable", "guidance"], description: "Skills: executable (default, needs reference) or guidance (SKILL.md, no reference)." },
+            reference: { type: "object", additionalProperties: true, description: "Executable skills: {type:'python', import, callable}." },
+            arguments: { type: "object", additionalProperties: true, description: "Executable skills: accepted input contract." },
+            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Required for memory (feedback/project need Why + How to apply)." },
+            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
+            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
         },
         output: {
             schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
@@ -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",
@@ -216,9 +216,9 @@ export function registerEvolveTools(ctx, engine, opts) {
             id: { type: "string", required: true, description: "Existing entry id." },
             title: { type: "string" },
             content: { type: "string" },
-            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "For memory: (re)classify the entry's recall type." },
-            scope: { type: "string", enum: SCOPES, description: "Target store: 'local' (default), 'project', or 'global'. Wins over the legacy global flag." },
-            global: { type: "boolean", description: "Set true to edit the cross-session store (requires human approval)." },
+            memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Memory: (re)classify the recall type." },
+            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
+            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
         },
         output: {
             schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
@@ -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)
@@ -242,17 +242,17 @@ export function registerEvolveTools(ctx, engine, opts) {
     }));
     ctx.tools.register(defineTool({
         name: "evolve_delete",
-        description: "Delete harness entries by id. Pass `id` for one entry or `ids` for several — a batch lands as one refinement behind one approval. Literal ids win: entries whose stored id itself carries a scope-like prefix (e.g. a legacy `local:…` id) are addressed verbatim.",
+        description: "Delete harness entries: `id` for one, `ids` for a batch (one refinement, one approval). Ids are addressed verbatim, scope-prefixed or not.",
         parameters: {
             kind: { type: "string", enum: ["prompt", "memory", "skill", "subagent"], required: true },
-            id: { type: "string", description: "Existing entry id (single delete; combine with ids or use ids for a batch)." },
+            id: { type: "string", description: "One entry id (or use ids for a batch)." },
             ids: {
                 type: "array",
                 items: { type: "string" },
-                description: "Existing entry ids for one batch delete (one refinement, one approval).",
+                description: "Entry ids for one batch delete.",
             },
-            scope: { type: "string", enum: SCOPES, description: "Target store: 'local' (default), 'project', or 'global'. Wins over the legacy global flag." },
-            global: { type: "boolean", description: "Set true to edit the cross-session store (requires human approval)." },
+            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
+            global: { type: "boolean", description: "Shorthand for scope='global' (requires human approval)." },
         },
         output: {
             schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },
@@ -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)));
@@ -271,11 +271,11 @@ export function registerEvolveTools(ctx, engine, opts) {
     }));
     ctx.tools.register(defineTool({
         name: "evolve_rollback",
-        description: "Deterministically revert a previous refinement by its id (from evolve_list history or the /evolve command).",
+        description: "Deterministically revert a previous refinement by its id (from evolve_list history or /evolve).",
         parameters: {
-            refinementId: { type: "string", required: true, description: "The refinement id to roll back." },
-            scope: { type: "string", enum: SCOPES, description: "Target store: 'local' (default), 'project', or 'global'. Wins over the legacy global flag." },
-            global: { type: "boolean", description: "Set true to roll back a cross-session refinement." },
+            refinementId: { type: "string", required: true, description: "Refinement id to roll back." },
+            scope: { type: "string", enum: SCOPES, description: "'local' (default), 'project', or 'global'." },
+            global: { type: "boolean", description: "Shorthand for scope='global'." },
         },
         output: {
             schema: { type: "object", additionalProperties: false, properties: { text: { type: "string", required: true } } },

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: [
                     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "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": {
@@ -56,6 +56,7 @@
     "lint": "oxlint src test",
     "clean": "rm -rf lib",
     "check:docs": "tsx scripts/run-gates.ts docs",
+    "check:handoff": "tsx scripts/verify-handoff-structure.ts --self-test && tsx scripts/verify-handoff-structure.ts",
     "check:governance": "tsx scripts/verify-governance.ts"
   },
   "peerDependencies": {