dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/maintenance-commands.d.ts

@@ -1,23 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import type { CommandInvocation } from "@deepseek-ai/dsh-commands";
-import { type HarnessScope } from "./types.js";
-import type { EvolutionEngine } from "./service.js";
-import { type CommandTextResult } from "./command-util.js";
-type ScopeArg = {
-    scope: HarnessScope;
-    rest: string[];
-};
-/** `/evolve archive|unarchive <id> [global|project]` — hide or restore an entry. */
-export declare function executeArchiveCommand(_ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, sub: "archive" | "unarchive", parsed: ScopeArg, usage: string): Promise<CommandTextResult>;
-/** `/evolve consolidate [apply] [merge]` — deterministic global-store hygiene. */
-export declare function executeConsolidateCommand(engine: EvolutionEngine, rest: string[]): CommandTextResult;
-/** `/evolve failures` — failure-signature aggregation (D1 observation). */
-export declare function executeFailuresCommand(engine: EvolutionEngine): CommandTextResult;
-/** `/evolve log [tail N] [session <sessionId>]` — plugin file log inspection. */
-export declare function executeLogCommand(engine: EvolutionEngine, rest: string[], usage: string): CommandTextResult;
-/** `/evolve export [global|project] <path>` — backup a store to a JSON file. */
-export declare function executeExportCommand(engine: EvolutionEngine, invocation: CommandInvocation, parsed: ScopeArg, usage: string): CommandTextResult;
-/** `/evolve import [global|project] <path>` — restore a store from an export file. */
-export declare function executeImportCommand(engine: EvolutionEngine, invocation: CommandInvocation, parsed: ScopeArg, path: string | undefined): CommandTextResult;
-export {};
-//# sourceMappingURL=maintenance-commands.d.ts.map

package/lib/maintenance-commands.js

@@ -1,136 +0,0 @@
-/**
- * `/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

@@ -1,93 +0,0 @@
-/**
- * Dedicated background memory extraction agent.
- *
- * This is the DSH counterpart of ZCode's project-memory agent loop. It keeps
- * an independent request history, exposes only a frozen memory manifest and a
- * 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 ToolSchema } from "@deepseek-ai/dsh-llm";
-import { type LlmSessionId } from "./llm-text.js";
-import { type MemoryManifestEntry } from "./memory-manifest.js";
-import { type PrefixCacheOptions } from "./prefix-cache.js";
-import { type TokenUsageTarget } from "./token-usage.js";
-import { type RecordLanguage } from "./record-language.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. */
-export declare const MEMORY_AGENT_MAX_EDITS = 20;
-/**
- * System-prompt size budget (chars): the prompt ships on EVERY extractor
- * turn (up to five per snapshot), so each added line is recurring token
- * spend, not one-off text. Raise this cap only in the same commit that
- * justifies the added lines (regression pressure beats silent bloat).
- */
-export declare const MEMORY_AGENT_SYSTEM_PROMPT_BUDGET_CHARS = 3000;
-/** The complete tool-name allowlist exposed by the memory agent. */
-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. */
-/** A memory-only edit with an explicit persistence target. */
-export type ScopedMemoryEdit = RefinementEdit & {
-    kind: "memory";
-    targetScope: HarnessScope;
-};
-/** Structured result returned by `memory_propose`. */
-export interface MemoryExtractionProposal extends Omit<RefinementProposal, "edits"> {
-    edits: ScopedMemoryEdit[];
-}
-/** Baseline states captured before the first extractor model turn. */
-export interface MemoryScopeBaselines {
-    local: HarnessState;
-    project?: HarnessState;
-    global: HarnessState;
-}
-/** Result of one bounded extractor loop. */
-export interface MemoryAgentRun {
-    proposal: MemoryExtractionProposal;
-    turns: number;
-    searches: number;
-}
-/** Scoped results after the proposal crosses the governed engine boundary. */
-export interface MemoryApplicationResult {
-    results: RefinementResult[];
-    declinedScopes: HarnessScope[];
-}
-/** Provider-facing schemas for the closed memory-only tool set. */
-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 interface MemoryAgentOptions {
-    provider: string;
-    model: string;
-    sessionId?: LlmSessionId | string;
-    manifest: readonly MemoryManifestEntry[];
-    trajectory: string;
-    trajectoryEvents?: readonly unknown[];
-    prefixCache?: PrefixCacheOptions;
-    maxOutputTokens?: number;
-    signal?: AbortSignal;
-    tokenUsage?: TokenUsageTarget;
-    /**
-     * Authoring language for the proposal. Absent → resolved per call
-     * (explicit config upstream, else durable client preference, else
-     * trajectory detection, else `en`).
-     */
-    language?: RecordLanguage;
-}
-/**
- * Run the dedicated loop against a frozen manifest.
- *
- * @throws On provider failure, abort, malformed tool arguments, policy denial,
- * a non-memory proposal, or exhaustion of the bounded internal turn budget.
- */
-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;
-//# sourceMappingURL=memory-agent.d.ts.map

