dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/usage.js

@@ -1,98 +0,0 @@
-/**
- * Entry usage tracking (gap B1): records how many times each entry has been
- * injected into system prompts. The counts are durable (persisted to disk)
- * and exposed in `evolve_list` and the gate's archive-candidate reporting,
- * so "zero-usage stale entries" can be surfaced for cleanup.
- *
- * Storage: `<baseDir>/evolve/usage.json` — a flat JSON object mapping
- * `kind:id` to an integer count. Reads are tolerant of missing/corrupt files;
- * writes are atomic (tmp + rename).
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-const USAGE_FILE = "usage.json";
-function usagePath(baseDir) {
-    return join(baseDir, "evolve", USAGE_FILE);
-}
-/**
- * Load the usage store from disk; returns an empty store when absent or
- * corrupt. Accepts BOTH on-disk shapes:
- * - legacy (≤0.3.x): a flat `{ "kind:id": count }` map,
- * - v2: `{ version: 2, counts, lastSession }` with per-session dedup.
- */
-export function loadUsage(baseDir) {
-    const path = usagePath(baseDir);
-    try {
-        if (!existsSync(path))
-            return { counts: {}, lastSession: {} };
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-            const record = raw;
-            if (record["version"] === 2 && typeof record["counts"] === "object" && record["counts"] !== null) {
-                return {
-                    counts: record["counts"],
-                    lastSession: typeof record["lastSession"] === "object" && record["lastSession"] !== null
-                        ? record["lastSession"]
-                        : {},
-                };
-            }
-            // Legacy flat map: every key is a count.
-            return { counts: raw, lastSession: {} };
-        }
-        return { counts: {}, lastSession: {} };
-    }
-    catch {
-        return { counts: {}, lastSession: {} };
-    }
-}
-/** Persist the usage store atomically (always the v2 shape). */
-export function saveUsage(baseDir, store) {
-    const dir = join(baseDir, "evolve");
-    mkdirSync(dir, { recursive: true });
-    const path = usagePath(baseDir);
-    const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify({ version: 2, counts: store.counts, lastSession: store.lastSession ?? {} }, null, 2)}\n`, "utf8");
-    renameSync(tmp, path);
-}
-/** Build the usage key for an entry. */
-export function usageKey(kind, id) {
-    return `${kind}:${id}`;
-}
-/**
- * Increment injection counts for the entries that were actually injected.
- * Called after `entriesSectionText` renders the injected block. Keys not
- * present in the store are initialized to 1.
- *
- * Session dedup (2026-08-22): with a sessionId, each key counts AT MOST
- * ONCE per session — the old per-build counting produced meaningless
- * numbers (one entry hit 2311× in a week) and hid the real "how many
- * sessions found this useful" signal that staleness decay needs. Without
- * a sessionId the call degrades to legacy always-increment behavior.
- */
-export function recordInjection(baseDir, injectedKeys, sessionId) {
-    if (injectedKeys.length === 0)
-        return;
-    const store = loadUsage(baseDir);
-    let dirty = false;
-    for (const key of injectedKeys) {
-        if (sessionId !== undefined && store.lastSession?.[key] === sessionId) {
-            continue;
-        }
-        store.counts[key] = (store.counts[key] ?? 0) + 1;
-        if (store.lastSession && sessionId !== undefined) {
-            store.lastSession[key] = sessionId;
-        }
-        dirty = true;
-    }
-    if (dirty) {
-        saveUsage(baseDir, store);
-    }
-}
-/**
- * Get the injection count for a specific entry. Returns 0 when the entry
- * has never been injected (absent from the store).
- */
-export function getUsageCount(store, kind, id) {
-    return store.counts[usageKey(kind, id)] ?? 0;
-}
-//# sourceMappingURL=usage.js.map

package/lib/validate.d.ts

@@ -1,28 +0,0 @@
-/**
- * Code-enforced validation of model-proposed edits. Every rule here exists
- * because the proposal is untrusted input: enum membership, immutability of
- * the base system prompt, required fields per action, and the executable
- * contract skill entries must carry.
- */
-import type { HarnessEntry, HarnessScope, RefinementEdit } from "./types.js";
-export declare const BASE_SYSTEM_PROMPT_ID = "base_system_prompt";
-/**
- * Gap C2: mechanical check that an edit's declared blast radius is coherent
- * with the scope it targets. A session-scoped edit claiming "general" would
- * silently read like a cross-project tactical rule; a global edit claiming
- * "session" would contradict its persistence. Absent blastRadius is NOT
- * rejected (pre-C2 data and manual edits stay compatible) — the planner is
- * instructed to always declare it, and this rule catches what it declares
- * incoherently.
- */
-export declare function validateBlastRadiusScope(scope: HarnessScope, blastRadius: "general" | "project" | "session"): string | undefined;
-/**
- * Returns a human-readable failure reason, or undefined when the edit passes.
- *
- * `before` (the entry the edit targets, absent for creates/unknown ids) lets
- * update rules distinguish "carrying the persisted value" from "changing it"
- * — e.g. a rollback inverse re-carries the stored skill_kind, which must
- * pass, while a genuine executable↔guidance switch must not.
- */
-export declare function validateEdit(edit: RefinementEdit, computedId: string | undefined, scope?: HarnessScope, before?: HarnessEntry): string | undefined;
-//# sourceMappingURL=validate.d.ts.map

package/lib/validate.js

@@ -1,181 +0,0 @@
-import { MEMORY_TYPE_KEY, isMemoryType } from "./types.js";
-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)";
-    }
-    if (scope === "project" && blastRadius === "session") {
-        return "project-scope edit must declare blastRadius \"project\" or \"general\" (\"session\" contradicts cross-session persistence)";
-    }
-    return undefined;
-}
-/**
- * Returns a human-readable failure reason, or undefined when the edit passes.
- *
- * `before` (the entry the edit targets, absent for creates/unknown ids) lets
- * update rules distinguish "carrying the persisted value" from "changing it"
- * — e.g. a rollback inverse re-carries the stored skill_kind, which must
- * pass, while a genuine executable↔guidance switch must not.
- */
-export function validateEdit(edit, computedId, scope, before) {
-    if (!ACTIONS.has(edit.action)) {
-        return `unsupported action ${String(edit.action)}`;
-    }
-    if (!KINDS.has(edit.kind)) {
-        return `unsupported kind ${String(edit.kind)}`;
-    }
-    if (edit.kind === "prompt" && (edit.id === BASE_SYSTEM_PROMPT_ID || computedId === BASE_SYSTEM_PROMPT_ID)) {
-        return "base system prompt is not editable";
-    }
-    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") {
-        return undefined;
-    }
-    // Create needs the full payload (nothing to fall back to). Update may
-    // carry any subset — apply merges with `?? before` — but must carry at
-    // least one change (review audit 2026-08-28 B3/B5: the old blanket
-    // "update requires title and content" broke every partial-update path:
-    // skill archive/demote, consolidate, and the evolve_update tool contract
-    // all construct payload-subset updates).
-    if (edit.action === "create" && (!edit.title || !edit.content)) {
-        return "create requires title and content";
-    }
-    if (edit.action === "update" &&
-        edit.title === undefined &&
-        edit.content === undefined &&
-        edit.path === undefined &&
-        edit.metadata === undefined &&
-        edit.reference === undefined &&
-        edit.arguments === undefined) {
-        return "update carries no changes";
-    }
-    if (edit.kind === "memory" && (edit.action === "create" || edit.action === "update")) {
-        // One-fact typed memories: every memory create declares its recall
-        // type; feedback/project (pitfalls, conventions) additionally carry
-        // the Why + How-to-apply structure so the fact is reusable, not just
-        // recorded. Updates are partial — only carried fields are checked,
-        // resolved against the persisted entry.
-        const carriedType = edit.metadata?.[MEMORY_TYPE_KEY];
-        if (edit.action === "create" && !isMemoryType(carriedType)) {
-            return `create memory requires metadata.${MEMORY_TYPE_KEY} one of user|feedback|project|reference (one fact per entry; update the existing entry instead of adding a duplicate)`;
-        }
-        if (carriedType !== undefined && !isMemoryType(carriedType)) {
-            return `invalid metadata.${MEMORY_TYPE_KEY} ${JSON.stringify(carriedType)} (one of user|feedback|project|reference)`;
-        }
-        const effectiveType = isMemoryType(carriedType)
-            ? carriedType
-            : edit.action === "update"
-                ? before?.metadata?.[MEMORY_TYPE_KEY]
-                : undefined;
-        if ((effectiveType === "feedback" || effectiveType === "project") &&
-            (edit.action === "create" || edit.content !== undefined)) {
-            const content = edit.content ?? "";
-            if (!/why/i.test(content) || !/how/i.test(content)) {
-                return `${effectiveType} memory content must carry a Why and a How to apply section (the fact plus why it matters and how to apply it next time)`;
-            }
-        }
-    }
-    if (edit.action === "create" && edit.kind === "skill") {
-        // 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("; ");
-        }
-    }
-    if (edit.action === "update" && edit.kind === "skill") {
-        // skill_kind is immutable on update: a switch without the matching
-        // contract pair would leave an invalid entry (guidance carrying a
-        // python reference, or an executable with none). Re-carrying the
-        // persisted value (rollback inverses do) passes. Recreate the entry
-        // to change the kind.
-        if (edit.skill_kind !== undefined && before !== undefined && before.skill_kind !== edit.skill_kind) {
-            return "update cannot change skill_kind — delete and recreate the entry instead";
-        }
-        // A carried non-empty reference replaces the contract wholesale, so it
-        // must be a complete executable contract on its own. Empty references
-        // (guidance skills) and absent payloads pass through — apply keeps
-        // the persisted values.
-        if (edit.reference !== undefined && Object.keys(edit.reference).length > 0) {
-            const contractError = validateSkillContract(edit);
-            if (contractError)
-                return contractError;
-        }
-        if (edit.content !== undefined) {
-            const contentProblems = validateSkillEntryContent(edit.content);
-            if (contentProblems.length > 0) {
-                return contentProblems.join("; ");
-            }
-        }
-    }
-    return undefined;
-}
-function validateSkillContract(edit) {
-    if (edit.arguments === undefined) {
-        return "create/update skill requires arguments";
-    }
-    const reference = edit.reference;
-    if (!reference || typeof reference !== "object") {
-        return "create/update skill requires python reference";
-    }
-    const ref = reference;
-    if (ref.type !== "python") {
-        return "create/update skill reference.type must be python";
-    }
-    const hasImport = (typeof ref.import === "string" && ref.import.length > 0) ||
-        (typeof ref.python_import === "string" && ref.python_import.length > 0);
-    const hasCallable = (typeof ref.callable === "string" && ref.callable.length > 0) ||
-        (typeof ref.call_pattern === "string" && ref.call_pattern.length > 0);
-    if (!hasImport) {
-        return "create/update skill requires python import";
-    }
-    if (!hasCallable) {
-        return "create/update skill requires callable or call_pattern";
-    }
-    return undefined;
-}
-//# sourceMappingURL=validate.js.map

package/lib/wrapup-command.d.ts

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

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