dsh-continual-evolve 0.2.0 → 0.4.0

package/lib/usage.js

@@ -0,0 +1,115 @@
+/**
+ * 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. Accepts BOTH on-disk shapes:
+ * - legacy (≤0.3.x): a flat `{ "kind:id": count }` map,
+ * - v2: `{ version: 2, counts, lastSession }` with per-session dedup.
+ */
+export function loadUsage(baseDir) {
+    const path = usagePath(baseDir);
+    try {
+        if (!existsSync(path))
+            return { counts: {}, lastSession: {} };
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+            const record = raw;
+            if (record["version"] === 2 && typeof record["counts"] === "object" && record["counts"] !== null) {
+                return {
+                    counts: record["counts"],
+                    lastSession: typeof record["lastSession"] === "object" && record["lastSession"] !== null
+                        ? record["lastSession"]
+                        : {},
+                };
+            }
+            // Legacy flat map: every key is a count.
+            return { counts: raw, lastSession: {} };
+        }
+        return { counts: {}, lastSession: {} };
+    }
+    catch {
+        return { counts: {}, lastSession: {} };
+    }
+}
+/** Persist the usage store atomically (always the v2 shape). */
+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({ version: 2, counts: store.counts, lastSession: store.lastSession ?? {} }, 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.
+ *
+ * Session dedup (2026-08-22): with a sessionId, each key counts AT MOST
+ * ONCE per session — the old per-build counting produced meaningless
+ * numbers (one entry hit 2311× in a week) and hid the real "how many
+ * sessions found this useful" signal that staleness decay needs. Without
+ * a sessionId the call degrades to legacy always-increment behavior.
+ */
+export function recordInjection(baseDir, injectedKeys, sessionId) {
+    if (injectedKeys.length === 0)
+        return;
+    const store = loadUsage(baseDir);
+    let dirty = false;
+    for (const key of injectedKeys) {
+        if (sessionId !== undefined && store.lastSession?.[key] === sessionId) {
+            continue;
+        }
+        store.counts[key] = (store.counts[key] ?? 0) + 1;
+        if (store.lastSession && sessionId !== undefined) {
+            store.lastSession[key] = sessionId;
+        }
+        dirty = true;
+    }
+    if (dirty) {
+        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,9 @@
+/**
+ * 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";
+import { type PromotionPolicy } from "./promotion.js";
+export declare function executeWrapupCommand(ctx: Context, engine: EvolutionEngine, invocation: CommandInvocation, policy?: PromotionPolicy): Promise<CommandResult>;
+//# sourceMappingURL=wrapup-command.d.ts.map

package/lib/wrapup-command.js

@@ -0,0 +1,212 @@
+import { questionServiceOf, requireGlobalApproval } from "./approval.js";
+import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals } from "./wrapup.js";
+import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
+function success(text) {
+    return { kind: "success", text };
+}
+export async function executeWrapupCommand(ctx, engine, invocation, policy = DEFAULT_PROMOTION_POLICY) {
+    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, policy);
+    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, policy);
+        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

@@ -21,6 +21,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 import type { HarnessEntry, HarnessState, RefinementKind, RefinementProposal } from "./types.js";
+import { type PromotionPolicy } from "./promotion.js";
 /** What should happen to one local entry at session end. */
 export type WrapupVerdict = "promote" | "archive" | "keep";
 /** A classified local entry: `key` matches one audited candidate exactly. */
@@ -74,6 +75,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 +113,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
@@ -133,9 +139,16 @@ export interface PromotableSplit {
  * Apply-time deterministic guard: re-check every promote verdict against the
  * global store right before it lands. The LLM classification may be stale
  * (a gate ran while assessing) or wrong; this ensures a promote never writes
- * a duplicate global entry. Pure and unit-tested.
+ * a duplicate, project-scoped, or too-thin global entry. Pure and unit-tested.
+ *
+ * Guards (2026-08-22 promotion policy):
+ * - audited candidate list + title coverage (pre-existing),
+ * - project-scoped content markers (absolute paths / session ids) — the
+ *   global store is shared across projects and must stay portable,
+ * - thin content below the policy floor (framing outweighs the fact),
+ * - near-duplicate of an existing global entry by content overlap.
  */
-export declare function filterPromotable(items: readonly WrapupItem[], globalState: HarnessState, candidates: readonly WrapupCandidate[]): PromotableSplit;
+export declare function filterPromotable(items: readonly WrapupItem[], globalState: HarnessState, candidates: readonly WrapupCandidate[], policy?: PromotionPolicy): PromotableSplit;
 export interface ArchiveReviewSplit {
     /** Archives that may proceed silently: topic already covered, no real
      * distillation source, or the archive half of an already-approved split. */
@@ -166,11 +179,12 @@ export declare function needsArchiveReview(item: WrapupItem, candidate: WrapupCa
 export declare function splitArchiveGuards(items: readonly WrapupItem[], candidates: readonly WrapupCandidate[]): ArchiveReviewSplit;
 /**
  * Apply-time guard for a split promotion (archive + promote sub-object):
- * the cleaned title must not duplicate a topic already covered globally. A
- * duplicate split is dropped (the entry still archives plain) rather than
- * half-promoting a redundancy.
+ * the cleaned payload must pass the same promotion policy as a whole
+ * promote — no global coverage duplicate, no project-scoped content, not
+ * too thin, no near-duplicate global entry. A blocked split is dropped (the
+ * entry still archives plain) rather than half-promoting a redundancy.
  */
-export declare function splitPromoteBlocked(item: WrapupItem, globalState: HarnessState, kind: RefinementKind): string | undefined;
+export declare function splitPromoteBlocked(item: WrapupItem, globalState: HarnessState, kind: RefinementKind, policy?: PromotionPolicy): string | undefined;
 /**
  * Shared proposal builders for a WHOLE promotion — used by both the
  * `/evolve wrapup` command and the gate's local-fate dimension so the two
@@ -194,7 +208,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;