package/lib/memory-agent.js

@@ -1,300 +0,0 @@
-import { createAssistantMessage, createToolResultMessage, createUserMessage, } from "@deepseek-ai/dsh-llm";
-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 { createTokenUsageObserver } from "./token-usage.js";
-import { recordLanguageInstruction, resolveRecordLanguage } from "./record-language.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. */
-export const MEMORY_AGENT_MAX_EDITS = 20;
-/**
- * System-prompt size budget (chars): the prompt ships on EVERY extractor
- * turn (up to five per snapshot), so each added line is recurring token
- * spend, not one-off text. Raise this cap only in the same commit that
- * justifies the added lines (regression pressure beats silent bloat).
- */
-export const MEMORY_AGENT_SYSTEM_PROMPT_BUDGET_CHARS = 3000;
-/** The complete tool-name allowlist exposed by the memory agent. */
-export const MEMORY_AGENT_TOOL_NAMES = ["memory_search", "memory_propose"];
-/** Provider-facing schemas for the closed memory-only tool set. */
-export const MEMORY_AGENT_TOOL_SCHEMAS = [
-    {
-        name: "memory_search",
-        description: "Read full content from the frozen memory manifest. This is the only data-reading tool available to the memory extractor.",
-        parameters: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                query: { type: "string", description: "Keywords, title text, scope:id, or content terms to retrieve." },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "memory_propose",
-        description: "Finish extraction with one auditable memory-only proposal. An empty edits array is a valid no-op.",
-        parameters: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                summary: { type: "string" },
-                rationale: { type: "string" },
-                expectedOutcome: { type: "string" },
-                edits: {
-                    type: "array",
-                    maxItems: MEMORY_AGENT_MAX_EDITS,
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        properties: {
-                            action: { type: "string", enum: ["create", "update", "delete", "archive"] },
-                            kind: { type: "string", enum: ["memory"] },
-                            targetScope: { type: "string", enum: ["local", "project", "global"] },
-                            blastRadius: { type: "string", enum: ["general", "project", "session"] },
-                            id: { type: "string", pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$" },
-                            title: { type: "string" },
-                            content: { type: "string" },
-                            path: { type: "string" },
-                            metadata: {
-                                type: "object",
-                                additionalProperties: false,
-                                properties: { memoryType: { type: "string", enum: ["user", "feedback", "project", "reference"] } },
-                            },
-                            reason: { type: "string" },
-                        },
-                        required: ["action", "kind", "targetScope", "blastRadius"],
-                    },
-                },
-            },
-            required: ["summary", "rationale", "expectedOutcome", "edits"],
-        },
-    },
-];
-/** Instructions for the dedicated loop; model text is always untrusted. */
-export const MEMORY_AGENT_SYSTEM_PROMPT = `You are the dedicated background memory extraction agent for a continual-evolution harness.
-
-You 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.
-
-Rules:
-- Use memory_search before creating when the manifest may already cover the topic. Update an existing entry instead of creating a near-duplicate.
-- Every memory entry contains exactly one fact. Classify it with metadata.memoryType = user | feedback | project | reference.
-- feedback and project memories must state the fact, Why it matters, and How to apply it next time.
-- Never invent a user preference. Ground every proposal in the supplied conversation evidence and existing memory.
-- Every edit must have kind=memory, an explicit targetScope, and a coherent blastRadius.
-- targetScope=local is session staging. project persists within the current repository. global persists across projects. project/global require human approval before application.
-- 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.
-- 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).
-- 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.
-- 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.
-- Granularity examples (vague → reject; sharp → save):
-  - "user communicates in Chinese" → "user reads English with effort — write memory and handoff content in Chinese prose".
-  - "user works on the desktop project" → "desktop profile loads npm-installed plugin copies — source edits need a release before they take effect".
-  - "fixed fcitx5 by setting GTK_IM_MODULE tonight" → reject (one-off applied fix, already on disk, no recurrence evidence).
-- 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.`;
-/**
- * Run the dedicated loop against a frozen manifest.
- *
- * @throws On provider failure, abort, malformed tool arguments, policy denial,
- * a non-memory proposal, or exhaustion of the bounded internal turn budget.
- */
-export async function runMemoryAgent(ctx, options) {
-    const events = options.trajectoryEvents ?? [];
-    const routing = resolvePrefixCache(options.prefixCache);
-    const route = detectPlannerRoute(events, routing.mode);
-    const prefixMessages = route === "A"
-        ? buildPrefixMessages(events, { provider: options.provider, model: options.model, maxChars: routing.maxChars })
-        : [];
-    const conversation = prefixMessages.length > 0 ? "" : `<conversation>\n${options.trajectory}\n</conversation>`;
-    const prompt = [
-        `<memory_manifest>\n${formatMemoryManifest(options.manifest)}\n</memory_manifest>`,
-        conversation,
-        "Search before deciding, then call memory_propose with the complete memory-only proposal. Empty edits is a valid no-op.",
-    ]
-        .filter(Boolean)
-        .join("\n\n");
-    const messages = [
-        ...prefixMessages,
-        createUserMessage({
-            content: [{ type: "text", text: prompt }],
-            source: EVOLVE_MESSAGE_SOURCE,
-        }),
-    ];
-    let searches = 0;
-    const language = options.language ?? resolveRecordLanguage({ ctx, trajectoryText: options.trajectory });
-    const systemPrompt = `${MEMORY_AGENT_SYSTEM_PROMPT}\n\n${recordLanguageInstruction(language)}`;
-    for (let turn = 1; turn <= MEMORY_AGENT_MAX_TURNS; turn += 1) {
-        options.signal?.throwIfAborted();
-        const blocks = await streamModelTurn(ctx, {
-            provider: options.provider,
-            model: options.model,
-            ...(options.sessionId ? { sessionId: asLlmSessionId(options.sessionId) } : {}),
-            system: systemPrompt,
-            messages,
-            tools: MEMORY_AGENT_TOOL_SCHEMAS,
-            requireTextOrToolCall: true,
-            maxTokens: options.maxOutputTokens ?? 4096,
-            ...(options.signal ? { signal: options.signal } : {}),
-            ...(options.tokenUsage
-                ? { onUsage: createTokenUsageObserver(options.tokenUsage, "memory", options.provider, options.model) }
-                : {}),
-        });
-        const hasText = blocks.some((block) => block.type === "text" && block.text.length > 0);
-        const hasToolCall = blocks.some((block) => block.type === "tool-call");
-        if (!hasText && !hasToolCall)
-            throw new Error("memory agent produced no model output");
-        messages.push(createAssistantMessage({
-            content: blocks,
-            source: { provider: options.provider, model: options.model },
-        }));
-        const toolCalls = blocks.filter((block) => block.type === "tool-call");
-        if (toolCalls.length === 0) {
-            const text = textOf(blocks);
-            return {
-                proposal: parseMemoryExtractionProposal(extractJsonObject(text), options.manifest),
-                turns: turn,
-                searches,
-            };
-        }
-        let proposal;
-        for (const call of toolCalls) {
-            const execution = executeMemoryTool(call, options.manifest);
-            if (call.name === "memory_search")
-                searches += 1;
-            proposal ??= execution.proposal;
-            messages.push(createToolResultMessage({
-                callId: call.id,
-                content: [{ type: "text", text: execution.text }],
-                isError: execution.isError,
-            }));
-        }
-        if (proposal)
-            return { proposal, turns: turn, searches };
-    }
-    throw new Error(`memory agent exhausted ${MEMORY_AGENT_MAX_TURNS} internal turns without a valid proposal`);
-}
-/** Strictly parse and policy-check the structured `memory_propose` payload. */
-export function parseMemoryExtractionProposal(value, manifest) {
-    const record = asRecord(value);
-    if (!record)
-        throw new Error("memory proposal must be an object");
-    const summary = requiredString(record["summary"], "summary");
-    const rationale = requiredString(record["rationale"], "rationale");
-    const expectedOutcome = requiredString(record["expectedOutcome"], "expectedOutcome");
-    if (!Array.isArray(record["edits"]))
-        throw new Error("memory proposal edits must be an array");
-    if (record["edits"].length > MEMORY_AGENT_MAX_EDITS) {
-        throw new Error(`memory proposal exceeds ${MEMORY_AGENT_MAX_EDITS} edits`);
-    }
-    const byScopeId = new Map(manifest.map((entry) => [`${entry.scope}:${entry.id}`, entry]));
-    const edits = record["edits"].map((raw, index) => parseScopedMemoryEdit(raw, index, byScopeId));
-    return { summary, rationale, expectedOutcome, edits };
-}
-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 };
-    }
-    try {
-        const args = parseJsonCandidate(call.arguments.trim() || "{}");
-        if (call.name === "memory_search") {
-            const record = asRecord(args);
-            const query = record ? requiredString(record["query"], "query") : "";
-            const matches = searchMemoryManifest(manifest, query).map(manifestResult);
-            return { text: JSON.stringify({ matches }), isError: false };
-        }
-        return { proposal: parseMemoryExtractionProposal(args, manifest), text: JSON.stringify({ accepted: true }), isError: false };
-    }
-    catch (cause) {
-        return {
-            text: `tool error: ${cause instanceof Error ? cause.message : String(cause)}`,
-            isError: true,
-        };
-    }
-}
-function parseScopedMemoryEdit(raw, index, byScopeId) {
-    const record = asRecord(raw);
-    if (!record)
-        throw new Error(`memory edit ${index} must be an object`);
-    const action = requiredString(record["action"], `edits[${index}].action`);
-    if (!isOneOf(action, ["create", "update", "delete", "archive"])) {
-        throw new Error(`memory edit ${index} has unsupported action ${action}`);
-    }
-    if (record["kind"] !== "memory")
-        throw new Error(`memory edit ${index} must have kind=memory`);
-    const targetScope = requiredString(record["targetScope"], `edits[${index}].targetScope`);
-    if (!isOneOf(targetScope, ["local", "project", "global"])) {
-        throw new Error(`memory edit ${index} has unsupported targetScope ${targetScope}`);
-    }
-    const blastRadius = requiredString(record["blastRadius"], `edits[${index}].blastRadius`);
-    if (!isOneOf(blastRadius, ["general", "project", "session"])) {
-        throw new Error(`memory edit ${index} has unsupported blastRadius ${blastRadius}`);
-    }
-    const blastError = validateBlastRadiusScope(targetScope, blastRadius);
-    if (blastError)
-        throw new Error(`memory edit ${index}: ${blastError}`);
-    if (record["reference"] !== undefined || record["arguments"] !== undefined || record["skill_kind"] !== undefined) {
-        throw new Error(`memory edit ${index} cannot carry skill-only fields`);
-    }
-    const edit = {
-        action,
-        kind: "memory",
-        targetScope,
-        blastRadius,
-    };
-    for (const field of ["id", "title", "content", "path", "reason"]) {
-        const fieldValue = record[field];
-        if (fieldValue !== undefined) {
-            if (typeof fieldValue !== "string")
-                throw new Error(`memory edit ${index}.${field} must be a string`);
-            edit[field] = fieldValue;
-        }
-    }
-    if (record["metadata"] !== undefined) {
-        const metadata = asRecord(record["metadata"]);
-        if (!metadata)
-            throw new Error(`memory edit ${index}.metadata must be an object`);
-        const unexpected = Object.keys(metadata).filter((key) => key !== MEMORY_TYPE_KEY);
-        if (unexpected.length > 0) {
-            throw new Error(`memory edit ${index}.metadata contains engine-owned or unsupported keys: ${unexpected.join(", ")}`);
-        }
-        edit.metadata = { ...metadata };
-    }
-    if (action === "create" && edit.id && !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(edit.id)) {
-        throw new Error(`memory edit ${index}.id contains unsupported identifier characters`);
-    }
-    const before = edit.id ? byScopeId.get(`${targetScope}:${edit.id}`) : undefined;
-    if (action !== "create" && !before) {
-        throw new Error(`memory edit ${index} ${action} target does not exist in ${targetScope}: ${edit.id ?? "(missing id)"}`);
-    }
-    if (action === "create" && edit.id && before) {
-        throw new Error(`memory edit ${index} create duplicates ${targetScope}:${edit.id}; use update instead`);
-    }
-    const validationError = validateEdit(edit, edit.id ?? slug(edit.title ?? "memory", "memory"), targetScope, before);
-    if (validationError)
-        throw new Error(`memory edit ${index}: ${validationError}`);
-    return edit;
-}
-function textOf(blocks) {
-    return blocks
-        .map((block) => (block.type === "text" ? block.text : ""))
-        .filter((text) => text.length > 0)
-        .join("\n");
-}
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-}
-function requiredString(value, field) {
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new Error(`${field} must be a non-empty string`);
-    return value;
-}
-function isOneOf(value, values) {
-    return values.includes(value);
-}
-//# sourceMappingURL=memory-agent.js.map

package/lib/memory-apply.d.ts

@@ -1,44 +0,0 @@
-/**
- * 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