dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/maintenance-commands.js

@@ -0,0 +1,136 @@
+/**
+ * `/evolve` maintenance and observability subcommands: global-store
+ * consolidation, failure aggregation, plugin log inspection, store
+ * export/import backup, and entry archive/unarchive.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { ARCHIVED_AT_KEY } from "./types.js";
+import { filterLogBySession, formatLogLine, pluginLogFilePath } from "./logfile.js";
+import { collectFailureSummary, formatFailureSummary } from "./failures.js";
+import { planConsolidation } from "./consolidate.js";
+import { loadUsage } from "./usage.js";
+import { findEntryById, parsePositiveInt, renderResult, stripAngleBrackets, storeIdForCommand, success, error, } from "./command-util.js";
+/** `/evolve archive|unarchive <id> [global|project]` — hide or restore an entry. */
+export async function executeArchiveCommand(_ctx, engine, invocation, sub, parsed, usage) {
+    const id = stripAngleBrackets(parsed.rest[0] ?? "");
+    if (!id) {
+        return error(`${sub} requires an entry id.\n${usage}`);
+    }
+    const state = engine.load(parsed.scope, storeIdForCommand(parsed.scope, invocation));
+    const found = findEntryById(state, id);
+    if (!found) {
+        return error(`entry ${id} not found in the ${parsed.scope} store`);
+    }
+    const [kind, entry] = found;
+    const metadata = { ...entry.metadata };
+    if (sub === "archive") {
+        metadata[ARCHIVED_AT_KEY] = new Date().toISOString();
+    }
+    else {
+        delete metadata[ARCHIVED_AT_KEY];
+    }
+    const archived = sub === "archive";
+    const result = engine.apply(parsed.scope, storeIdForCommand(parsed.scope, invocation), {
+        summary: `${archived ? "Archive" : "Unarchive"} entry ${kind}:${id}`,
+        rationale: "Human-invoked archive/unarchive via the /evolve command.",
+        expectedOutcome: `Entry ${archived ? "is hidden from injection (data kept, restorable)" : "is injected again"}.`,
+        edits: [{ action: "update", kind, id, title: entry.title, content: entry.content, metadata }],
+    }, { scope: parsed.scope });
+    return success(renderResult(result));
+}
+/** `/evolve consolidate [apply] [merge]` — deterministic global-store hygiene. */
+export function executeConsolidateCommand(engine, rest) {
+    // R3: deterministic global-store hygiene. Report by default; `apply`
+    // re-scans fresh state and lands the whole batch as ONE refinement
+    // (single snapshot + audit record, fully rollback-able). `merge`
+    // (P1 反膨胀) additionally merges conflict-pair content into the
+    // surviving original instead of only archiving.
+    const apply = rest[0] === "apply";
+    const merge = rest.includes("merge");
+    const state = engine.load("global", undefined);
+    const { candidates, edits } = planConsolidation(state, loadUsage(engine.baseDir), Date.now(), { mergeDuplicates: merge });
+    if (candidates.length === 0) {
+        return success("global store is already consolidated — no conflict-hinted or stale zero-use entries.");
+    }
+    const mergeCount = merge ? candidates.filter((candidate) => candidate.mergeInto).length : 0;
+    const report = candidates
+        .map((candidate, index) => {
+        const mergeNote = candidate.mergeInto && merge ? ` → 内容并入 ${candidate.mergeInto.id}` : "";
+        return `${index + 1}. [${candidate.kind}:${candidate.id}] ${candidate.title}${mergeNote}\n   ${candidate.reason}`;
+    })
+        .join("\n");
+    if (!apply) {
+        return success(`consolidation plan — ${candidates.length} archive candidate(s):\n${report}\n(run "/evolve consolidate apply" to archive all of them in one refinement; add "merge" to fold near-duplicate content into the survivors)`);
+    }
+    const result = engine.apply("global", undefined, {
+        summary: `Consolidate global store: archive ${candidates.length} entries${mergeCount > 0 ? `, merge ${mergeCount} into survivors` : ""}`,
+        rationale: "Human-invoked batch consolidation via /evolve consolidate apply.",
+        expectedOutcome: "Candidate entries are hidden from injection (data kept; restorable via /evolve unarchive). Merged survivors carry the near-duplicate content with a mergedFrom provenance stamp.",
+        edits,
+    }, { scope: "global" });
+    return success(`${report}\n\napplied:\n${renderResult(result)}`);
+}
+/** `/evolve failures` — failure-signature aggregation (D1 observation). */
+export function executeFailuresCommand(engine) {
+    const { summary, records } = collectFailureSummary(engine.baseDir);
+    const parts = formatFailureSummary(summary).split("\n");
+    const recent = records
+        .sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""))
+        .slice(0, 10)
+        .map((f) => `  [${f.timestamp ?? "(benchmark)"}] ${f.kind} · ${f.source}: ${f.message.slice(0, 140)}`);
+    if (recent.length > 0) {
+        parts.push("recent 10:");
+        parts.push(...recent);
+    }
+    return success(parts.join("\n"));
+}
+/** `/evolve log [tail N] [session <sessionId>]` — plugin file log inspection. */
+export function executeLogCommand(engine, rest, usage) {
+    let tail = 50;
+    let sessionFilter;
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i] ?? "";
+        if (token === "session") {
+            sessionFilter = stripAngleBrackets(rest[i + 1] ?? "");
+            if (!sessionFilter) {
+                return error(`log session requires a session id (e.g. /evolve log session session-abc123).\n${usage}`);
+            }
+            i += 1;
+        }
+        else {
+            tail = Math.min(Math.max(parsePositiveInt(token, "tail"), 1), 1000);
+        }
+    }
+    const path = pluginLogFilePath(engine.baseDir);
+    if (!existsSync(path)) {
+        return success(`(no plugin log yet — ${path} is created on the first log message)`);
+    }
+    const lines = readFileSync(path, "utf8").trimEnd().split("\n").filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        return success(`(empty plugin log: ${path})`);
+    }
+    const filtered = sessionFilter ? filterLogBySession(lines, sessionFilter) : lines;
+    const shown = filtered.slice(-tail);
+    const scopeNote = sessionFilter ? `, ${filtered.length} for session ${sessionFilter}` : "";
+    return success(`plugin log ${path} (${lines.length} lines${scopeNote}, showing last ${shown.length}):\n${shown.map(formatLogLine).join("\n")}`);
+}
+/** `/evolve export [global|project] <path>` — backup a store to a JSON file. */
+export function executeExportCommand(engine, invocation, parsed, usage) {
+    const path = parsed.rest[0];
+    if (!path) {
+        return error(`export requires an output path.\n${usage}`);
+    }
+    const payload = engine.exportStore(parsed.scope, storeIdForCommand(parsed.scope, invocation));
+    writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    return success(`exported ${parsed.scope} store (${Object.values(payload.entries).reduce((n, e) => n + Object.keys(e).length, 0)} entries, ${payload.history.length} refinements) to ${path}`);
+}
+/** `/evolve import [global|project] <path>` — restore a store from an export file. */
+export function executeImportCommand(engine, invocation, parsed, path) {
+    if (!path) {
+        return error(`import requires an input path.`);
+    }
+    const payload = JSON.parse(readFileSync(path, "utf8"));
+    const summary = engine.importStore(parsed.scope, storeIdForCommand(parsed.scope, invocation), payload);
+    return success(`imported ${parsed.scope} store from ${path} (${summary.entries} entries, ${summary.refinements} refinements)`);
+}
+//# sourceMappingURL=maintenance-commands.js.map

