dsh-continual-evolve 0.10.5 → 0.11.0

package/lib/wrapup-proposals.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Wrap-up proposal builders: turn assessed verdicts into deterministic,
+ * evidence-carrying refinement proposals — whole promotes, split promotes,
+ * archive reviews, and valence stamps. Pure logic over the candidate types
+ * in `wrapup-candidates.ts`; the user approves, the engine applies.
+ */
+import type { HarnessState, RefinementKind, RefinementProposal } from "./types.js";
+import { type PromotionPolicy } from "./promotion.js";
+import { type WrapupCandidate, type WrapupItem } from "./wrapup-candidates.js";
+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, 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[], 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. */
+    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 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, policy?: PromotionPolicy, candidateMetadata?: Record<string, unknown>): 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;
+};
+/**
+ * Valence stamp (P1 效价反馈): a keep-verdict item the assessor marked
+ * contradicted gets its negative-valence counter bumped — the entry stays
+ * live but sinks in injection ranking and the next assessment prefers
+ * archiving it. Promotes pass untouched (the human-approved global copy is
+ * the live truth); archives don't need the stamp (they already leave
+ * injection). Undefined when nothing applies.
+ */
+export declare function valenceStampProposal(item: WrapupItem, candidate: WrapupCandidate): RefinementProposal | undefined;
+//# sourceMappingURL=wrapup-proposals.d.ts.map

package/lib/wrapup-proposals.js

