dsh-continual-evolve 0.2.0 → 0.3.0

package/lib/skillquality.js

@@ -21,7 +21,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { renderSkillMarkdown, skillNameOf } from "./skill.js";
+import { renderSkillMarkdown } from "./skill-render.js";
 /** Skill-name regex the platform enforces (skill-filesystem). */
 const NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const TRUE_WORDS = new Set(["true", "yes", "on", "1"]);
@@ -307,5 +307,5 @@ export function skillResourceRefs(content) {
     return [...refs];
 }
 /** Kebab-case name under which the entry materializes (exported for diagnostics). */
-export { skillNameOf };
+export { skillNameOf } from "./skill-render.js";
 //# sourceMappingURL=skillquality.js.map

package/lib/store.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessScope, HarnessState, RefinementResult } from "./types.js";
+import type { HarnessScope, RefinementResult } from "./types.js";
 export declare const EVOLVE_DIR = "evolve";
 export interface StorePaths {
     /** Directory holding harness_state.json. */
@@ -15,6 +15,4 @@ export declare function snapshotBefore(paths: StorePaths, refinementId: string):
 export declare function appendResult(paths: StorePaths, result: RefinementResult): void;
 /** Read the applied results history; malformed lines are skipped, never fatal. */
 export declare function loadResults(paths: StorePaths): RefinementResult[];
-/** Load a state file into memory, returning empty state when absent. */
-export declare function loadStateFile(paths: StorePaths): HarnessState;
 //# sourceMappingURL=store.d.ts.map

package/lib/store.js

@@ -14,7 +14,6 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { emptyHarnessState } from "./types.js";
 import { stateFilePath } from "./state.js";
 export const EVOLVE_DIR = "evolve";
 export function storePaths(baseDir, scope, sessionId) {
@@ -65,10 +64,4 @@ export function loadResults(paths) {
 function isResult(data) {
     return typeof data === "object" && data !== null && "id" in data && "appliedEdits" in data;
 }
-/** Load a state file into memory, returning empty state when absent. */
-export function loadStateFile(paths) {
-    return existsSync(stateFilePath(paths.stateDir))
-        ? JSON.parse(readFileSync(stateFilePath(paths.stateDir), "utf8"))
-        : emptyHarnessState();
-}
 //# sourceMappingURL=store.js.map

package/lib/tool.js

@@ -2,6 +2,8 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 import { formatHarnessStateForPrompt } from "./render.js";
 import { requireGlobalApproval } from "./approval.js";
 import { entrySourceOf } from "./source.js";
+import { getUsageCount, loadUsage } from "./usage.js";
+import { buildEvolveCompleteEvent, emitEvolveComplete } from "./evolve-event.js";
 const SCOPES = ["local", "global"];
 /** Accept both the boolean tool parameter (`global: true`) and the string form. */
 export function scopeOf(value, fallback) {
@@ -32,7 +34,22 @@ export function registerEvolveTools(ctx, engine, opts) {
         execute: async (args, exec) => {
             const scope = scopeOf(args.scope, "local");
             const state = engine.load(scope, sessionIdOf(exec));
-            return textResult(formatHarnessStateForPrompt(state));
+            const text = formatHarnessStateForPrompt(state);
+            // Append injection usage counts (gap B1).
+            const usage = loadUsage(engine.baseDir);
+            const usageLines = [];
+            for (const kind of Object.keys(state.entries)) {
+                for (const entry of Object.values(state.entries[kind])) {
+                    const count = getUsageCount(usage, kind, entry.id);
+                    if (count > 0) {
+                        usageLines.push(`${kind}:${entry.id} — injected ${count}×`);
+                    }
+                }
+            }
+            if (usageLines.length > 0) {
+                return textResult(`${text}\n\n# Injection Usage\n${usageLines.join("\n")}`);
+            }
+            return textResult(text);
         },
     }));
     ctx.tools.register(defineTool({
@@ -154,6 +171,10 @@ function applyEditsText(engine, scope, sessionId, edits, agent) {
         : { scope });
     const applied = result.appliedEdits.filter((e) => e.applied);
     const failed = result.appliedEdits.filter((e) => !e.applied);
+    // Gap C4: emit structured evolve_complete event for third-party consumers.
+    if (applied.length > 0 && sessionId) {
+        emitEvolveComplete(engine.baseDir, buildEvolveCompleteEvent(result, "manual_tool", sessionId));
+    }
     const lines = [`refinement ${result.id}: ${applied.length} applied, ${failed.length} failed`];
     for (const e of applied) {
         lines.push(`- ${e.action} ${e.kind}:${e.id} (v${(e.after?.version ?? e.before?.version) ?? "?"})`);

package/lib/types.d.ts

@@ -124,6 +124,14 @@ export interface RefinementEdit {
     skill_kind?: SkillKind;
     metadata?: Record<string, unknown>;
     reason?: string;
+    /**
+     * Gap C2: blast-radius annotation — how broadly this edit applies.
+     * Values: "general" (cross-project tactical), "project" (single project),
+     * "session" (one-off session-specific). The review gate checks that
+     * local-scope edits are "session" or "project" and global-scope edits
+     * are "general" or "project".
+     */
+    blastRadius?: "general" | "project" | "session";
 }
 /** The structured output of a planning pass. */
 export interface RefinementProposal {

package/lib/usage.d.ts

@@ -0,0 +1,32 @@
+import type { HarnessState, RefinementKind } from "./types.js";
+export interface UsageStore {
+    /** Injection count per entry key (`kind:id`). */
+    counts: Record<string, number>;
+}
+/** Load the usage store from disk; returns an empty store when absent or corrupt. */
+export declare function loadUsage(baseDir: string): UsageStore;
+/** Persist the usage store atomically. */
+export declare function saveUsage(baseDir: string, store: UsageStore): void;
+/** Build the usage key for an entry. */
+export declare function usageKey(kind: RefinementKind, id: string): string;
+/**
+ * Increment injection counts for the entries that were actually injected.
+ * Called after `entriesSectionText` renders the injected block. Keys not
+ * present in the store are initialized to 1; existing keys are incremented.
+ */
+export declare function recordInjection(baseDir: string, injectedKeys: string[]): void;
+/**
+ * Get the injection count for a specific entry. Returns 0 when the entry
+ * has never been injected (absent from the store).
+ */
+export declare function getUsageCount(store: UsageStore, kind: RefinementKind, id: string): number;
+/**
+ * Find entries with zero injection usage. Returns `{kind, id, title}` for
+ * each entry that has never been injected — prime candidates for archival.
+ */
+export declare function zeroUsageEntries(state: HarnessState, store: UsageStore): {
+    kind: RefinementKind;
+    id: string;
+    title: string;
+}[];
+//# sourceMappingURL=usage.d.ts.map

package/lib/usage.js

@@ -0,0 +1,84 @@
+/**
+ * Entry usage tracking (gap B1): records how many times each entry has been
+ * injected into system prompts. The counts are durable (persisted to disk)
+ * and exposed in `evolve_list` and the gate's archive-candidate reporting,
+ * so "zero-usage stale entries" can be surfaced for cleanup.
+ *
+ * Storage: `<baseDir>/evolve/usage.json` — a flat JSON object mapping
+ * `kind:id` to an integer count. Reads are tolerant of missing/corrupt files;
+ * writes are atomic (tmp + rename).
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const USAGE_FILE = "usage.json";
+function usagePath(baseDir) {
+    return join(baseDir, "evolve", USAGE_FILE);
+}
+/** Load the usage store from disk; returns an empty store when absent or corrupt. */
+export function loadUsage(baseDir) {
+    const path = usagePath(baseDir);
+    try {
+        if (!existsSync(path))
+            return { counts: {} };
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+            return { counts: raw };
+        }
+        return { counts: {} };
+    }
+    catch {
+        return { counts: {} };
+    }
+}
+/** Persist the usage store atomically. */
+export function saveUsage(baseDir, store) {
+    const dir = join(baseDir, "evolve");
+    mkdirSync(dir, { recursive: true });
+    const path = usagePath(baseDir);
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(store.counts, null, 2)}\n`, "utf8");
+    renameSync(tmp, path);
+}
+/** Build the usage key for an entry. */
+export function usageKey(kind, id) {
+    return `${kind}:${id}`;
+}
+/**
+ * Increment injection counts for the entries that were actually injected.
+ * Called after `entriesSectionText` renders the injected block. Keys not
+ * present in the store are initialized to 1; existing keys are incremented.
+ */
+export function recordInjection(baseDir, injectedKeys) {
+    if (injectedKeys.length === 0)
+        return;
+    const store = loadUsage(baseDir);
+    for (const key of injectedKeys) {
+        store.counts[key] = (store.counts[key] ?? 0) + 1;
+    }
+    saveUsage(baseDir, store);
+}
+/**
+ * Get the injection count for a specific entry. Returns 0 when the entry
+ * has never been injected (absent from the store).
+ */
+export function getUsageCount(store, kind, id) {
+    return store.counts[usageKey(kind, id)] ?? 0;
+}
+/**
+ * Find entries with zero injection usage. Returns `{kind, id, title}` for
+ * each entry that has never been injected — prime candidates for archival.
+ */
+export function zeroUsageEntries(state, store) {
+    const results = [];
+    for (const kind of Object.keys(state.entries)) {
+        for (const entry of Object.values(state.entries[kind])) {
+            if (entry.scope !== "local")
+                continue;
+            if (getUsageCount(store, kind, entry.id) === 0) {
+                results.push({ kind, id: entry.id, title: entry.title });
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=usage.js.map

package/lib/validate.d.ts

@@ -4,8 +4,18 @@
  * the base system prompt, required fields per action, and the executable
  * contract skill entries must carry.
  */
-import type { RefinementEdit } from "./types.js";
+import type { HarnessScope, RefinementEdit } from "./types.js";
 export declare const BASE_SYSTEM_PROMPT_ID = "base_system_prompt";
+/**
+ * Gap C2: mechanical check that an edit's declared blast radius is coherent
+ * with the scope it targets. A session-scoped edit claiming "general" would
+ * silently read like a cross-project tactical rule; a global edit claiming
+ * "session" would contradict its persistence. Absent blastRadius is NOT
+ * rejected (pre-C2 data and manual edits stay compatible) — the planner is
+ * instructed to always declare it, and this rule catches what it declares
+ * incoherently.
+ */
+export declare function validateBlastRadiusScope(scope: HarnessScope, blastRadius: "general" | "project" | "session"): string | undefined;
 /** Returns a human-readable failure reason, or undefined when the edit passes. */
-export declare function validateEdit(edit: RefinementEdit, computedId: string | undefined): string | undefined;
+export declare function validateEdit(edit: RefinementEdit, computedId: string | undefined, scope?: HarnessScope): string | undefined;
 //# sourceMappingURL=validate.d.ts.map

package/lib/validate.js

@@ -2,8 +2,26 @@ import { validateSkillEntryContent } from "./skillquality.js";
 const ACTIONS = new Set(["create", "update", "delete", "archive"]);
 const KINDS = new Set(["prompt", "memory", "skill", "subagent"]);
 export const BASE_SYSTEM_PROMPT_ID = "base_system_prompt";
+/**
+ * Gap C2: mechanical check that an edit's declared blast radius is coherent
+ * with the scope it targets. A session-scoped edit claiming "general" would
+ * silently read like a cross-project tactical rule; a global edit claiming
+ * "session" would contradict its persistence. Absent blastRadius is NOT
+ * rejected (pre-C2 data and manual edits stay compatible) — the planner is
+ * instructed to always declare it, and this rule catches what it declares
+ * incoherently.
+ */
+export function validateBlastRadiusScope(scope, blastRadius) {
+    if (scope === "local" && blastRadius === "general") {
+        return "local-scope edit must declare blastRadius \"session\" or \"project\" (\"general\" would claim a cross-project rule)";
+    }
+    if (scope === "global" && blastRadius === "session") {
+        return "global-scope edit must declare blastRadius \"general\" or \"project\" (\"session\" contradicts cross-session persistence)";
+    }
+    return undefined;
+}
 /** Returns a human-readable failure reason, or undefined when the edit passes. */
-export function validateEdit(edit, computedId) {
+export function validateEdit(edit, computedId, scope) {
     if (!ACTIONS.has(edit.action)) {
         return `unsupported action ${String(edit.action)}`;
     }
@@ -16,6 +34,13 @@ export function validateEdit(edit, computedId) {
     if (edit.action !== "create" && !edit.id) {
         return `${edit.action} requires id`;
     }
+    // Gap C2: blast-radius/scope coherence is a mechanical property of the
+    // edit payload itself — checked for every action, not only create/update.
+    if (scope && edit.blastRadius !== undefined) {
+        const blastError = validateBlastRadiusScope(scope, edit.blastRadius);
+        if (blastError)
+            return blastError;
+    }
     // Archive only names an existing entry: no title/content payload, and the
     // base system prompt stays immutable under every action.
     if (edit.action === "archive") {

package/lib/wrapup-command.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `/evolve wrapup` subcommand handler. Extracted from command.ts (P2-2).
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
+import type { EvolutionEngine } from "./service.js";
+export declare function executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation): Promise<CommandResult>;
+//# sourceMappingURL=wrapup-command.d.ts.map

package/lib/wrapup-command.js

@@ -0,0 +1,211 @@
+import { questionServiceOf, requireGlobalApproval } from "./approval.js";
+import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals } from "./wrapup.js";
+function success(text) {
+    return { kind: "success", text };
+}
+export async function executeWrapupCommand(ctx, engine, invocation) {
+    const sessionId = invocation.agent.id;
+    const localState = engine.load("local", sessionId);
+    const globalState = engine.load("global", undefined);
+    const candidates = listLocalCandidates(localState, globalState, engine.baseDir);
+    if (candidates.length === 0) {
+        return success(`(nothing to wrap up: ${sessionId}'s local store has no active, un-promoted entries — use /evolve list to inspect it)`);
+    }
+    // 1. Classify: the model judges each audited candidate's fate.
+    const assessment = await assessLocalEntries(ctx, invocation.agent, candidates, { signal: invocation.signal });
+    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    // 2. Partition by action. Deterministic guards re-check the LIVE global
+    //    store right before anything lands (state may have changed mid-call).
+    const { promotable, skipped } = filterPromotable(assessment.items, globalState, candidates);
+    const promoteItems = promotable.filter((item) => item.verdict === "promote");
+    const archiveItems = assessment.items.filter((item) => item.verdict === "archive");
+    // Split promotion (A-form): archive a mixed entry but promote ONLY the
+    // cleaned durable part the model extracted. Guarded the same way as whole
+    // promotes — a split that would duplicate a globally covered topic is
+    // dropped and the entry archives plain.
+    const splitItems = [];
+    const splitSkipped = [];
+    for (const item of archiveItems) {
+        if (!item.promote)
+            continue;
+        const candidate = byKey.get(item.key);
+        if (!candidate) {
+            splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
+            continue;
+        }
+        const blocked = splitPromoteBlocked(item, globalState, candidate.kind);
+        if (blocked) {
+            splitSkipped.push({ key: item.key, reason: blocked });
+            continue;
+        }
+        splitItems.push({ item, candidate });
+    }
+    // Plain archives (no split payload): the symmetric guard — an archive that
+    // is NOT globally covered AND was distilled from real user messages must
+    // not proceed silently.
+    const plainArchives = archiveItems.filter((item) => !item.promote);
+    const { silent: silentArchives, review: reviewArchives } = splitArchiveGuards(plainArchives, candidates);
+    const keepItems = assessment.items.filter((item) => item.verdict === "keep");
+    // 3. Report the assessment before touching anything.
+    const lines = [
+        `wrapup assessment (${sessionId}): ${candidates.length} candidates${candidates.some((c) => c.coveredGlobally) ? `, ${candidates.filter((c) => c.coveredGlobally).length} covered globally` : ""}`,
+        `${assessment.rationale}`,
+    ];
+    for (const [heading, items] of [
+        ["PROMOTE (to global)", promoteItems],
+        ["SPLIT (archive + promote durable part)", splitItems.map((split) => split.item)],
+        ["ARCHIVE", silentArchives],
+        ["ARCHIVE (needs review)", reviewArchives],
+        ["KEEP", keepItems],
+    ]) {
+        lines.push(`${heading}: ${items.length}`);
+        for (const item of items) {
+            const candidate = byKey.get(item.key);
+            const title = candidate ? candidate.title : item.key;
+            const splitNote = item.promote ? ` → 拆出提升「${item.promote.title}」` : "";
+            lines.push(`- ${item.key} "${title}"${splitNote} — ${item.reason}`);
+        }
+    }
+    for (const skip of skipped) {
+        lines.push(`- promote skipped: ${skip.key} — ${skip.reason}`);
+    }
+    for (const skip of splitSkipped) {
+        lines.push(`- split skipped: ${skip.key} — ${skip.reason}`);
+    }
+    lines.push("");
+    const applied = [];
+    // 4. Global writes: governed resource — ONE human approval gate covers
+    //    every create (whole promotes AND split promotions). On approval:
+    //    - whole promote → create global copy + stamp local promotedTo+archivedAt;
+    //    - split → create the cleaned durable part + archive the original with
+    //      promotedTo. On rejection: whole promotes are not written, and each
+    //      split's original STILL archives plain (its snapshot half deserves
+    //      the archive; the durable half is reported for manual handling).
+    const wholeCreates = promoteItems.map((item) => ({ item, candidate: byKey.get(item.key) }));
+    const splitCreates = splitItems;
+    const allCreates = new Set([...wholeCreates.map((c) => c.item.key), ...splitCreates.map((c) => c.item.key)]);
+    if (allCreates.size > 0) {
+        const what = `wrapup 将写入跨会话 global store（共 ${allCreates.size} 条：${promoteItems.length} 条整条提升 + ${splitItems.length} 条拆解提升）：\n${[
+            ...promoteItems.map((item) => `- 整条提升 ${item.key} "${byKey.get(item.key)?.title ?? item.key}"`),
+            ...splitItems.map((split) => `- 拆解提升 ${split.item.key} → 清洗「${split.item.promote?.title}」（原条目随之归档）`),
+        ].join("\n")}`;
+        let promoteAllowed = true;
+        try {
+            await requireGlobalApproval(ctx, invocation.agent, invocation.signal, what);
+        }
+        catch (cause) {
+            promoteAllowed = false;
+            const message = `global 写入未批准 — 整条提升与拆解提升均未写入 (${cause instanceof Error ? cause.message : String(cause)})`;
+            applied.push(message);
+            lines.push(message);
+        }
+        if (promoteAllowed) {
+            // Whole promotes: create global entry, retire the local copy.
+            // Shared proposal builders keep the wrap-up command and the gate's
+            // local-fate dimension writing IDENTICAL edits.
+            for (const { item, candidate } of wholeCreates) {
+                if (!candidate)
+                    continue;
+                const proposals = wholePromoteProposals(item, candidate, sessionId);
+                const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+                const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+                const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                    scope: "local",
+                    baselineState: localState,
+                });
+                applied.push(`promoted ${item.key} → global:${createdId} (${globalResult.id}; local stamped ${localResult.id})`);
+            }
+            // Split promotions: create the cleaned durable part, retire the
+            // original local entry (its snapshot half is archived along).
+            for (const { item, candidate } of splitCreates) {
+                if (!item.promote)
+                    continue;
+                const proposals = splitPromoteProposals(item, candidate, sessionId);
+                const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
+                const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
+                const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
+                    scope: "local",
+                    baselineState: localState,
+                });
+                applied.push(`split ${item.key}: promoted cleaned part → global:${createdId} (${globalResult.id}); original archived (${localResult.id})`);
+            }
+        }
+        else {
+            // Rejected: whole promotes stay un-written; each split's original
+            // still archives plain (reported, data restorable).
+            for (const { item, candidate } of splitCreates) {
+                if (!candidate)
+                    continue;
+                const result = engine.apply("local", sessionId, {
+                    summary: `wrapup: split promotion not approved — archive original ${item.key} plain`,
+                    rationale: item.reason,
+                    expectedOutcome: `The original leaves injection; the cleaned part was NOT written (reported for manual handling).`,
+                    edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
+                }, { scope: "local", baselineState: localState });
+                applied.push(`split ${item.key}: promotion not approved — original archived plain (${result.id})`);
+            }
+        }
+    }
+    // 5. Silent archives: deterministic local action (hidden from injection,
+    //    data kept restorable) — covered topics and operational entries need no
+    //    confirmation, matching the original behavior.
+    for (const item of silentArchives) {
+        const candidate = byKey.get(item.key);
+        if (!candidate)
+            continue;
+        const result = engine.apply("local", sessionId, {
+            summary: `wrapup: archive local ${item.key} — ${item.reason}`,
+            rationale: item.reason,
+            expectedOutcome: `The entry stops being injected but stays restorable.`,
+            edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
+        }, { scope: "local", baselineState: localState });
+        applied.push(`archived ${item.key} (${result.id})`);
+    }
+    // 6. Review archives (symmetric guard): not covered globally + distilled
+    //    from real user messages — the user decides before this content is
+    //    hidden from future sessions. No question service → conservative keep.
+    const userQuestions = questionServiceOf(ctx);
+    for (const item of reviewArchives) {
+        const candidate = byKey.get(item.key);
+        if (!candidate)
+            continue;
+        if (!userQuestions) {
+            applied.push(`kept ${item.key} — archive pending user confirmation (no question service)`);
+            continue;
+        }
+        const questionId = "evolve-wrapup-archive-review";
+        let archiveConfirmed = false;
+        try {
+            const answer = await userQuestions.ask({
+                questions: [
+                    {
+                        id: questionId,
+                        question: `wrapup：条目「${candidate.title}」未被全局覆盖且源自真实对话，直接归档会隐藏它（数据保留、可恢复）。确认归档？`,
+                        options: [{ label: "归档" }, { label: "保留" }],
+                    },
+                ],
+                agent: invocation.agent,
+                signal: invocation.signal,
+            });
+            archiveConfirmed = answer.answers?.find((entry) => entry.id === questionId)?.selected?.includes("归档") ?? false;
+        }
+        catch {
+            archiveConfirmed = false;
+        }
+        if (archiveConfirmed) {
+            const result = engine.apply("local", sessionId, {
+                summary: `wrapup: archive local ${item.key} (user-confirmed) — ${item.reason}`,
+                rationale: item.reason,
+                expectedOutcome: `The entry stops being injected but stays restorable.`,
+                edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
+            }, { scope: "local", baselineState: localState });
+            applied.push(`archived ${item.key} (user-confirmed, ${result.id})`);
+        }
+        else {
+            applied.push(`kept ${item.key} — user declined the archive`);
+        }
+    }
+    lines.push(...(applied.length > 0 ? applied : ["(no changes applied — all entries kept)"]));
+    return success(lines.join("\n"));
+}
+//# sourceMappingURL=wrapup-command.js.map

package/lib/wrapup.d.ts

@@ -74,6 +74,18 @@ export interface WrapupCandidate {
      * really covers the local content.
      */
     globalHints: GlobalHint[];
+    /**
+     * Injection usage count (gap B1): how many times this entry was included
+     * in a system-prompt assembly. Zero means the entry was never used — a
+     * strong staleness signal the assessor can weigh.
+     */
+    injectionCount: number;
+    /**
+     * Staleness flag (gap B2): true when the entry has both zero injection
+     * usage AND a recency score below the staleness threshold (old + unused).
+     * The assessor is instructed to prefer "archive" for stale entries.
+     */
+    stale: boolean;
 }
 export declare function candidateKey(kind: RefinementKind, id: string): string;
 /**
@@ -100,14 +112,7 @@ export declare function globalCoverageDetected(globalState: HarnessState, kind:
  * bare boolean. Bounded: a handful of best matches, never the whole store.
  */
 export declare function globalHintsFor(globalState: HarnessState, kind: RefinementKind, entry: Pick<HarnessEntry, "id" | "title">): GlobalHint[];
-/**
- * The auditable local candidates of a session: every non-archived local
- * entry that has not already been promoted (a promoted entry's lifecycle is
- * finished — the global copy is the live one). Each carries its
- * `coveredGlobally` flag so the assessor never wastes a promote on a topic
- * the global store already owns.
- */
-export declare function listLocalCandidates(state: HarnessState, globalState: HarnessState): WrapupCandidate[];
+export declare function listLocalCandidates(state: HarnessState, globalState: HarnessState, baseDir?: string): WrapupCandidate[];
 /**
  * Parse and validate the model's assessment JSON. Defense is mechanical:
  * keys outside the candidate list are dropped, verdicts outside the enum
@@ -194,7 +199,7 @@ export declare function splitPromoteProposals(item: WrapupItem, candidate: Wrapu
     global: RefinementProposal;
     localStamp: (createdId: string) => RefinementProposal;
 };
-export declare const WRAPUP_ASSESS_SYSTEM_PROMPT = "You are the /evolve session wrap-up assessor.\n\nA session is ending and its local harness entries need a fate. Classify each\nlisted entry exactly once:\n\n- \"promote\" \u2014 the content is a stable, durable, CROSS-SESSION reusable lesson:\n  a durable user preference, a project-level fact or convention, a reusable\n  procedure or skill. Future sessions would benefit from seeing it.\n- \"archive\" \u2014 the content is session-specific task progress, one-off noise,\n  superseded or obsolete, or already covered by the global store (note\n  \"covered globally\" in the reason).\n- \"keep\" \u2014 still actively useful to this session, or genuinely uncertain.\n\nRules:\n- When an entry is marked \"covered globally\" in the listing, prefer \"archive\"\n  or \"keep\" over \"promote\" \u2014 promoting a duplicate gains nothing.\n- Do not promote local task state, work-in-progress notes, or content tied to\n  one session's ephemeral details.\n- Skills: only \"promote\" a skill entry that is a genuinely reusable procedure\n  meeting the DSH skill quality standard; one-off workflows are \"archive\" or\n  \"keep\".\n- SPLIT PROMOTION: when an entry mixes a stable, cross-session-reusable part\n  WITH session-specific snapshot details, do NOT promote it whole. Instead\n  give verdict \"archive\" WITH a \"promote\" sub-object holding a CLEANED\n  version of only the durable part (a stable title + the persistent facts,\n  stripped of dates/states/one-off figures). Ephemeral snapshot content stays\n  out of the sub-object \u2014 it is left behind in the archive. A sub-object is\n  only meaningful on \"archive\" verdicts.\n\nReturn JSON only:\n{\n  \"rationale\": \"one or two sentences\",\n  \"items\": [\n    {\"key\": \"memory:foo\", \"verdict\": \"promote|archive|keep\", \"reason\": \"why\"},\n    {\"key\": \"memory:bar\", \"verdict\": \"archive\", \"reason\": \"why\",\n     \"promote\": {\"title\": \"cleaned stable title\", \"content\": \"cleaned durable part only\"}}\n  ]\n}\nOnly keys from the provided list are allowed; any entry you omit defaults to \"keep\".";
+export declare const WRAPUP_ASSESS_SYSTEM_PROMPT = "You are the /evolve session wrap-up assessor.\n\nA session is ending and its local harness entries need a fate. Classify each\nlisted entry exactly once:\n\n- \"promote\" \u2014 the content is a stable, durable, CROSS-SESSION reusable lesson:\n  a durable user preference, a project-level fact or convention, a reusable\n  procedure or skill. Future sessions would benefit from seeing it.\n- \"archive\" \u2014 the content is session-specific task progress, one-off noise,\n  superseded or obsolete, or already covered by the global store (note\n  \"covered globally\" in the reason), or stale (old + never injected \u2014 note\n  \"stale (injectionCount=0, recency low)\" in the reason).\n- \"keep\" \u2014 still actively useful to this session, or genuinely uncertain.\n\nRules:\n- When an entry is marked \"covered globally\" in the listing, prefer \"archive\"\n  or \"keep\" over \"promote\" \u2014 promoting a duplicate gains nothing.\n- When an entry is marked \"stale\" (injectionCount=0 and low recency), prefer\n  \"archive\" \u2014 the entry has never been used and is old, so it is unlikely to\n  be needed again. Only \"keep\" if the content is clearly valuable despite low\n  usage (e.g. a safety policy that rarely triggers but is critical).\n- Do not promote local task state, work-in-progress notes, or content tied to\n  one session's ephemeral details.\n- Skills: only \"promote\" a skill entry that is a genuinely reusable procedure\n  meeting the DSH skill quality standard; one-off workflows are \"archive\" or\n  \"keep\".\n- SPLIT PROMOTION: when an entry mixes a stable, cross-session-reusable part\n  WITH session-specific snapshot details, do NOT promote it whole. Instead\n  give verdict \"archive\" WITH a \"promote\" sub-object holding a CLEANED\n  version of only the durable part (a stable title + the persistent facts,\n  stripped of dates/states/one-off figures). Ephemeral snapshot content stays\n  out of the sub-object \u2014 it is left behind in the archive. A sub-object is\n  only meaningful on \"archive\" verdicts.\n\nReturn JSON only:\n{\n  \"rationale\": \"one or two sentences\",\n  \"items\": [\n    {\"key\": \"memory:foo\", \"verdict\": \"promote|archive|keep\", \"reason\": \"why\"},\n    {\"key\": \"memory:bar\", \"verdict\": \"archive\", \"reason\": \"why\",\n     \"promote\": {\"title\": \"cleaned stable title\", \"content\": \"cleaned durable part only\"}}\n  ]\n}\nOnly keys from the provided list are allowed; any entry you omit defaults to \"keep\".";
 export interface AssessOptions {
     /** Output token budget for the assessment call. */
     maxOutputTokens?: number;