dsh-continual-evolve 0.1.1 → 0.3.0

package/lib/validate.js

@@ -1,8 +1,27 @@
+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)}`;
     }
@@ -15,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") {
@@ -24,7 +50,30 @@ export function validateEdit(edit, computedId) {
         return `${edit.action} requires title and content`;
     }
     if (edit.action !== "delete" && edit.kind === "skill") {
-        return validateSkillContract(edit);
+        // Guidance skills are SKILL.md documents: no python reference (a
+        // reference on a guidance skill would be an invented contract) and
+        // no arguments contract. Executable skills keep the full contract.
+        if (edit.skill_kind === "guidance") {
+            if (edit.reference !== undefined && Object.keys(edit.reference).length > 0) {
+                return "guidance skill must not carry a python reference (it is a SKILL.md document, not an executable)";
+            }
+            if (edit.arguments !== undefined && Object.keys(edit.arguments).length > 0) {
+                return "guidance skill must not carry an arguments contract (only executable skills declare inputs)";
+            }
+        }
+        else {
+            const contractError = validateSkillContract(edit);
+            if (contractError)
+                return contractError;
+        }
+        // The entry body materializes as a SKILL.md under generated
+        // frontmatter; content-level mechanics (no shadowing `---`, no
+        // escaping resource refs) are code-enforced so a bad body never
+        // reaches the store (mirrors skill-creator's validate-frontmatter).
+        const contentProblems = validateSkillEntryContent(edit.content ?? "");
+        if (contentProblems.length > 0) {
+            return contentProblems.join("; ");
+        }
     }
     return undefined;
 }

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

@@ -0,0 +1,215 @@
+/**
+ * Session wrap-up: the lifecycle exit for a session's local harness entries.
+ *
+ * When a session ends, its local entries default to orphans: a later session
+ * (not on the parentSession chain) never sees them, and nothing promotes or
+ * archives them — the exploration results effectively "die" with the session.
+ * Wrap-up gives those entries a real exit:
+ *
+ * - cross-session-reusable content is classified `promote` and moved into the
+ *   global store (through the human approval gate — global is a governed
+ *   resource, exactly like skill proposals);
+ * - session-specific / superseded / already-covered content is classified
+ *   `archive` (hidden from injection, data stays restorable, rollbackable);
+ * - everything else is kept.
+ *
+ * Division of labor is deliberate: the mechanical audit proposes, the LLM
+ * classifies, the user approves, the code applies deterministically. The
+ * apply-side guard (`filterPromotable`) re-checks global coverage at apply
+ * time so a stale classification can never write a duplicate global entry.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import type { HarnessEntry, HarnessState, RefinementKind, RefinementProposal } from "./types.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. */
+export interface WrapupItem {
+    /** `kind:id` of the candidate this verdict refers to. */
+    key: string;
+    verdict: WrapupVerdict;
+    reason: string;
+    /**
+     * Optional split-promotion payload (verdict "archive" only): the entry is
+     * archived as a whole, but a CLEANED cross-session-reusable part is
+     * offered for promotion — the durable fact distilled out of the mixed
+     * entry, with the ephemeral snapshot left behind in the archive.
+     */
+    promote?: {
+        title: string;
+        content: string;
+    };
+}
+/** A real global entry worth showing the assessor for the same topic. */
+export interface GlobalHint {
+    id: string;
+    title: string;
+}
+/** The model's full classification of a session's local entries. */
+export interface WrapupAssessment {
+    items: WrapupItem[];
+    rationale: string;
+}
+/** A local entry offered for assessment, plus its deterministic audit flags. */
+export interface WrapupCandidate {
+    kind: RefinementKind;
+    id: string;
+    title: string;
+    content: string;
+    path: string;
+    version: number;
+    metadata: Record<string, unknown>;
+    /**
+     * True when the global store already covers this topic by a STRONG
+     * signal: a title that normalizes equal to, or (beyond a length floor)
+     * contains, the candidate's title. Collisions on id alone with a wildly
+     * different title are deliberately NOT coverage — see {@link globalHintsFor}.
+     */
+    coveredGlobally: boolean;
+    /**
+     * Actual global entries that touch the same topic (same id, equal
+     * normalized title, or title overlap). Shown to the assessor so it judges
+     * against real titles instead of a bare boolean; a bare same-id collision
+     * shows up here precisely so the model can tell whether the global copy
+     * 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;
+/**
+ * Deterministic global-coverage check (STRONG signal): the global store
+ * already covers a topic when it holds a title that normalizes equal to, or
+ * (beyond a length floor) contains, the candidate's normalized title.
+ * Archived global entries count too — the topic was already judged
+ * cross-session; a local duplicate would only re-sediment it.
+ *
+ * The bare same-id case is deliberately NOT coverage: ids are slugs derived
+ * from titles, so a real collision is usually caught by the title check
+ * below. A same-id entry with a wildly different title is a weak signal — the
+ * caller routes it through {@link globalHintsFor} for the assessor to judge
+ * against the actual global title (real case: local `memory` "用户产品愿景与
+ * 收入需求（本会话）" vs global `memory` "用户画像（持续更新）").
+ */
+export declare function globalCoverageDetected(globalState: HarnessState, kind: RefinementKind, entry: Pick<HarnessEntry, "id" | "title">): boolean;
+/**
+ * The actual global entries that touch the same topic as a local candidate:
+ * same id (regardless of title — the weak collision signal that is NOT
+ * coverage on its own), equal normalized title, or title overlap. The raw ids
+ * and titles let the assessor judge enrichment against real global content
+ * (does the global copy already hold what the local one adds?) rather than a
+ * 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[];
+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
+ * collapse to "keep", and candidates the model omitted default to "keep" —
+ * a malformed reply can never change an entry's fate by itself.
+ *
+ * Split promotion (verdict "archive" with a `promote` sub-object): the
+ * sub-object is accepted ONLY on archive verdicts and ONLY when both cleaned
+ * title and content are non-empty strings — a dropped/malformed sub-object
+ * silently degrades to a plain archive (the entry is never half-promoted).
+ */
+export declare function parseWrapupAssessment(text: string, candidates: readonly WrapupCandidate[]): WrapupAssessment;
+export interface PromotableSplit {
+    /** Items that may be promoted: classified promote AND not covered globally. */
+    promotable: WrapupItem[];
+    /** Items classified promote but blocked by the deterministic guard, with why. */
+    skipped: {
+        key: string;
+        reason: string;
+    }[];
+}
+/**
+ * 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.
+ */
+export declare function filterPromotable(items: readonly WrapupItem[], globalState: HarnessState, candidates: readonly WrapupCandidate[]): 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. */
+    silent: WrapupItem[];
+    /**
+     * Archives that would bury possibly-reusable content: not covered
+     * globally AND distilled from real user messages (sourceSeqs present).
+     * These MAY NOT archive silently — the command must get user
+     * confirmation first (the symmetric guard to filterPromotable: it stops
+     * over-archiving, not just over-writing).
+     */
+    review: WrapupItem[];
+}
+/**
+ * The symmetric archive guard. `filterPromotable` is one-directional: it
+ * stops the model from WRITING duplicate global entries, but nothing stopped
+ * an unfounded ARCHIVE from hiding content that was actually only local.
+ * Guard criteria: an archive needs user confirmation when it is NOT covered
+ * globally AND the entry carries a real distillation source (sourceSeqs /
+ * sourceSession — i.e. it was distilled from actual user messages, so it
+ * may hold reusable value). Operational/empty entries archive silently as
+ * before. Split archives (archive + promote sub-object) skip this check:
+ * their promotion already crosses a human approval gate, so the archive is
+ * the completion of an approved action, not a silent burial.
+ */
+export declare function needsArchiveReview(item: WrapupItem, candidate: WrapupCandidate): boolean;
+/** Partition archive items into silent vs review-required (see needsArchiveReview). */
+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.
+ */
+export declare function splitPromoteBlocked(item: WrapupItem, globalState: HarnessState, kind: RefinementKind): 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
+ * paths apply IDENTICAL edits (global create + local retirement stamp).
+ *
+ * The local stamp is a factory: the `promotedTo` id is only known after the
+ * global create lands (validation may slugify the id), so the caller applies
+ * the global proposal first and stamps the local copy with the created id.
+ */
+export declare function wholePromoteProposals(item: WrapupItem, candidate: WrapupCandidate, sessionId: string): {
+    global: RefinementProposal;
+    localStamp: (createdId: string) => RefinementProposal;
+};
+/**
+ * Shared proposal builders for a SPLIT promotion (A-form): archive a mixed
+ * local entry but promote ONLY the cleaned durable part the model extracted.
+ * Same usage contract as {@link wholePromoteProposals}: apply the global
+ * create, then stamp the original local entry with the created id.
+ */
+export declare function splitPromoteProposals(item: WrapupItem, candidate: WrapupCandidate, sessionId: string): {
+    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), 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;
+    /** Abort signal forwarded to the model call. */
+    signal?: AbortSignal;
+}
+/**
+ * Ask the model to classify the audited local candidates. Routes through the
+ * calling agent's own provider/model (same model the session runs on), with
+ * reasoning disabled so the output budget goes to the JSON verdicts.
+ */
+export declare function assessLocalEntries(ctx: Context, agent: Agent, candidates: readonly WrapupCandidate[], options?: AssessOptions): Promise<WrapupAssessment>;
+//# sourceMappingURL=wrapup.d.ts.map