package/lib/memory-agent.d.ts

@@ -6,17 +6,18 @@
  * structured proposal tool, and never writes state itself. Every accepted edit
  * is handed to EvolutionEngine so scope approval, snapshots, versioning,
  * rollback, and audit remain mandatory.
+ *
+ * Split (2026-10-03 refactor): the manifest view lives in
+ * `memory-manifest.ts`, proposal application in `memory-apply.ts`.
  */
 import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
 import { type ToolSchema } from "@deepseek-ai/dsh-llm";
-import { type ScopeApprovalDecision } from "./approval.js";
 import { type LlmSessionId } from "./llm-text.js";
+import { type MemoryManifestEntry } from "./memory-manifest.js";
 import { type PrefixCacheOptions } from "./prefix-cache.js";
-import { type EvolutionEngine } from "./service.js";
 import { type TokenUsageTarget } from "./token-usage.js";
 import { type RecordLanguage } from "./record-language.js";
-import type { EntrySource, HarnessEntry, HarnessScope, HarnessState, RefinementEdit, RefinementProposal, RefinementResult } from "./types.js";
+import type { HarnessScope, HarnessState, RefinementEdit, RefinementProposal, RefinementResult } from "./types.js";
 /** ZCode parity: the extractor may inspect memory and propose at most five times. */
 export declare const MEMORY_AGENT_MAX_TURNS = 5;
 /** Bound one proposal so approval text and engine compensation stay reviewable. */
