dsh-continual-evolve 0.7.6 → 0.9.0

package/lib/index.d.ts

@@ -14,6 +14,11 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     autoReview: z<boolean, boolean, "defined">;
     /** ZCode-style minimum lexical words in one direct user text part. */
     memoryMinUserWords: z<number, number, "defined">;
+    /**
+     * Session-close bounded drain for in-flight extraction, in milliseconds.
+     * Absent → 15s; 0 restores the legacy immediate abort on dispose.
+     */
+    sessionCloseDrainMs: z<number, number, "defined">;
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */
@@ -114,6 +119,11 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     autoReview: z<boolean, boolean, "defined">;
     /** ZCode-style minimum lexical words in one direct user text part. */
     memoryMinUserWords: z<number, number, "defined">;
+    /**
+     * Session-close bounded drain for in-flight extraction, in milliseconds.
+     * Absent → 15s; 0 restores the legacy immediate abort on dispose.
+     */
+    sessionCloseDrainMs: z<number, number, "defined">;
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z<number, number, "defined">;
     /** Trajectory slice handed to the gate, in characters. */

package/lib/index.js

@@ -35,6 +35,11 @@ export const Config = z.object({
     autoReview: z.boolean().default(false),
     /** ZCode-style minimum lexical words in one direct user text part. */
     memoryMinUserWords: z.natural().default(3),
+    /**
+     * Session-close bounded drain for in-flight extraction, in milliseconds.
+     * Absent → 15s; 0 restores the legacy immediate abort on dispose.
+     */
+    sessionCloseDrainMs: z.natural().default(15000),
     /** Legacy/local-fate cadence fallback; successful-turn review is snapshot-driven. */
     reviewIntervalTurns: z.natural().default(6),
     /** Trajectory slice handed to the gate, in characters. */
@@ -192,6 +197,7 @@ export function apply(ctx, config) {
         enabledByDefault: config.autoReview ?? false,
         memoryOnly: true,
         memoryMinUserWords: config.memoryMinUserWords ?? 3,
+        sessionCloseDrainMs: config.sessionCloseDrainMs ?? 15000,
         maxInputChars: config.maxReviewInputChars ?? 40000,
         budgetTokens: config.reviewBudgetTokens ?? 4096,
         notifyOnAutoReview: config.notifyOnAutoReview ?? true,

package/lib/memory-agent.d.ts

@@ -20,6 +20,13 @@ import type { EntrySource, HarnessEntry, HarnessScope, HarnessState, RefinementE
 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];
@@ -54,7 +61,7 @@ export interface MemoryApplicationResult {
 /** 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- 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.";
+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.\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- 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. */

package/lib/memory-agent.js

@@ -15,6 +15,13 @@ import { validateBlastRadiusScope, validateEdit } from "./validate.js";
 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. */
@@ -84,6 +91,12 @@ Rules:
 - 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.
+- 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".
 - 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.`;

package/lib/memory-benchmark.d.ts

@@ -0,0 +1,76 @@
+import type { HarnessEntry } from "./types.js";
+/** One labeled fact the extractor should (or, when outdated, should not) produce. */
+export interface MemoryBenchmarkFact {
+    id: string;
+    memoryType: string;
+    /** Key phrases; an edit matches when its title+content carry every phrase. */
+    mustContain: string[];
+    /** Outdated facts must be avoided (create/update) or removed (archive/delete). */
+    outdated?: boolean;
+}
+export interface MemoryBenchmarkReference {
+    facts: MemoryBenchmarkFact[];
+}
+/** One proposed edit in the shape the memory loop emits. */
+export interface MemoryBenchmarkEdit {
+    action: "create" | "update" | "delete" | "archive";
+    title?: string;
+    content?: string;
+    /** Target entry id for update/delete/archive. */
+    id?: string;
+}
+export interface ScoredMemoryBenchmarkEdit {
+    action: MemoryBenchmarkEdit["action"];
+    matchedFactIds: string[];
+    duplicateOf?: string;
+    staleReason?: string;
+    noisyReason?: string;
+}
+export interface MemoryBenchmarkScore {
+    totalEdits: number;
+    matchedFacts: number;
+    precision: number;
+    recall: number;
+    duplicate: number;
+    stale: number;
+    noise: number;
+    uncoveredFactIds: string[];
+    edits: ScoredMemoryBenchmarkEdit[];
+}
+export interface MemoryGradeThresholds {
+    minPrecision: number;
+    minRecall: number;
+    maxDuplicate: number;
+    maxStale: number;
+    maxNoise: number;
+}
+/** Strict-by-default gate: duplicates and stale operations never pass unnoticed. */
+export declare const DEFAULT_MEMORY_GRADE_THRESHOLDS: MemoryGradeThresholds;
+/**
+ * v1 exclusion heuristics for noise ("不该记什么" in mechanical form):
+ * git history, repo paths re-readable from disk, stack traces, and
+ * explicitly temporary session state. Keep this list short and documented —
+ * every pattern here is a precision/recall tradeoff, not ground truth.
+ */
+export declare const MEMORY_NOISE_PATTERNS: readonly RegExp[];
+/** Content shorter than this is too thin to be a durable fact. */
+export declare const MEMORY_MIN_FACT_CHARS = 30;
+/**
+ * Score one proposal against the reference and the pre-extraction manifest.
+ *
+ * @param reference Labeled facts (live + outdated).
+ * @param edits The proposal's memory edits.
+ * @param manifest Memory entries visible before extraction (duplicate source).
+ * @returns Per-dimension counts plus a per-edit breakdown.
+ */
+export declare function scoreMemoryExtraction(reference: MemoryBenchmarkReference, edits: readonly MemoryBenchmarkEdit[], manifest: readonly HarnessEntry[]): MemoryBenchmarkScore;
+/**
+ * Grade a score against explicit thresholds.
+ *
+ * @returns pass plus one failure line per violated dimension (empty when passing).
+ */
+export declare function gradeMemoryScore(score: MemoryBenchmarkScore, thresholds?: MemoryGradeThresholds): {
+    pass: boolean;
+    failures: string[];
+};
+//# sourceMappingURL=memory-benchmark.d.ts.map

package/lib/memory-benchmark.js

@@ -0,0 +1,170 @@
+/**
+ * Memory-specific extraction benchmark (P1): deterministic scoring of one
+ * memory proposal against a labeled reference.
+ *
+ * Unlike the harness benchmark (which runs subagents against rubrics), this
+ * module scores a proposal's SHAPE without any model call: precision and
+ * recall over reference facts, duplicate creates (update-first violations),
+ * stale operations (re-proposing outdated facts, or removing live ones), and
+ * noise (unmatched or exclusion-list material). Suite authors hand-build
+ * small references plus transcripts; the extraction loop under test produces
+ * the proposal, this module grades it.
+ *
+ * Matching is phrase-substring based (case-insensitive): a reference fact
+ * lists must-contain phrases, and a proposed edit matches when its title
+ * plus content carry every phrase. Deliberately mechanical — the benchmark
+ * measures extraction coverage, not paraphrase quality.
+ */
+import { CONFLICT_BLOCK_SCORE, mostSimilarEntry } from "./promotion.js";
+import { isArchived } from "./types.js";
+/** Strict-by-default gate: duplicates and stale operations never pass unnoticed. */
+export const DEFAULT_MEMORY_GRADE_THRESHOLDS = {
+    minPrecision: 0.7,
+    minRecall: 0.7,
+    maxDuplicate: 0,
+    maxStale: 0,
+    maxNoise: 0,
+};
+/**
+ * v1 exclusion heuristics for noise ("不该记什么" in mechanical form):
+ * git history, repo paths re-readable from disk, stack traces, and
+ * explicitly temporary session state. Keep this list short and documented —
+ * every pattern here is a precision/recall tradeoff, not ground truth.
+ */
+export const MEMORY_NOISE_PATTERNS = [
+    /\bgit\s+(log|show|commit|diff)\b/i,
+    /\bcommit\s+[0-9a-f]{5,40}\b/i,
+    /\b[0-9a-f]{40}\b/,
+    /(?:^|[\s("'])((?:src|lib|test|tests|docs|scripts)\/[A-Za-z0-9_./-]+\.[a-z]+)/,
+    /\bat\s+[\w$.]+\s*\(.*:\d+:\d+\)/,
+    /\b(temporary|one-off debugging|current task progress|in this session only)\b/i,
+];
+/** Content shorter than this is too thin to be a durable fact. */
+export const MEMORY_MIN_FACT_CHARS = 30;
+/**
+ * Score one proposal against the reference and the pre-extraction manifest.
+ *
+ * @param reference Labeled facts (live + outdated).
+ * @param edits The proposal's memory edits.
+ * @param manifest Memory entries visible before extraction (duplicate source).
+ * @returns Per-dimension counts plus a per-edit breakdown.
+ */
+export function scoreMemoryExtraction(reference, edits, manifest) {
+    const live = reference.facts.filter((fact) => !fact.outdated);
+    const outdated = reference.facts.filter((fact) => fact.outdated);
+    const liveMatched = new Set();
+    const outdatedHandled = new Set();
+    const scored = [];
+    let duplicate = 0;
+    let stale = 0;
+    let noise = 0;
+    for (const edit of edits) {
+        const text = `${edit.title ?? ""}\n${edit.content ?? ""}`;
+        const liveHits = live.filter((fact) => matchesFact(text, fact));
+        const outdatedHits = outdated.filter((fact) => matchesFact(text, fact));
+        const entry = { action: edit.action, matchedFactIds: [] };
+        if (edit.action === "create" || edit.action === "update") {
+            if (outdatedHits.length > 0) {
+                stale += 1;
+                entry.staleReason = `re-proposes outdated fact(s): ${outdatedHits.map((fact) => fact.id).join(",")}`;
+            }
+            else if (edit.action === "create") {
+                const hit = mostSimilarEntry(manifest.filter((candidate) => candidate.kind === "memory"), edit.title ?? "", edit.content ?? "", CONFLICT_BLOCK_SCORE);
+                if (hit) {
+                    duplicate += 1;
+                    entry.duplicateOf = hit.id;
+                }
+                else if (liveHits.length > 0) {
+                    for (const fact of liveHits) {
+                        liveMatched.add(fact.id);
+                        entry.matchedFactIds.push(fact.id);
+                    }
+                }
+                else {
+                    noise += 1;
+                    entry.noisyReason = noiseReason(text);
+                }
+            }
+            else if (liveHits.length > 0) {
+                for (const fact of liveHits) {
+                    liveMatched.add(fact.id);
+                    entry.matchedFactIds.push(fact.id);
+                }
+            }
+            else {
+                noise += 1;
+                entry.noisyReason = noiseReason(text);
+            }
+        }
+        else {
+            // delete/archive: correct only against outdated facts.
+            const targetHits = [...liveHits, ...outdatedHits];
+            const targetOutdated = outdatedHits.length > 0;
+            const targetEntry = edit.id !== undefined ? manifest.find((candidate) => candidate.id === edit.id) : undefined;
+            if (targetOutdated) {
+                for (const fact of outdatedHits) {
+                    outdatedHandled.add(fact.id);
+                    entry.matchedFactIds.push(fact.id);
+                }
+            }
+            else if (targetEntry !== undefined && isArchived(targetEntry)) {
+                // Re-archiving an already archived entry is harmless housekeeping.
+                entry.matchedFactIds.push(`archived:${targetEntry.id}`);
+            }
+            else if (targetHits.length > 0 || (targetEntry !== undefined && !isArchived(targetEntry))) {
+                stale += 1;
+                entry.staleReason = `removes live fact(s): ${targetHits.map((fact) => fact.id).join(",") || targetEntry?.id || "(unknown target)"}`;
+            }
+            else {
+                noise += 1;
+                entry.noisyReason = "removal matches no reference fact";
+            }
+        }
+        scored.push(entry);
+    }
+    const total = edits.length;
+    const preciseEdits = scored.filter((entry) => entry.matchedFactIds.length > 0).length;
+    const precision = total === 0 ? 1 : preciseEdits / total;
+    const recall = live.length === 0 ? 1 : liveMatched.size / live.length;
+    return {
+        totalEdits: total,
+        matchedFacts: liveMatched.size + outdatedHandled.size,
+        precision,
+        recall,
+        duplicate,
+        stale,
+        noise,
+        uncoveredFactIds: live.filter((fact) => !liveMatched.has(fact.id)).map((fact) => fact.id),
+        edits: scored,
+    };
+}
+/**
+ * Grade a score against explicit thresholds.
+ *
+ * @returns pass plus one failure line per violated dimension (empty when passing).
+ */
+export function gradeMemoryScore(score, thresholds = DEFAULT_MEMORY_GRADE_THRESHOLDS) {
+    const failures = [];
+    if (score.precision < thresholds.minPrecision)
+        failures.push(`precision ${score.precision.toFixed(2)} < ${thresholds.minPrecision}`);
+    if (score.recall < thresholds.minRecall)
+        failures.push(`recall ${score.recall.toFixed(2)} < ${thresholds.minRecall}`);
+    if (score.duplicate > thresholds.maxDuplicate)
+        failures.push(`duplicate ${score.duplicate} > ${thresholds.maxDuplicate}`);
+    if (score.stale > thresholds.maxStale)
+        failures.push(`stale ${score.stale} > ${thresholds.maxStale}`);
+    if (score.noise > thresholds.maxNoise)
+        failures.push(`noise ${score.noise} > ${thresholds.maxNoise}`);
+    return { pass: failures.length === 0, failures };
+}
+function matchesFact(text, fact) {
+    const lowered = text.toLowerCase();
+    return fact.mustContain.every((phrase) => lowered.includes(phrase.toLowerCase()));
+}
+function noiseReason(text) {
+    if (text.trim().length < MEMORY_MIN_FACT_CHARS)
+        return `thin content (<${MEMORY_MIN_FACT_CHARS} chars)`;
+    const hit = MEMORY_NOISE_PATTERNS.findIndex((pattern) => pattern.test(text));
+    return hit >= 0 ? `matches exclusion pattern #${hit + 1}` : "matches no reference fact";
+}
+//# sourceMappingURL=memory-benchmark.js.map

package/lib/notify.d.ts

@@ -29,4 +29,31 @@ export declare function buildGateNotice(result: RefinementResult, turnsSinceLast
  * the decision in reviews.jsonl.
  */
 export declare function notifyAutoReview(ctx: Context, agent: Agent, result: RefinementResult, turnsSinceLastReview: number): void;
+/** Unified extraction receipt: one shape for applied / declined / no-op. */
+export interface MemoryReceipt {
+    outcome: "applied" | "declined" | "noop";
+    /** Applied refinement batches (one per scope) for applied outcomes. */
+    results?: RefinementResult[];
+    /** Scopes the human explicitly declined. */
+    declinedScopes?: string[];
+    /** Extractor loop turns / manifest searches / wall time. */
+    turns: number;
+    searches: number;
+    durationMs: number;
+}
+/**
+ * Compose the user-visible memory receipt from applied refinement batches
+ * (never model text): every landed memory edit with its rollback command.
+ * No-op and declined-only outcomes render one quiet line each — a foreground
+ * notice for zero landed edits would be nagging, so callers only queue
+ * follow-ups for applied outcomes.
+ */
+export declare function buildMemoryReceipt(receipt: MemoryReceipt): string;
+/**
+ * Queue the memory receipt follow-up. Same containment as the gate notice:
+ * notification failure only logs. Callers gate on applied outcomes — no-op
+ * and declined-only runs stay audit-only (reviews.jsonl) and never wake
+ * the agent.
+ */
+export declare function notifyMemoryExtraction(ctx: Context, agent: Agent, receipt: MemoryReceipt): void;
 //# sourceMappingURL=notify.d.ts.map

package/lib/notify.js

@@ -40,4 +40,58 @@ export function notifyAutoReview(ctx, agent, result, turnsSinceLastReview) {
             .warn(`auto-review notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
 }
+/**
+ * Compose the user-visible memory receipt from applied refinement batches
+ * (never model text): every landed memory edit with its rollback command.
+ * No-op and declined-only outcomes render one quiet line each — a foreground
+ * notice for zero landed edits would be nagging, so callers only queue
+ * follow-ups for applied outcomes.
+ */
+export function buildMemoryReceipt(receipt) {
+    const seconds = (receipt.durationMs / 1000).toFixed(1);
+    const stats = `${receipt.turns} 轮推理 / ${receipt.searches} 次检索 / ${seconds}s`;
+    if (receipt.outcome === "noop") {
+        return `🧠 记忆提取：本轮无可沉淀的持久事实（no-op，${stats}），未写入任何条目。`;
+    }
+    const results = receipt.results ?? [];
+    const declinedScopes = receipt.declinedScopes ?? [];
+    if (receipt.outcome === "declined" || results.length === 0) {
+        const scopes = declinedScopes.join("、") || "持久化作用域";
+        return `🧠 记忆提取：${scopes}的写入未获批准，已跳过（${stats}），未写入任何条目。`;
+    }
+    const applied = results.flatMap((result) => result.appliedEdits.filter((edit) => edit.applied));
+    const lines = applied.slice(0, 12).map((edit) => `- 记忆「${edit.title ?? edit.id}」（${edit.id}）`);
+    if (applied.length > 12)
+        lines.push(`- …另有 ${applied.length - 12} 条（见 /evolve history）`);
+    const declined = declinedScopes.length > 0 ? `\n另有作用域${declinedScopes.join("、")}未经批准（已跳过）。` : "";
+    const rollbacks = [...new Set(results.map((result) => result.id))].map((id) => `/evolve rollback ${id}`).join("；");
+    return [
+        `🧠 记忆提取：本轮沉淀 ${applied.length} 条记忆（${results.length} 个作用域批次，${stats}）：`,
+        lines.length > 0 ? lines.join("\n") : "（无条目成功应用）",
+        declined,
+        `回看：/evolve recall <关键词>；回滚：${rollbacks}`,
+        "请用一句话简短确认即可，不要调用任何工具。",
+    ]
+        .filter((part) => part !== "")
+        .join("\n");
+}
+/**
+ * Queue the memory receipt follow-up. Same containment as the gate notice:
+ * notification failure only logs. Callers gate on applied outcomes — no-op
+ * and declined-only runs stay audit-only (reviews.jsonl) and never wake
+ * the agent.
+ */
+export function notifyMemoryExtraction(ctx, agent, receipt) {
+    try {
+        agent.followup(createUserMessage({
+            content: [{ type: "text", text: buildMemoryReceipt(receipt) }],
+            source: EVOLVE_MESSAGE_SOURCE,
+        }));
+    }
+    catch (cause) {
+        ctx
+            .logger("continual-evolve")
+            .warn(`memory receipt notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
 //# sourceMappingURL=notify.js.map

package/lib/planner.d.ts

@@ -11,7 +11,7 @@ import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { HarnessState, RefinementProposal, RefinementResult } from "./types.js";
 import { type PrefixCacheOptions } from "./prefix-cache.js";
 import { type TokenUsageTarget } from "./token-usage.js";
-export declare const PLANNER_SYSTEM_PROMPT = "You are the /evolve continual harness subsystem.\n\nYour job is to improve the editable continual harness state. Instead of\nsummarizing the conversation you emit precise Create, Update, or Delete edits\nto reusable state: prompt notes, memories, skills, and subagent specs.\n\nRules:\n- The base system prompt is immutable and MUST NOT be rewritten (never edit id \"base_system_prompt\").\n- Prefer small evidence-backed edits. If no useful edit is justified, return an empty edits array.\n- prompt = narrow behavioral policy addendums; memory = ONE FACT per entry, typed via metadata.memoryType\n-   (user = who the user is; feedback = a pitfall/correction or confirmed approach, MUST carry Why + How to apply;\n-   project = work goal/constraint not derivable from the repo; reference = URL/dashboard/ticket pointer).\n-   Memory rules: one fact per entry (title = one-line retrieval hook, content = the fact alone);\n-   never save what the repo already records (code structure, past fixes, git history, AGENTS.md) or what only\n-   matters to this conversation \u2014 save the non-obvious point instead; before creating, update the existing\n-   entry when one already covers the fact (creates carry metadata {memoryType} or they are rejected);\n-   skill = repeatable procedures (must carry a python reference {type:\"python\", import, callable}\n  and an arguments object); subagent = reusable delegation roles.\n- Skill entries are authored to the DSH skill quality standard\n  (skill-creator, distilled from the official deepseek-harness 11 skills;\n  the full facts are provided in the <skill_quality_standard> block below):\n  only for a REAL trigger scenario grounded in the trajectory\n  (who, in what real task, what signal) \u2014 never invent one to pad the store;\n  never duplicate the official 11 skills or existing entries; content is a\n  SKILL.md document (frontmatter routing with \"use when / do not use when\"\n  description, boundary declaration, prerequisites and exclusions, layered\n  information, verifiable completion criteria). Self-check every proposed\n  skill against the 7 structural features and state the result in its\n  reason field.\n- Repeated multi-step workflows (session start/end routines, recurring\n  wrap-up or handoff procedures) may be proposed as guidance skills:\n  kind=skill, skill_kind=\"guidance\", content = a SKILL.md document (no\n  python reference \u2014 executable skills keep requiring reference +\n  arguments). Only propose with repeated evidence in the trajectory, never\n  for one-off flows. Guidance skills materialize as discoverable SKILL.md\n  files under <skillsRoot>/<kebab-name>/SKILL.md and are always offered to\n  the user for a decision before they land.\n- Local edits are session-scoped; global edits persist across sessions.\n- Gap C2: EVERY edit MUST include a \"blastRadius\" field indicating how broadly\n  the edit applies: \"general\" (cross-project tactical rule, applies everywhere),\n  \"project\" (valid for the current project/repo), or \"session\" (one-off,\n  specific to this session's context). The review gate validates that\n  local-scope edits use \"session\" or \"project\", and global-scope edits use\n  \"general\" or \"project\". When in doubt, prefer narrower blast radius.\n- Ground every edit in evidence: the session trajectory (recent direct user\n  messages) is provided when available; prefer edits backed by it over\n  speculation, and never invent preferences the user did not express.\n- Stale entries (superseded by newer ones, never referenced in recent\n  trajectories, obsolete facts): propose action \"archive\" instead of\n  \"delete\" \u2014 archive hides the entry from injection while keeping its data\n  restorable; it requires only kind + id.\n- Output JSON only, exactly this shape:\n{\n  \"summary\": \"one sentence\",\n  \"rationale\": \"why these edits are justified by the evidence\",\n  \"expectedOutcome\": \"what should improve and how to validate it\",\n  \"edits\": [\n    {\n      \"action\": \"create|update|delete\",\n      \"kind\": \"prompt|memory|skill|subagent\",\n      \"id\": \"stable id for update/delete, optional for create\",\n      \"title\": \"required for create/update except delete\",\n      \"content\": \"required for create/update except delete\",\n      \"path\": \"optional grouping path\",\n      \"reference\": {\"type\":\"python\",\"import\":\"pkg.mod\",\"callable\":\"fn\"} ,\n      \"arguments\": {\"name\": {\"type\":\"string\",\"required\":true,\"description\":\"...\"}},\n      \"skill_kind\": \"executable|guidance (optional; skill kind only \u2014 guidance = SKILL.md document without reference)\",\n      \"metadata\": {},\n      \"reason\": \"why this edit is useful\",\n      \"blastRadius\": \"general|project|session\"\n    }\n  ]\n}";
+export declare const PLANNER_SYSTEM_PROMPT = "You are the /evolve continual harness subsystem.\n\nYour job is to improve the editable continual harness state. Instead of\nsummarizing the conversation you emit precise Create, Update, or Delete edits\nto reusable state: prompt notes, memories, skills, and subagent specs.\n\nRules:\n- The base system prompt is immutable and MUST NOT be rewritten (never edit id \"base_system_prompt\").\n- Prefer small evidence-backed edits. If no useful edit is justified, return an empty edits array.\n- Repeated evidence is mandatory for prompt/skill/subagent proposals: the same\n  pattern must recur at least twice in the trajectory. A single one-off\n  interaction never justifies a prompt, skill, or subagent edit \u2014 return an\n  empty edits array with a rationale instead. Session-scoped local prompt\n  landings converge on /evolve wrapup human review; the turn pipeline must\n  not silently persist one-off abstractions.\n- prompt = narrow behavioral policy addendums; memory = ONE FACT per entry, typed via metadata.memoryType\n-   (user = who the user is; feedback = a pitfall/correction or confirmed approach, MUST carry Why + How to apply;\n-   project = work goal/constraint not derivable from the repo; reference = URL/dashboard/ticket pointer).\n-   Memory rules: one fact per entry (title = one-line retrieval hook, content = the fact alone);\n-   never save what the repo already records (code structure, past fixes, git history, AGENTS.md) or what only\n-   matters to this conversation \u2014 save the non-obvious point instead; before creating, update the existing\n-   entry when one already covers the fact (creates carry metadata {memoryType} or they are rejected);\n-   skill = repeatable procedures (must carry a python reference {type:\"python\", import, callable}\n  and an arguments object); subagent = reusable delegation roles.\n- Skill entries are authored to the DSH skill quality standard\n  (skill-creator, distilled from the official deepseek-harness 11 skills;\n  the full facts are provided in the <skill_quality_standard> block below):\n  only for a REAL trigger scenario grounded in the trajectory\n  (who, in what real task, what signal) \u2014 never invent one to pad the store;\n  never duplicate the official 11 skills or existing entries; content is a\n  SKILL.md document (frontmatter routing with \"use when / do not use when\"\n  description, boundary declaration, prerequisites and exclusions, layered\n  information, verifiable completion criteria). Self-check every proposed\n  skill against the 7 structural features and state the result in its\n  reason field.\n- Repeated multi-step workflows (session start/end routines, recurring\n  wrap-up or handoff procedures) may be proposed as guidance skills:\n  kind=skill, skill_kind=\"guidance\", content = a SKILL.md document (no\n  python reference \u2014 executable skills keep requiring reference +\n  arguments). Only propose with repeated evidence in the trajectory, never\n  for one-off flows. Guidance skills materialize as discoverable SKILL.md\n  files under <skillsRoot>/<kebab-name>/SKILL.md and are always offered to\n  the user for a decision before they land.\n- Local edits are session-scoped; global edits persist across sessions.\n- Gap C2: EVERY edit MUST include a \"blastRadius\" field indicating how broadly\n  the edit applies: \"general\" (cross-project tactical rule, applies everywhere),\n  \"project\" (valid for the current project/repo), or \"session\" (one-off,\n  specific to this session's context). The review gate validates that\n  local-scope edits use \"session\" or \"project\", and global-scope edits use\n  \"general\" or \"project\". When in doubt, prefer narrower blast radius.\n- Ground every edit in evidence: the session trajectory (recent direct user\n  messages) is provided when available; prefer edits backed by it over\n  speculation, and never invent preferences the user did not express.\n- Stale entries (superseded by newer ones, never referenced in recent\n  trajectories, obsolete facts): propose action \"archive\" instead of\n  \"delete\" \u2014 archive hides the entry from injection while keeping its data\n  restorable; it requires only kind + id.\n- Output JSON only, exactly this shape:\n{\n  \"summary\": \"one sentence\",\n  \"rationale\": \"why these edits are justified by the evidence\",\n  \"expectedOutcome\": \"what should improve and how to validate it\",\n  \"edits\": [\n    {\n      \"action\": \"create|update|delete\",\n      \"kind\": \"prompt|memory|skill|subagent\",\n      \"id\": \"stable id for update/delete, optional for create\",\n      \"title\": \"required for create/update except delete\",\n      \"content\": \"required for create/update except delete\",\n      \"path\": \"optional grouping path\",\n      \"reference\": {\"type\":\"python\",\"import\":\"pkg.mod\",\"callable\":\"fn\"} ,\n      \"arguments\": {\"name\": {\"type\":\"string\",\"required\":true,\"description\":\"...\"}},\n      \"skill_kind\": \"executable|guidance (optional; skill kind only \u2014 guidance = SKILL.md document without reference)\",\n      \"metadata\": {},\n      \"reason\": \"why this edit is useful\",\n      \"blastRadius\": \"general|project|session\"\n    }\n  ]\n}";
 export interface PlanOptions {
     agent: Agent;
     state: HarnessState;

package/lib/planner.js

@@ -14,6 +14,12 @@ to reusable state: prompt notes, memories, skills, and subagent specs.
 Rules:
 - The base system prompt is immutable and MUST NOT be rewritten (never edit id "base_system_prompt").
 - Prefer small evidence-backed edits. If no useful edit is justified, return an empty edits array.
+- Repeated evidence is mandatory for prompt/skill/subagent proposals: the same
+  pattern must recur at least twice in the trajectory. A single one-off
+  interaction never justifies a prompt, skill, or subagent edit — return an
+  empty edits array with a rationale instead. Session-scoped local prompt
+  landings converge on /evolve wrapup human review; the turn pipeline must
+  not silently persist one-off abstractions.
 - prompt = narrow behavioral policy addendums; memory = ONE FACT per entry, typed via metadata.memoryType
 -   (user = who the user is; feedback = a pitfall/correction or confirmed approach, MUST carry Why + How to apply;
 -   project = work goal/constraint not derivable from the repo; reference = URL/dashboard/ticket pointer).
@@ -85,7 +91,7 @@ export async function planWithLlm(ctx, options) {
     }
     const scopeInstruction = options.global
         ? "Requested scope: global. Only propose stable cross-session lessons, durable preferences, reusable skills/subagents, or explicitly project-qualified facts."
-        : "Requested scope: local. Prefer session-scoped edits for current task progress; global entries are read-only context — do not propose update/delete for them.";
+        : "Requested scope: local. Propose session-scoped edits only when the trajectory shows repeated evidence (>=2 occurrences of the same pattern); a single one-off interaction returns an empty edits array. Global entries are read-only context — do not propose update/delete for them.";
     // Ground the plan in the caller's session: Route A carries the context
     // as a session-derived message prefix (cache-eligible on providers with
     // prompt caching) and drops the auto-extracted trajectory block; Route B

package/lib/projection.d.ts

@@ -0,0 +1,22 @@
+import type { HarnessState } from "./types.js";
+/** Index file name at the store root. */
+export declare const MEMORY_INDEX_FILE = "MEMORY.md";
+/** Per-fact file directory inside the store. */
+export declare const MEMORY_FACTS_DIR = "memory";
+/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
+export declare function memoryFactFilename(id: string): string;
+/**
+ * Rewrite the whole projection from the post-apply state: index, one file
+ * per memory entry (including archived ones, flagged), and deletion of
+ * files whose ids no longer exist. Deterministic — the same state always
+ * produces the same files.
+ *
+ * @param stateDir The store directory holding harness_state.json.
+ * @param state The freshly persisted state (post-apply, post-rollback).
+ */
+export declare function materializeMemoryProjection(stateDir: string, state: HarnessState): void;
+/** Read back one projected fact file (round-trip helper for tests and tools). */
+export declare function readMemoryFact(factsDir: string, filename: string): string;
+/** True when the store directory carries a projection from a previous apply. */
+export declare function hasMemoryProjection(stateDir: string): boolean;
+//# sourceMappingURL=projection.d.ts.map

package/lib/projection.js

@@ -0,0 +1,112 @@
+/**
+ * Readable Markdown projection (P1): a ZCode-style `MEMORY.md` index plus
+ * one file per memory fact, materialized from the JSON store.
+ *
+ * The JSON harness state stays the single source of truth (versions,
+ * rollback, audit). The projection is a derived, human-trustable view:
+ * it is rewritten from the post-apply state inside the engine, so the
+ * model can never write it directly and rollback/archive stay in sync.
+ *
+ * Layout per store directory:
+ *
+ *   <stateDir>/MEMORY.md          one line per memory entry
+ *   <stateDir>/memory/<file>.md   one fact per file with frontmatter
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isArchived, isMemoryType, MEMORY_TYPE_KEY } from "./types.js";
+/** Index file name at the store root. */
+export const MEMORY_INDEX_FILE = "MEMORY.md";
+/** Per-fact file directory inside the store. */
+export const MEMORY_FACTS_DIR = "memory";
+/** Map a memory id to a flat filename (`:` is legal on disk but hostile to tools). */
+export function memoryFactFilename(id) {
+    return `${id.replace(/:/g, "_")}.md`;
+}
+/**
+ * Rewrite the whole projection from the post-apply state: index, one file
+ * per memory entry (including archived ones, flagged), and deletion of
+ * files whose ids no longer exist. Deterministic — the same state always
+ * produces the same files.
+ *
+ * @param stateDir The store directory holding harness_state.json.
+ * @param state The freshly persisted state (post-apply, post-rollback).
+ */
+export function materializeMemoryProjection(stateDir, state) {
+    const entries = Object.values(state.entries.memory).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const factsDir = join(stateDir, MEMORY_FACTS_DIR);
+    mkdirSync(factsDir, { recursive: true });
+    const expected = new Map();
+    for (const entry of entries) {
+        let filename = memoryFactFilename(entry.id);
+        let suffix = 1;
+        while (expected.has(filename)) {
+            suffix += 1;
+            filename = `${memoryFactFilename(entry.id).replace(/\.md$/, "")}~${suffix}.md`;
+        }
+        expected.set(filename, entry);
+    }
+    for (const [filename, entry] of expected) {
+        writeFileSync(join(factsDir, filename), renderMemoryFact(entry), { encoding: "utf8", mode: 0o600 });
+    }
+    // Sweep facts whose entries vanished (delete); archived entries keep
+    // their file with archived:true frontmatter.
+    let existing;
+    try {
+        existing = readdirSync(factsDir).filter((file) => file.endsWith(".md"));
+    }
+    catch {
+        existing = [];
+    }
+    for (const file of existing) {
+        if (!expected.has(file)) {
+            try {
+                unlinkSync(join(factsDir, file));
+            }
+            catch {
+                // A stale fact file must not break the apply path; the next
+                // materialization retries the sweep.
+            }
+        }
+    }
+    writeFileSync(join(stateDir, MEMORY_INDEX_FILE), renderMemoryIndex([...expected]), { encoding: "utf8", mode: 0o600 });
+}
+/** Read back one projected fact file (round-trip helper for tests and tools). */
+export function readMemoryFact(factsDir, filename) {
+    return readFileSync(join(factsDir, filename), "utf8");
+}
+/** True when the store directory carries a projection from a previous apply. */
+export function hasMemoryProjection(stateDir) {
+    return existsSync(join(stateDir, MEMORY_INDEX_FILE)) && existsSync(join(stateDir, MEMORY_FACTS_DIR));
+}
+function renderMemoryFact(entry) {
+    const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
+    const frontmatter = [
+        "---",
+        `id: ${entry.id}`,
+        `scope: ${entry.scope}`,
+        `kind: memory`,
+        `memoryType: ${type}`,
+        `version: ${entry.version}`,
+        `path: ${entry.path}`,
+        `archived: ${isArchived(entry)}`,
+        `created_at: ${entry.created_at}`,
+        `updated_at: ${entry.updated_at}`,
+        "---",
+    ].join("\n");
+    return `${frontmatter}\n\n# ${entry.title}\n\n${entry.content}\n`;
+}
+function renderMemoryIndex(files) {
+    const lines = ["# Memory Index", "", "Derived from the JSON harness state — do not edit by hand; it is rewritten on every memory apply.", ""];
+    if (files.length === 0) {
+        lines.push("(no memory entries yet)");
+        return `${lines.join("\n")}\n`;
+    }
+    for (const [file, entry] of files) {
+        const type = isMemoryType(entry.metadata[MEMORY_TYPE_KEY]) ? String(entry.metadata[MEMORY_TYPE_KEY]) : "untyped";
+        const archived = isArchived(entry) ? ", archived" : "";
+        lines.push(`- [${entry.scope}:${entry.id}] ${entry.title} (type=${type}, v${entry.version}${archived}) → ${MEMORY_FACTS_DIR}/${file}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+//# sourceMappingURL=projection.js.map