@@ -0,0 +1,281 @@
+import { ARCHIVED_AT_KEY, PROMOTED_AT_KEY, PROMOTED_TO_KEY, SOURCE_SEQS_KEY, SOURCE_SESSION_KEY, SOURCED_FROM_KEY, VALENCE_NEGATIVE_KEY } from "./types.js";
+import { MEMORY_TYPE_KEY, isMemoryType } from "./types.js";
+import { DEFAULT_PROMOTION_POLICY, mostSimilarGlobalEntry, projectScopedReason, secretLeakReason } from "./promotion.js";
+import { globalCoverageDetected } from "./wrapup-candidates.js";
+import { candidateKey } from "./wrapup-candidates.js";
+/**
+ * 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, 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 function filterPromotable(items, globalState, candidates, policy = DEFAULT_PROMOTION_POLICY) {
+    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const promotable = [];
+    const skipped = [];
+    for (const item of items) {
+        if (item.verdict !== "promote")
+            continue;
+        const candidate = byKey.get(item.key);
+        if (!candidate) {
+            skipped.push({ key: item.key, reason: "not in the audited candidate list" });
+            continue;
+        }
+        if (candidate.coveredGlobally || globalCoverageDetected(globalState, candidate.kind, candidate)) {
+            skipped.push({ key: item.key, reason: "already covered globally" });
+            continue;
+        }
+        if (candidate.kind === "memory" && !isMemoryType(candidate.metadata[MEMORY_TYPE_KEY])) {
+            skipped.push({
+                key: item.key,
+                reason: `memory has no recall type (metadata.${MEMORY_TYPE_KEY} one of user|feedback|project|reference) — update the local entry to classify it first, then promote`,
+            });
+            continue;
+        }
+        const scoped = projectScopedReason(`${candidate.title}\n${candidate.content}`, policy);
+        if (scoped) {
+            skipped.push({ key: item.key, reason: scoped });
+            continue;
+        }
+        // Metadata screens too: wholePromoteProposals copies candidate.metadata
+        // verbatim into the global entry, so a credential planted in local
+        // metadata must not ride the promotion path into the shared store
+        // (review audit 2026-08-28 B2).
+        const secret = secretLeakReason([candidate.title, candidate.content, JSON.stringify(candidate.metadata ?? {})].join("\n"));
+        if (secret) {
+            skipped.push({ key: item.key, reason: secret });
+            continue;
+        }
+        if (candidate.content.length < policy.minPromoteChars) {
+            skipped.push({
+                key: item.key,
+                reason: `too thin to promote (${candidate.content.length} < ${policy.minPromoteChars} chars) — keep local or merge`,
+            });
+            continue;
+        }
+        const similar = mostSimilarGlobalEntry(globalState, candidate.kind, candidate.title, candidate.content, policy);
+        if (similar) {
+            skipped.push({
+                key: item.key,
+                reason: `near-duplicate of global ${candidate.kind}:${similar.id} "${similar.title}" (overlap ${similar.score.toFixed(2)}) — update that entry instead`,
+            });
+            continue;
+        }
+        promotable.push(item);
+    }
+    return { promotable, skipped };
+}
+/**
+ * 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 function needsArchiveReview(item, candidate) {
+    if (item.verdict !== "archive")
+        return false;
+    if (item.promote)
+        return false;
+    if (candidate.coveredGlobally)
+        return false;
+    const seqs = candidate.metadata[SOURCE_SEQS_KEY];
+    const session = candidate.metadata[SOURCE_SESSION_KEY];
+    return (Array.isArray(seqs) && seqs.length > 0) || (typeof session === "string" && session.length > 0);
+}
+/** Partition archive items into silent vs review-required (see needsArchiveReview). */
+export function splitArchiveGuards(items, candidates) {
+    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
+    const silent = [];
+    const review = [];
+    for (const item of items) {
+        if (item.verdict !== "archive")
+            continue;
+        const candidate = byKey.get(item.key);
+        if (candidate && needsArchiveReview(item, candidate)) {
+            review.push(item);
+        }
+        else {
+            silent.push(item);
+        }
+    }
+    return { silent, review };
+}
+/**
+ * Apply-time guard for a split promotion (archive + promote sub-object):
+ * 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 function splitPromoteBlocked(item, globalState, kind, policy = DEFAULT_PROMOTION_POLICY, candidateMetadata) {
+    if (!item.promote)
+        return "no split payload";
+    if (kind === "memory" && !isMemoryType(candidateMetadata?.[MEMORY_TYPE_KEY])) {
+        return `split promotion needs the source entry classified (metadata.${MEMORY_TYPE_KEY} one of user|feedback|project|reference) — update it first`;
+    }
+    if (globalCoverageDetected(globalState, kind, { id: "", title: item.promote.title })) {
+        return "split promotion duplicates a globally covered topic";
+    }
+    const scoped = projectScopedReason(`${item.promote.title}\n${item.promote.content}`, policy);
+    if (scoped)
+        return `split promotion is ${scoped}`;
+    const secret = secretLeakReason([item.promote.title, item.promote.content].join("\n"));
+    if (secret)
+        return `split promotion blocked: ${secret}`;
+    if (item.promote.content.length < policy.minPromoteChars) {
+        return `split promotion too thin (${item.promote.content.length} < ${policy.minPromoteChars} chars)`;
+    }
+    const similar = mostSimilarGlobalEntry(globalState, kind, item.promote.title, item.promote.content, policy);
+    if (similar) {
+        return `split promotion near-duplicates global ${kind}:${similar.id} "${similar.title}" (overlap ${similar.score.toFixed(2)})`;
+    }
+    return 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 function wholePromoteProposals(item, candidate, sessionId) {
+    const now = new Date().toISOString();
+    return {
+        global: {
+            summary: `wrapup: promote local ${item.key} to the global store`,
+            rationale: item.reason,
+            expectedOutcome: `The entry is now visible to every session via the global store (sourcedFromLocal=${sessionId}:${candidate.id}).`,
+            edits: [
+                {
+                    action: "create",
+                    kind: candidate.kind,
+                    id: candidate.id,
+                    title: candidate.title,
+                    content: candidate.content,
+                    path: candidate.path,
+                    metadata: {
+                        ...candidate.metadata,
+                        [SOURCED_FROM_KEY]: `${sessionId}:${candidate.id}`,
+                        [PROMOTED_AT_KEY]: now,
+                    },
+                },
+            ],
+        },
+        localStamp: (createdId) => ({
+            summary: `wrapup: stamp local ${item.key} as promoted to ${createdId} and retire it from injection`,
+            rationale: item.reason,
+            expectedOutcome: `The local copy keeps its data but stops being injected; the global copy is the live one.`,
+            edits: [
+                {
+                    action: "update",
+                    kind: candidate.kind,
+                    id: candidate.id,
+                    title: candidate.title,
+                    content: candidate.content,
+                    metadata: {
+                        ...candidate.metadata,
+                        [PROMOTED_TO_KEY]: createdId,
+                        [PROMOTED_AT_KEY]: now,
+                        [ARCHIVED_AT_KEY]: now,
+                    },
+                },
+            ],
+        }),
+    };
+}
+/**
+ * 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 function splitPromoteProposals(item, candidate, sessionId) {
+    if (!item.promote)
+        throw new Error("split promote proposals require a promote payload");
+    const now = new Date().toISOString();
+    return {
+        global: {
+            summary: `wrapup: split — promote cleaned part of ${item.key} to the global store`,
+            rationale: item.reason,
+            expectedOutcome: `Only the durable part becomes visible globally; the snapshot half stays archived with the original.`,
+            edits: [
+                {
+                    action: "create",
+                    kind: candidate.kind,
+                    id: candidate.id,
+                    title: item.promote.title,
+                    content: item.promote.content,
+                    path: candidate.path,
+                    metadata: {
+                        ...candidate.metadata,
+                        [SOURCED_FROM_KEY]: `${sessionId}:${candidate.id}`,
+                        [PROMOTED_AT_KEY]: now,
+                    },
+                },
+            ],
+        },
+        localStamp: (createdId) => ({
+            summary: `wrapup: split — archive original ${item.key}, stamped as promoted to ${createdId}`,
+            rationale: item.reason,
+            expectedOutcome: `The original leaves injection (data kept, restorable); the cleaned global copy is the live one.`,
+            edits: [
+                {
+                    action: "update",
+                    kind: candidate.kind,
+                    id: candidate.id,
+                    title: candidate.title,
+                    content: candidate.content,
+                    metadata: {
+                        ...candidate.metadata,
+                        [PROMOTED_TO_KEY]: createdId,
+                        [PROMOTED_AT_KEY]: now,
+                        [ARCHIVED_AT_KEY]: now,
+                    },
+                },
+            ],
+        }),
+    };
+}
+/**
+ * Valence stamp (P1 效价反馈): a keep-verdict item the assessor marked
+ * contradicted gets its negative-valence counter bumped — the entry stays
+ * live but sinks in injection ranking and the next assessment prefers
+ * archiving it. Promotes pass untouched (the human-approved global copy is
+ * the live truth); archives don't need the stamp (they already leave
+ * injection). Undefined when nothing applies.
+ */
+export function valenceStampProposal(item, candidate) {
+    if (item.verdict !== "keep" || !item.contradicted)
+        return undefined;
+    return {
+        summary: `wrapup: stamp contradicted valence on ${item.key} (${candidate.negativeCount + 1})`,
+        rationale: item.reason,
+        expectedOutcome: "The entry's negative-valence counter rises; injection downranks it and the next assessment prefers archiving it.",
+        edits: [
+            {
+                action: "update",
+                kind: candidate.kind,
+                id: candidate.id,
+                title: candidate.title,
+                content: candidate.content,
+                metadata: { ...candidate.metadata, [VALENCE_NEGATIVE_KEY]: candidate.negativeCount + 1 },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=wrapup-proposals.js.map

package/lib/wrapup.d.ts

@@ -17,223 +17,19 @@
  * 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.
+ *
+ * Split (2026-10-03 refactor): the candidate domain lives in
+ * `wrapup-candidates.ts`, the proposal builders in `wrapup-proposals.ts`;
+ * this module owns the bounded LLM assessment call. Moved symbols are
+ * re-exported here so the public surface stays on one module.
  */
 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 TokenUsageTarget } from "./token-usage.js";
 import { type RecordLanguage } from "./record-language.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. */
-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;
-    };
-    /**
-     * Valence signal (P1 效价反馈): the assessor found trajectory or global
-     * evidence contradicting this entry's content (user correction, overridden
-     * fact). Strictly parsed — only an explicit JSON `true` sets it. Keep
-     * verdicts with this flag get a negative-valence stamp; the assessor is
-     * instructed to prefer "archive" for contradicted entries.
-     */
-    contradicted?: boolean;
-}
-/** 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;
-    /**
-     * Negative-valence counter (P1 效价反馈): how many prior assessments marked
-     * this entry contradicted (metadata {@link VALENCE_NEGATIVE_KEY}). Shown to
-     * the assessor so it can prefer "archive"; also demotes the entry in
-     * injection ranking (inject.ts rankEntries).
-     */
-    negativeCount: number;
-}
-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, 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[], 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. */
-    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 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, policy?: PromotionPolicy, candidateMetadata?: Record<string, unknown>): 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;
-};
-/**
- * Valence stamp (P1 效价反馈): a keep-verdict item the assessor marked
- * contradicted gets its negative-valence counter bumped — the entry stays
- * live but sinks in injection ranking and the next assessment prefers
- * archiving it. Promotes pass untouched (the human-approved global copy is
- * the live truth); archives don't need the stamp (they already leave
- * injection). Undefined when nothing applies.
- */
-export declare function valenceStampProposal(item: WrapupItem, candidate: WrapupCandidate): RefinementProposal | undefined;
+import { type WrapupAssessment, type WrapupCandidate } from "./wrapup-candidates.js";
+export * from "./wrapup-candidates.js";
+export * from "./wrapup-proposals.js";
 export declare const WRAPUP_ASSESS_SYSTEM_PROMPT = "You are the /evolve session wrap-up assessor.\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), or CONTRADICTED \u2014\n  newer evidence in the trajectory or the global store disproves or overrides\n  the entry's content (note what contradicts it in the reason).\n- \"keep\" \u2014 still actively useful to this session, or genuinely uncertain.\n\nRules:\n- CONTRADICTED: when evidence contradicts an entry, set \"contradicted\": true\n  on that item (besides the verdict). Entries marked \"(contradicted N\u00D7\n  before)\" were contradicted in earlier assessments \u2014 prefer \"archive\" for\n  them unless you have concrete evidence the content is valid again.\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- Memory entries carry a recall type (user/feedback/project/reference): a\n  memory WITHOUT one cannot be promoted (the guard skips it) \u2014 verdict such\n  entries \"keep\" (or \"archive\" when they qualify) rather than \"promote\".\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\", \"contradicted\": true,\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. */