@@ -32,7 +33,6 @@ export declare const MEMORY_AGENT_SYSTEM_PROMPT_BUDGET_CHARS = 3000;
 export declare const MEMORY_AGENT_TOOL_NAMES: readonly ["memory_search", "memory_propose"];
 export type MemoryAgentToolName = (typeof MEMORY_AGENT_TOOL_NAMES)[number];
 /** One frozen memory entry visible to the extractor for the whole run. */
-export type MemoryManifestEntry = HarnessEntry;
 /** A memory-only edit with an explicit persistence target. */
 export type ScopedMemoryEdit = RefinementEdit & {
     kind: "memory";
@@ -63,17 +63,10 @@ export interface MemoryApplicationResult {
 export declare const MEMORY_AGENT_TOOL_SCHEMAS: readonly ToolSchema[];
 /** Instructions for the dedicated loop; model text is always untrusted. */
 export declare const MEMORY_AGENT_SYSTEM_PROMPT = "You are the dedicated background memory extraction agent for a continual-evolution harness.\n\nYou receive only an incremental conversation checkpoint and a frozen manifest of existing memory entries. Your entire job is to decide whether this checkpoint contains a durable fact worth remembering. Never propose prompt notes, skills, subagent specs, code changes, or general conversation summaries.\n\nRules:\n- Use memory_search before creating when the manifest may already cover the topic. Update an existing entry instead of creating a near-duplicate.\n- Every memory entry contains exactly one fact. Classify it with metadata.memoryType = user | feedback | project | reference.\n- feedback and project memories must state the fact, Why it matters, and How to apply it next time.\n- Never invent a user preference. Ground every proposal in the supplied conversation evidence and existing memory.\n- Every edit must have kind=memory, an explicit targetScope, and a coherent blastRadius.\n- targetScope=local is session staging. project persists within the current repository. global persists across projects. project/global require human approval before application.\n- update/delete/archive must name an existing id from the same targetScope. Prefer archive over delete when the fact is obsolete but should remain restorable.\n- Do not remember: code structure or file paths re-readable from the repository; git history, diffs, commit hashes, or CI logs; content already written in project instruction files; temporary session state, one-off debugging trails, or current task progress; model-only speculation without conversation evidence; an already-applied troubleshooting fix with no recurrence evidence (the fixed state on disk is its own record).\n- Be specific enough to act on: prefer a fact that tells the next session what to DO over a summary of what happened. If the fact is obvious from the conversation itself with no future action attached, skip it.\n- Save only what is surprising or non-obvious: routine chatter, restated context, and facts with no bearing on future work are no-ops, not memories.\n- Granularity examples (vague \u2192 reject; sharp \u2192 save):\n  - \"user communicates in Chinese\" \u2192 \"user reads English with effort \u2014 write memory and handoff content in Chinese prose\".\n  - \"user works on the desktop project\" \u2192 \"desktop profile loads npm-installed plugin copies \u2014 source edits need a release before they take effect\".\n  - \"fixed fcitx5 by setting GTK_IM_MODULE tonight\" \u2192 reject (one-off applied fix, already on disk, no recurrence evidence).\n- You cannot read or write source files, call agents, use MCP, use the network, or mutate the harness directly. memory_propose is the only finish tool and never writes state itself.\n- If no durable memory is justified, call memory_propose with edits=[].\n- Always finish by calling memory_propose. Do not return unproposed prose.";
-/** Build the frozen memory manifest from a merged harness view. */
-export declare function buildMemoryManifest(state: HarnessState): MemoryManifestEntry[];
-/** Render a bounded manifest index; full bodies remain available through memory_search. */
-export declare function formatMemoryManifest(entries: readonly MemoryManifestEntry[], maxChars?: number): string;
-/** Rank frozen manifest entries with CJK-aware token overlap and stable tie-breaking. */
-export declare function searchMemoryManifest(entries: readonly MemoryManifestEntry[], query: string, maxResults?: number): MemoryManifestEntry[];
-/** Inputs for one bounded background memory extraction loop. */
-export interface MemoryAgentOptions {
+/** Build the frozen memory manifest from a merged harness view. */ export interface MemoryAgentOptions {
     provider: string;
     model: string;
-    sessionId?: LlmSessionId;
+    sessionId?: LlmSessionId | string;
     manifest: readonly MemoryManifestEntry[];
     trajectory: string;
     trajectoryEvents?: readonly unknown[];
@@ -97,31 +90,4 @@ export interface MemoryAgentOptions {
 export declare function runMemoryAgent(ctx: Context, options: MemoryAgentOptions): Promise<MemoryAgentRun>;
 /** Strictly parse and policy-check the structured `memory_propose` payload. */
 export declare function parseMemoryExtractionProposal(value: unknown, manifest: readonly MemoryManifestEntry[]): MemoryExtractionProposal;
-export interface ApplyMemoryProposalOptions {
-    agent: Agent;
-    baselines: MemoryScopeBaselines;
-    projectKey?: string;
-    requireApproval: boolean;
-    source?: EntrySource;
-    signal?: AbortSignal;
-    /** Outer cursor used to scope reusable approval decisions. */
-    decisionCursor?: string;
-    /** Prior decisions for the same cursor and exact scoped proposal. */
-    scopeDecisions?: Readonly<Record<string, ScopeApprovalDecision>>;
-    /** Persist each decision before a later scope can fail. */
-    onScopeDecision?: (key: string, decision: ScopeApprovalDecision) => void;
-}
-/**
- * Render the authoritative persistent-scope diff shown to the human. Model
- * prose is retained only as an explicitly untrusted summary; actions, targets,
- * content previews, memory types, and conflict warnings come from code.
- */
-export declare function renderMemoryApprovalDetails(proposal: MemoryExtractionProposal, scope: "project" | "global", state: HarnessState, maxChars?: number): string;
-/**
- * Apply one accepted proposal through the only mutation engine. All persistent
- * approvals are resolved before the first write, so an unavailable approval
- * boundary cannot leave a partially applied batch. Explicit rejection is a
- * no-op for that scope; service/question failures remain retryable errors.
- */
-export declare function applyMemoryExtractionProposal(ctx: Context, engine: EvolutionEngine, proposal: MemoryExtractionProposal, options: ApplyMemoryProposalOptions): Promise<MemoryApplicationResult>;
 //# sourceMappingURL=memory-agent.d.ts.map

package/lib/memory-agent.js

@@ -1,18 +1,13 @@
 import { createAssistantMessage, createToolResultMessage, createUserMessage, } from "@deepseek-ai/dsh-llm";
-import { requestScopeApproval } from "./approval.js";
-import { fingerprintMemoryBatch, isDeclinedRepeat, loadDeclinedMemory, recordDeclinedMemory, } from "./declines.js";
-import { streamModelTurn } from "./llm-text.js";
 import { EVOLVE_MESSAGE_SOURCE } from "./message-source.js";
+import { asLlmSessionId, streamModelTurn } from "./llm-text.js";
+import { formatMemoryManifest, manifestResult, searchMemoryManifest } from "./memory-manifest.js";
+import { validateBlastRadiusScope, validateEdit } from "./validate.js";
 import { extractJsonObject, parseJsonCandidate } from "./plan.js";
 import { buildPrefixMessages, detectPlannerRoute, resolvePrefixCache } from "./prefix-cache.js";
-import { compactText } from "./render.js";
-import { buildConflictNotice, CONFLICT_WARN_SCORE, mostSimilarEntry } from "./promotion.js";
-import { EvolutionApplyPostCommitError } from "./service.js";
-import { tokenize } from "./search.js";
 import { createTokenUsageObserver } from "./token-usage.js";
 import { recordLanguageInstruction, resolveRecordLanguage } from "./record-language.js";
-import { isArchived, isMemoryType, MEMORY_TYPE_KEY, slug } from "./types.js";
-import { validateBlastRadiusScope, validateEdit } from "./validate.js";
+import { MEMORY_TYPE_KEY, slug } from "./types.js";
 /** ZCode parity: the extractor may inspect memory and propose at most five times. */
 export const MEMORY_AGENT_MAX_TURNS = 5;
 /** Bound one proposal so approval text and engine compensation stay reviewable. */
@@ -103,57 +98,6 @@ Rules:
 - You cannot read or write source files, call agents, use MCP, use the network, or mutate the harness directly. memory_propose is the only finish tool and never writes state itself.
 - If no durable memory is justified, call memory_propose with edits=[].
 - Always finish by calling memory_propose. Do not return unproposed prose.`;
-/** Build the frozen memory manifest from a merged harness view. */
-export function buildMemoryManifest(state) {
-    return Object.values(state.entries.memory)
-        .map((entry) => ({ ...entry, metadata: { ...entry.metadata }, reference: {}, arguments: {} }))
-        .sort((a, b) => manifestOrder(a).localeCompare(manifestOrder(b), "en"));
-}
-/** Render a bounded manifest index; full bodies remain available through memory_search. */
-export function formatMemoryManifest(entries, maxChars = 8000) {
-    if (entries.length === 0)
-        return "No saved memory entries yet.";
-    const lines = [];
-    let used = 0;
-    for (const entry of entries) {
-        const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? entry.metadata[MEMORY_TYPE_KEY] : "untyped";
-        const archived = isArchived(entry) ? ", archived" : "";
-        const line = `- [${entry.scope}:${entry.id}] ${entry.title} (memoryType=${type}, path=${entry.path}${archived}): ${compactText(entry.content, 240)}`;
-        if (used + line.length + 1 > maxChars)
-            break;
-        lines.push(line);
-        used += line.length + 1;
-    }
-    const omitted = entries.length - lines.length;
-    if (omitted > 0)
-        lines.push(`- +${omitted} more entries; use memory_search with a narrower query.`);
-    return lines.join("\n");
-}
-/** Rank frozen manifest entries with CJK-aware token overlap and stable tie-breaking. */
-export function searchMemoryManifest(entries, query, maxResults = 8) {
-    const queryTokens = new Set(tokenize(query));
-    if (queryTokens.size === 0)
-        return [];
-    return entries
-        .map((entry) => {
-        const title = tokenize(entry.title);
-        const body = tokenize(`${entry.content} ${entry.path} ${String(entry.metadata[MEMORY_TYPE_KEY] ?? "")}`);
-        let score = 0;
-        for (const token of queryTokens) {
-            if (title.includes(token))
-                score += 2;
-            if (body.includes(token))
-                score += 1;
-        }
-        if (`${entry.scope}:${entry.id}`.toLowerCase() === query.trim().toLowerCase())
-            score += 100;
-        return { entry, score };
-    })
-        .filter((hit) => hit.score > 0)
-        .sort((a, b) => b.score - a.score || manifestOrder(a.entry).localeCompare(manifestOrder(b.entry), "en"))
-        .slice(0, maxResults)
-        .map((hit) => hit.entry);
-}
 /**
  * Run the dedicated loop against a frozen manifest.
  *
@@ -190,7 +134,7 @@ export async function runMemoryAgent(ctx, options) {
         const blocks = await streamModelTurn(ctx, {
             provider: options.provider,
             model: options.model,
-            ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+            ...(options.sessionId ? { sessionId: asLlmSessionId(options.sessionId) } : {}),
             system: systemPrompt,
             messages,
             tools: MEMORY_AGENT_TOOL_SCHEMAS,
@@ -252,188 +196,6 @@ export function parseMemoryExtractionProposal(value, manifest) {
     const edits = record["edits"].map((raw, index) => parseScopedMemoryEdit(raw, index, byScopeId));
     return { summary, rationale, expectedOutcome, edits };
 }
-/**
- * Render the authoritative persistent-scope diff shown to the human. Model
- * prose is retained only as an explicitly untrusted summary; actions, targets,
- * content previews, memory types, and conflict warnings come from code.
- */
-export function renderMemoryApprovalDetails(proposal, scope, state, maxChars = 6000) {
-    const edits = proposal.edits.filter((candidate) => candidate.targetScope === scope);
-    const details = edits.map((edit) => {
-        const before = edit.id ? state.entries.memory[edit.id] : undefined;
-        const title = edit.title ?? before?.title ?? "(existing title unchanged)";
-        const path = edit.path ?? before?.path ?? "(path unchanged)";
-        const content = edit.content ?? (edit.action === "update" ? "(content unchanged)" : "(no content field)");
-        const type = edit.metadata?.[MEMORY_TYPE_KEY] ?? before?.metadata[MEMORY_TYPE_KEY] ?? "untyped";
-        const candidates = Object.values(state.entries.memory).filter((entry) => entry.id !== edit.id);
-        const hit = edit.action === "create" || edit.action === "update"
-            ? mostSimilarEntry(candidates, edit.title ?? before?.title ?? "", edit.content ?? before?.content ?? "", CONFLICT_WARN_SCORE)
-            : undefined;
-        const conflict = hit ? `; conflict: ${compactText(buildConflictNotice(hit), 120)}` : "";
-        const targetId = edit.id === undefined ? "(new)" : JSON.stringify(edit.id);
-        return {
-            target: `- ${edit.action} ${scope}:${targetId} — ${compactText(title, 80)}`,
-            detail: `  path=${compactText(path, 60)}; memoryType=${String(type)}; content=${compactText(content, 100)}${conflict}`,
-        };
-    });
-    let titleLimit = 80;
-    let targets = details.map((detail) => detail.target.replace(/ — .*$/, ` — ${compactText(detail.target.split(" — ")[1] ?? "", titleLimit)}`));
-    let base = ["edits to approve:", ...targets].join("\n");
-    while (base.length > maxChars && titleLimit > 20) {
-        titleLimit = Math.floor(titleLimit / 2);
-        targets = details.map((detail) => `- ${detail.target.split(" — ")[0]} — ${compactText(detail.target.split(" — ")[1] ?? "", titleLimit)}`);
-        base = ["edits to approve:", ...targets].join("\n");
-    }
-    if (base.length > maxChars)
-        throw new Error(`memory approval diff exceeds ${maxChars} characters`);
-    const output = [base];
-    const summary = `model summary (untrusted): ${compactText(proposal.summary, 180)}`;
-    if ([...output, summary].join("\n").length <= maxChars)
-        output.push(summary);
-    for (const detail of details) {
-        const line = detail.detail;
-        if ([...output, line].join("\n").length <= maxChars)
-            output.push(line);
-    }
-    if ([...output, "  (additional previews omitted; every target is listed above)"].join("\n").length <= maxChars) {
-        output.push("  (additional previews omitted; every target is listed above)");
-    }
-    return output.join("\n");
-}
-function memoryScopeDecisionKey(cursor, scope, edits) {
-    return `${cursor}:${scope}:${JSON.stringify(edits.map(stripTargetScope))}`;
-}
-class MemoryApplyBatchError extends Error {
-    result;
-    scope;
-    storeId;
-    constructor(message, result, scope, storeId) {
-        super(message);
-        this.result = result;
-        this.scope = scope;
-        this.storeId = storeId;
-    }
-}
-/**
- * Apply one accepted proposal through the only mutation engine. All persistent
- * approvals are resolved before the first write, so an unavailable approval
- * boundary cannot leave a partially applied batch. Explicit rejection is a
- * no-op for that scope; service/question failures remain retryable errors.
- */
-export async function applyMemoryExtractionProposal(ctx, engine, proposal, options) {
-    const scopeOrder = ["local", "project", "global"];
-    const editsByScope = new Map();
-    for (const scope of scopeOrder) {
-        const edits = proposal.edits.filter((edit) => edit.targetScope === scope);
-        if (edits.length > 0)
-            editsByScope.set(scope, edits);
-    }
-    if (editsByScope.has("project") && !options.projectKey) {
-        throw new Error("memory agent cannot target project scope without a resolved project key");
-    }
-    const approvedScopes = new Set();
-    const declinedScopes = [];
-    for (const scope of ["project", "global"]) {
-        if (!editsByScope.has(scope))
-            continue;
-        if (!options.requireApproval) {
-            approvedScopes.add(scope);
-            continue;
-        }
-        const baseline = options.baselines[scope];
-        if (!baseline)
-            throw new Error(`memory agent has no ${scope} baseline`);
-        const scopeEdits = proposal.edits.filter((edit) => edit.targetScope === scope);
-        const fingerprint = fingerprintMemoryBatch(scope, scopeEdits);
-        if (isDeclinedRepeat(loadDeclinedMemory(engine.baseDir), scope, fingerprint)) {
-            ctx.logger("continual-evolve").info(`memory ${scope} proposal repeat-suppressed (declined before, no popup)`);
-            declinedScopes.push(scope);
-            continue;
-        }
-        const decisionKey = options.decisionCursor === undefined
-            ? undefined
-            : memoryScopeDecisionKey(options.decisionCursor, scope, proposal.edits.filter((edit) => edit.targetScope === scope));
-        const previous = decisionKey === undefined ? undefined : options.scopeDecisions?.[decisionKey];
-        if (previous === "approved") {
-            approvedScopes.add(scope);
-            continue;
-        }
-        if (previous === "declined") {
-            declinedScopes.push(scope);
-            continue;
-        }
-        const approved = await requestScopeApproval(ctx, options.agent, options.signal, scope, renderMemoryApprovalDetails(proposal, scope, baseline));
-        if (decisionKey !== undefined)
-            options.onScopeDecision?.(decisionKey, approved);
-        if (approved === "approved")
-            approvedScopes.add(scope);
-        else {
-            declinedScopes.push(scope);
-            try {
-                recordDeclinedMemory(engine.baseDir, scope, scopeEdits, compactText(scopeEdits[0]?.title ?? proposal.summary, 120));
-            }
-            catch (error) {
-                ctx.logger("continual-evolve").warn(`declined-memory ledger write failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    const results = [];
-    const applied = [];
-    try {
-        for (const scope of scopeOrder) {
-            const edits = editsByScope.get(scope);
-            if (!edits)
-                continue;
-            if (scope !== "local" && !approvedScopes.has(scope))
-                continue;
-            options.signal?.throwIfAborted();
-            const storeId = scope === "local" ? options.agent.id : scope === "project" ? options.projectKey : undefined;
-            const baseline = options.baselines[scope];
-            if (!baseline)
-                throw new Error(`memory agent has no ${scope} baseline`);
-            const result = engine.apply(scope, storeId, {
-                summary: proposal.summary,
-                rationale: proposal.rationale,
-                expectedOutcome: proposal.expectedOutcome,
-                edits: prepareMemoryEdits(edits, baseline),
-            }, {
-                scope,
-                baselineState: baseline,
-                ...(options.source ? { source: options.source } : {}),
-            });
-            const failed = result.appliedEdits.filter((edit) => !edit.applied);
-            if (failed.length > 0) {
-                throw new MemoryApplyBatchError(`${scope} batch ${result.id} left ${failed.length} edit(s) unapplied: ${failed.map((edit) => edit.error ?? "unknown").join("; ")}`, result, scope, storeId);
-            }
-            results.push(result);
-            applied.push({ scope, storeId, result });
-        }
-        return { results, declinedScopes };
-    }
-    catch (cause) {
-        const attempted = [...applied];
-        if (cause instanceof MemoryApplyBatchError && cause.result && cause.scope) {
-            attempted.push({ scope: cause.scope, storeId: cause.storeId, result: cause.result });
-        }
-        else if (cause instanceof EvolutionApplyPostCommitError) {
-            attempted.push({ scope: cause.scope, storeId: cause.storeId, result: cause.result });
-        }
-        const rollbackErrors = [];
-        for (const item of attempted.reverse()) {
-            try {
-                const rollback = engine.rollbackResult(item.scope, item.storeId, item.result);
-                const failed = rollback.appliedEdits.filter((edit) => !edit.applied);
-                if (failed.length > 0)
-                    rollbackErrors.push(`${item.scope}:${item.result.id} left ${failed.length} rollback edit(s) unapplied`);
-            }
-            catch (rollbackCause) {
-                rollbackErrors.push(`${item.scope}:${item.result.id} rollback failed: ${rollbackCause instanceof Error ? rollbackCause.message : String(rollbackCause)}`);
-            }
-        }
-        const suffix = rollbackErrors.length > 0 ? `; compensation errors: ${rollbackErrors.join("; ")}` : "; prior memory writes were rolled back";
-        throw new Error(`memory agent apply failed: ${cause instanceof Error ? cause.message : String(cause)}${suffix}`);
-    }
-}
 function executeMemoryTool(call, manifest) {
     if (!MEMORY_AGENT_TOOL_NAMES.includes(call.name)) {
         return { text: `tool denied: only ${MEMORY_AGENT_TOOL_NAMES.join(" and ")} are available`, isError: true };
@@ -518,44 +280,14 @@ function parseScopedMemoryEdit(raw, index, byScopeId) {
         throw new Error(`memory edit ${index}: ${validationError}`);
     return edit;
 }
-function prepareMemoryEdits(edits, baseline) {
-    return edits.map((edit) => {
-        const plain = stripTargetScope(edit);
-        if (plain.action !== "update" || plain.metadata === undefined || plain.id === undefined)
-            return plain;
-        const before = baseline.entries.memory[plain.id];
-        return before ? { ...plain, metadata: { ...before.metadata, ...plain.metadata } } : plain;
-    });
-}
-function stripTargetScope(edit) {
-    const { targetScope: _targetScope, ...plain } = edit;
-    return plain;
-}
-function manifestResult(entry) {
-    return {
-        scope: entry.scope,
-        id: entry.id,
-        title: entry.title,
-        content: entry.content,
-        path: entry.path,
-        memoryType: entry.metadata[MEMORY_TYPE_KEY],
-        archived: isArchived(entry),
-    };
-}
-function manifestOrder(entry) {
-    const scope = entry.scope === "global" ? "0" : entry.scope === "project" ? "1" : "2";
-    return `${scope}:${entry.id}:${entry.title}`;
-}
 function textOf(blocks) {
     return blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
+        .map((block) => (block.type === "text" ? block.text : ""))
+        .filter((text) => text.length > 0)
         .join("\n");
 }
 function asRecord(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return undefined;
-    return value;
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 function requiredString(value, field) {
     if (typeof value !== "string" || value.trim().length === 0)

package/lib/memory-apply.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Memory proposal application: take the extractor's structured proposal and
+ * land it through the governed path — per-scope human approval (unique,
+ * explicit, fail-loud), credential screening, conflict notices, engine
+ * apply with baseline checks, decline recording, and cross-scope
+ * compensation on partial failure.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { EntrySource, HarnessState } from "./types.js";
+import { type ScopeApprovalDecision } from "./approval.js";
+import { type EvolutionEngine } from "./service.js";
+import type { MemoryApplicationResult, MemoryExtractionProposal, MemoryScopeBaselines } from "./memory-agent.js";
+import type { RecordLanguagePreference } from "./record-language.js";
+export interface ApplyMemoryProposalOptions {
+    agent: Agent;
+    baselines: MemoryScopeBaselines;
+    projectKey?: string;
+    requireApproval: boolean;
+    source?: EntrySource;
+    signal?: AbortSignal;
+    /** Outer cursor used to scope reusable approval decisions. */
+    decisionCursor?: string;
+    /** Prior decisions for the same cursor and exact scoped proposal. */
+    scopeDecisions?: Readonly<Record<string, ScopeApprovalDecision>>;
+    /** Persist each decision before a later scope can fail. */
+    onScopeDecision?: (key: string, decision: ScopeApprovalDecision) => void;
+    /** Plugin `recordLanguage` preference for the approval dialog copy. */
+    recordLanguage?: RecordLanguagePreference;
+}
+/**
+ * Render the authoritative persistent-scope diff shown to the human. Model
+ * prose is retained only as an explicitly untrusted summary; actions, targets,
+ * content previews, memory types, and conflict warnings come from code.
+ */
+export declare function renderMemoryApprovalDetails(proposal: MemoryExtractionProposal, scope: "project" | "global", state: HarnessState, maxChars?: number): string;
+/**
+ * Apply one accepted proposal through the only mutation engine. All persistent
+ * approvals are resolved before the first write, so an unavailable approval
+ * boundary cannot leave a partially applied batch. Explicit rejection is a
+ * no-op for that scope; service/question failures remain retryable errors.
+ */
+export declare function applyMemoryExtractionProposal(ctx: Context, engine: EvolutionEngine, proposal: MemoryExtractionProposal, options: ApplyMemoryProposalOptions): Promise<MemoryApplicationResult>;
+//# sourceMappingURL=memory-apply.d.ts.map