dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/wrapup-command.js

@@ -1,243 +0,0 @@
-import { questionServiceOf, requireGlobalApproval } from "./approval.js";
-import { wrapupArchiveCopy } from "./copy.js";
-import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, valenceStampProposal, wholePromoteProposals } from "./wrapup.js";
-import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
-import { normalizeRecordLanguage, resolveRecordLanguage } from "./record-language.js";
-import { recentUserText } from "./inject.js";
-function success(text) {
-    return { kind: "success", text };
-}
-export async function executeWrapupCommand(ctx, engine, invocation, policy = DEFAULT_PROMOTION_POLICY, recordLanguage) {
-    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,
-        tokenUsage: {
-            baseDir: engine.baseDir,
-            sessionId,
-            retain: engine.retention.tokenUsage,
-            onError: (cause) => ctx.logger("continual-evolve").warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
-        },
-        tokenUsagePhase: "wrapup",
-    });
-    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, candidate.metadata);
-        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, recordLanguage);
-        }
-        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 copy = wrapupArchiveCopy(candidate.title, normalizeRecordLanguage(recordLanguage) ??
-                resolveRecordLanguage({ ctx, trajectoryText: recentUserText(invocation.agent) }));
-            const answer = await userQuestions.ask({
-                questions: [
-                    {
-                        id: questionId,
-                        question: copy.question,
-                        options: copy.options,
-                    },
-                ],
-                agent: invocation.agent,
-                signal: invocation.signal,
-            });
-            const selected = answer.answers?.find((entry) => entry.id === questionId)?.selected ?? [];
-            archiveConfirmed = selected.includes("归档") || selected.includes("Archive");
-        }
-        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`);
-        }
-    }
-    // 7. Valence stamps (P1 效价反馈): keep-verdict entries the assessor marked
-    //    contradicted get their negative counter bumped — the entry stays live
-    //    but sinks in injection ranking and the next assessment prefers
-    //    archiving it. Deterministic local action, no approval needed.
-    for (const item of keepItems) {
-        if (!item.contradicted)
-            continue;
-        const candidate = byKey.get(item.key);
-        if (!candidate)
-            continue;
-        const proposal = valenceStampProposal(item, candidate);
-        if (!proposal)
-            continue;
-        const result = engine.apply("local", sessionId, proposal, { scope: "local", baselineState: localState });
-        applied.push(`contradicted stamp ${item.key} → valenceNegative=${candidate.negativeCount + 1} (${result.id})`);
-    }
-    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-proposals.d.ts

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,281 +0,0 @@
-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