dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/command.js

@@ -1,568 +0,0 @@
-import { ARCHIVED_AT_KEY } from "./types.js";
-import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
-import { planWithLlm } from "./planner.js";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { requireGlobalApproval } from "./approval.js";
-import { saveHarnessState } from "./state.js";
-import { appendResult, pruneJsonlFile, storePaths } from "./store.js";
-import { DEFAULT_REFINEMENTS_RETAIN } from "./store.js";
-import { entrySourceOf } from "./source.js";
-import { filterLogBySession, formatLogLine, pluginLogFilePath } from "./logfile.js";
-import { collectFailureSummary, formatFailureSummary } from "./failures.js";
-import { executeGoalCommand } from "./goal-command.js";
-import { executeMountCommand, executeUnmountCommand } from "./mount-command.js";
-import { executeBenchmarkCommand } from "./benchmark-command.js";
-import { executeWrapupCommand } from "./wrapup-command.js";
-import { projectKeyOf } from "./project.js";
-import { loadUsage, getUsageCount } from "./usage.js";
-import { loadGateRuntime, saveGateRuntime } from "./runtime.js";
-import { planConsolidation } from "./consolidate.js";
-import { loadTokenUsage, renderTokenUsageReport } from "./token-usage.js";
-const USAGE_COMMON = `Usage:
-  /evolve                  show this help and the current local store
-  /evolve list [project|global]    list entries (default local staging; "project" = this project's cross-session store, "global" = cross-project store)
-  /evolve history [global] show applied refinements (rollback ids)
-  /evolve rollback <id> [global]  deterministically revert a refinement
-  /evolve plan [msg]       run the LLM planner against the current store
-  /evolve wrapup           assess this session's local entries: promote reusable ones
-                           to the global store (approval required), archive one-offs
-  /evolve archive <id> [global]   hide an entry from injection (data kept, restorable)
-  /evolve unarchive <id> [global] restore an archived entry
-  /evolve pause | resume   pause/resume the automatic Memory Agent (manual tools and commands keep working)
-  /evolve status           automatic Memory Agent state plus store entry counts
-  /evolve help all         every subcommand, including the advanced ones below`;
-const USAGE_ADVANCED = `Advanced:
-  /evolve consolidate [apply] [merge]
-                                   report (or apply) a batch archive of conflict-hinted
-                                   and stale zero-use global entries; "merge" folds
-                                   near-duplicate content into the surviving original
-  /evolve failures               aggregated failure counts (gate + benchmark, by class)
-  /evolve log [tail N]            show the recent plugin log (default 50 lines)
-  /evolve export [global] <path>  backup a store to a JSON file
-  /evolve import [global] <path>  restore a store from an export file
-  /evolve mount <skillId>    hot-mount a skill entry as a live cordis plugin
-  /evolve mount list         list hot-mounted plugins
-  /evolve unmount <id>       remove a hot-mounted plugin
-  /evolve goal               show the evolution goal (round-driven auto-review)
-  /evolve goal <objective>   create/update the evolution goal
-  /evolve goal done          complete the evolution goal
-  /evolve benchmark ...      case lifecycle, runs, acceptance
-  /evolve usage              injection counts + exact direct-call token usage (benchmark subagents excluded)`;
-/** Default help (`/evolve`, `/evolve help`): the commands worth knowing. */
-const USAGE = USAGE_COMMON;
-export function registerEvolveCommand(ctx, engine, opts, runtime) {
-    ctx.commands.register({
-        name: "evolve",
-        description: "自进化：检查并演进 harness 状态（记忆/技能/提示词/子代理） | Inspect and evolve the continual harness state (memories, skills, prompt notes, subagent specs)",
-        input: { hint: "[list [global] | history [global] | rollback <id> [global] | plan [msg] | help all]" },
-        handler: (invocation) => executeEvolveCommand(ctx, engine, invocation, opts, runtime),
-    });
-}
-function scopeArg(tokens) {
-    if (tokens[0] === "global") {
-        return { scope: "global", rest: tokens.slice(1) };
-    }
-    if (tokens[0] === "project") {
-        return { scope: "project", rest: tokens.slice(1) };
-    }
-    return { scope: "local", rest: tokens };
-}
-/**
- * The store id a scope reads/writes from the human command: live session id
- * for local, derived project key for project, undefined for global. Throws
- * for project when the session cwd is unavailable.
- */
-function storeIdForCommand(scope, invocation) {
-    if (scope === "local") {
-        return invocation.agent.id;
-    }
-    if (scope === "project") {
-        const key = projectKeyOf(invocation.agent);
-        if (!key) {
-            throw new Error("project scope needs the session cwd (unavailable here) — use local or global instead");
-        }
-        return key;
-    }
-    return undefined;
-}
-/**
- * Tokenize a command's raw input with shell-like quoting:
- * - a `#` outside quotes starts a comment (rest of the line is dropped);
- * - whitespace separates tokens;
- * - double or single quotes group words into one token and are stripped.
- *
- * This lets users paste help-text examples verbatim, e.g.
- * `/evolve benchmark add-case <bid> "<title>" "<statement>" "<rubric>"`.
- */
-export function tokenizeEvolveInput(rawInput) {
-    const tokens = [];
-    let current = "";
-    let quote = null;
-    for (const char of rawInput) {
-        if (quote !== null) {
-            if (char === quote) {
-                quote = null;
-            }
-            else {
-                current += char;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = char;
-            continue;
-        }
-        if (char === "#") {
-            break; // rest of the line is a comment
-        }
-        if (/\s/.test(char)) {
-            if (current.length > 0) {
-                tokens.push(current);
-                current = "";
-            }
-            continue;
-        }
-        current += char;
-    }
-    if (current.length > 0) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-/** Accept both `<id>` (help-text placeholder form) and bare `id`. */
-export function stripAngleBrackets(value) {
-    return value.replace(/^<|>$/g, "");
-}
-/**
- * Locate an entry by id across every kind of a store. Ids are only unique
- * within a kind, so the lookup scans all four and returns the first match
- * (kind + entry) or undefined. Used by archive/unarchive, which take a bare
- * id from the user.
- */
-export function findEntryById(state, id) {
-    for (const kind of Object.keys(state.entries)) {
-        const entry = state.entries[kind][id];
-        if (entry) {
-            return [kind, entry];
-        }
-    }
-    return undefined;
-}
-async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
-    const tokens = tokenizeEvolveInput(invocation.rawInput);
-    const sub = tokens[0] ?? "";
-    const rest = tokens.slice(1);
-    const sessionId = invocation.agent.id;
-    try {
-        switch (sub) {
-            case "":
-            case "help":
-                // Layered help (2026-10-01): the default listing stays short;
-                // `help all` expands the advanced half.
-                return success(`${rest[0] === "all" ? `${USAGE_COMMON}\n\n${USAGE_ADVANCED}` : USAGE_COMMON}\n\n${formatHarnessStateForPrompt(engine.load("local", sessionId))}`);
-            case "list": {
-                const { scope } = scopeArg(rest);
-                return success(formatHarnessStateForPrompt(engine.load(scope, storeIdForCommand(scope, invocation))));
-            }
-            case "history": {
-                const { scope } = scopeArg(rest);
-                const history = engine.history(scope, storeIdForCommand(scope, invocation));
-                return success(historyForPrompt(history) || "(no refinements yet)");
-            }
-            case "rollback": {
-                const { scope, rest: after } = scopeArg(rest);
-                const id = stripAngleBrackets(after[0] ?? "");
-                if (!id) {
-                    return error(`rollback requires a refinement id.\n${USAGE}`);
-                }
-                const result = engine.rollback(scope, storeIdForCommand(scope, invocation), id);
-                return success(renderResult(result));
-            }
-            case "archive":
-            case "unarchive": {
-                const { scope, rest: after } = scopeArg(rest);
-                const id = stripAngleBrackets(after[0] ?? "");
-                if (!id) {
-                    return error(`${sub} requires an entry id.\n${USAGE}`);
-                }
-                const state = engine.load(scope, storeIdForCommand(scope, invocation));
-                const found = findEntryById(state, id);
-                if (!found) {
-                    return error(`entry ${id} not found in the ${scope} store`);
-                }
-                const [kind, entry] = found;
-                const metadata = { ...entry.metadata };
-                if (sub === "archive") {
-                    metadata[ARCHIVED_AT_KEY] = new Date().toISOString();
-                }
-                else {
-                    delete metadata[ARCHIVED_AT_KEY];
-                }
-                const archived = sub === "archive";
-                const result = engine.apply(scope, storeIdForCommand(scope, invocation), {
-                    summary: `${archived ? "Archive" : "Unarchive"} entry ${kind}:${id}`,
-                    rationale: "Human-invoked archive/unarchive via the /evolve command.",
-                    expectedOutcome: `Entry ${archived ? "is hidden from injection (data kept, restorable)" : "is injected again"}.`,
-                    edits: [{ action: "update", kind, id, title: entry.title, content: entry.content, metadata }],
-                }, { scope });
-                return success(renderResult(result));
-            }
-            case "consolidate": {
-                // R3: deterministic global-store hygiene. Report by default;
-                // `apply` re-scans fresh state and lands the whole batch as ONE
-                // refinement (single snapshot + audit record, fully rollback-able).
-                // `merge` (P1 反膨胀) additionally merges conflict-pair content
-                // into the surviving original instead of only archiving.
-                const apply = rest[0] === "apply";
-                const merge = rest.includes("merge");
-                const state = engine.load("global", undefined);
-                const { candidates, edits } = planConsolidation(state, loadUsage(engine.baseDir), Date.now(), { mergeDuplicates: merge });
-                if (candidates.length === 0) {
-                    return success("global store is already consolidated — no conflict-hinted or stale zero-use entries.");
-                }
-                const mergeCount = merge ? candidates.filter((candidate) => candidate.mergeInto).length : 0;
-                const report = candidates
-                    .map((candidate, index) => {
-                    const mergeNote = candidate.mergeInto && merge ? ` → 内容并入 ${candidate.mergeInto.id}` : "";
-                    return `${index + 1}. [${candidate.kind}:${candidate.id}] ${candidate.title}${mergeNote}\n   ${candidate.reason}`;
-                })
-                    .join("\n");
-                if (!apply) {
-                    return success(`consolidation plan — ${candidates.length} archive candidate(s):\n${report}\n(run "/evolve consolidate apply" to archive all of them in one refinement; add "merge" to fold near-duplicate content into the survivors)`);
-                }
-                const result = engine.apply("global", undefined, {
-                    summary: `Consolidate global store: archive ${candidates.length} entries${mergeCount > 0 ? `, merge ${mergeCount} into survivors` : ""}`,
-                    rationale: "Human-invoked batch consolidation via /evolve consolidate apply.",
-                    expectedOutcome: "Candidate entries are hidden from injection (data kept; restorable via /evolve unarchive). Merged survivors carry the near-duplicate content with a mergedFrom provenance stamp.",
-                    edits,
-                }, { scope: "global" });
-                return success(`${report}\n\napplied:\n${renderResult(result)}`);
-            }
-            case "failures": {
-                // /evolve failures — failure-signature aggregation (D1 observation):
-                // failed review-gate records + failed benchmark cells, counted by class.
-                const { summary, records } = collectFailureSummary(engine.baseDir);
-                const parts = formatFailureSummary(summary).split("\n");
-                const recent = records
-                    .sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""))
-                    .slice(0, 10)
-                    .map((f) => `  [${f.timestamp ?? "(benchmark)"}] ${f.kind} · ${f.source}: ${f.message.slice(0, 140)}`);
-                if (recent.length > 0) {
-                    parts.push("recent 10:");
-                    parts.push(...recent);
-                }
-                return success(parts.join("\n"));
-            }
-            case "log": {
-                // /evolve log [tail N] [session <sessionId>]
-                let tail = 50;
-                let sessionFilter;
-                for (let i = 0; i < rest.length; i += 1) {
-                    const token = rest[i] ?? "";
-                    if (token === "session") {
-                        sessionFilter = stripAngleBrackets(rest[i + 1] ?? "");
-                        if (!sessionFilter) {
-                            return error(`log session requires a session id (e.g. /evolve log session session-abc123).\n${USAGE}`);
-                        }
-                        i += 1;
-                    }
-                    else {
-                        tail = Math.min(Math.max(parsePositiveInt(token, "tail"), 1), 1000);
-                    }
-                }
-                const path = pluginLogFilePath(engine.baseDir);
-                if (!existsSync(path)) {
-                    return success(`(no plugin log yet — ${path} is created on the first log message)`);
-                }
-                const lines = readFileSync(path, "utf8").trimEnd().split("\n").filter((line) => line.length > 0);
-                if (lines.length === 0) {
-                    return success(`(empty plugin log: ${path})`);
-                }
-                const filtered = sessionFilter ? filterLogBySession(lines, sessionFilter) : lines;
-                const shown = filtered.slice(-tail);
-                const scopeNote = sessionFilter ? `, ${filtered.length} for session ${sessionFilter}` : "";
-                return success(`plugin log ${path} (${lines.length} lines${scopeNote}, showing last ${shown.length}):\n${shown.map(formatLogLine).join("\n")}`);
-            }
-            case "export": {
-                const { scope, rest: after } = scopeArg(rest);
-                const path = after[0];
-                if (!path) {
-                    return error(`export requires an output path.\n${USAGE}`);
-                }
-                const state = engine.load(scope, storeIdForCommand(scope, invocation));
-                const history = engine.history(scope, storeIdForCommand(scope, invocation));
-                const payload = {
-                    version: 1,
-                    scope,
-                    schema: state.schema,
-                    entries: state.entries,
-                    refinements: state.refinements,
-                    history,
-                };
-                writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-                return success(`exported ${scope} store (${Object.values(state.entries).reduce((n, e) => n + Object.keys(e).length, 0)} entries, ${history.length} refinements) to ${path}`);
-            }
-            case "import": {
-                const { scope, rest: after } = scopeArg(rest);
-                const path = after[0];
-                if (!path) {
-                    return error(`import requires an input path.\n${USAGE}`);
-                }
-                const payload = JSON.parse(readFileSync(path, "utf8"));
-                if (!isValidExport(payload)) {
-                    return error(`invalid export file shape: expected {version, entries: {prompt, memory, skill, subagent}, refinements, history}`);
-                }
-                const state = {
-                    schema: typeof payload["schema"] === "number" ? payload["schema"] : 1,
-                    entries: {
-                        prompt: toEntryRecord(payload["entries"]["prompt"]),
-                        memory: toEntryRecord(payload["entries"]["memory"]),
-                        skill: toEntryRecord(payload["entries"]["skill"]),
-                        subagent: toEntryRecord(payload["entries"]["subagent"]),
-                    },
-                    refinements: Array.isArray(payload["refinements"]) ? payload["refinements"] : [],
-                };
-                const paths = storePaths(engine.baseDir, scope, storeIdForCommand(scope, invocation));
-                saveHarnessState(paths.stateDir, state);
-                if (Array.isArray(payload["history"])) {
-                    for (const result of payload["history"]) {
-                        if (isResultRecord(result)) {
-                            appendResult(paths, result);
-                        }
-                    }
-                    // Storage hygiene (#20): an imported history obeys the
-                    // same tail budget as a live one.
-                    try {
-                        pruneJsonlFile(paths.resultsPath, engine.retention?.refinements ?? DEFAULT_REFINEMENTS_RETAIN);
-                    }
-                    catch {
-                        // ignored — the next apply retries
-                    }
-                }
-                return success(`imported ${scope} store from ${path}`);
-            }
-            case "plan": {
-                const { scope, rest: after } = scopeArg(rest);
-                const instructions = after.length > 0 ? after.join(" ") : undefined;
-                const state = engine.load(scope, storeIdForCommand(scope, invocation));
-                const history = engine.history(scope, storeIdForCommand(scope, invocation));
-                const proposal = await planWithLlm(ctx, {
-                    agent: invocation.agent,
-                    state,
-                    history,
-                    ...(instructions ? { instructions } : {}),
-                    global: scope === "global",
-                    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)}`),
-                    },
-                    // skill-creator template facts (fallback: builtin guide).
-                    skillsRoot: join(engine.baseDir, "skills"),
-                });
-                if ((scope === "global" || scope === "project") && opts.requireGlobalApproval && proposal.edits.length > 0) {
-                    await requireGlobalApproval(ctx, invocation.agent, invocation.signal, `/evolve plan ${scope} 将应用 ${proposal.edits.length} 条编辑到${scope === "project" ? "本项目" : "跨会话"} store：${proposal.summary}`, runtime.recordLanguage);
-                }
-                const result = engine.apply(scope, storeIdForCommand(scope, invocation), proposal, {
-                    scope,
-                    baselineState: state,
-                    ...(entrySourceOf(invocation.agent, sessionId) ? { source: entrySourceOf(invocation.agent, sessionId) } : {}),
-                });
-                return success(renderResult(result));
-            }
-            case "wrapup": {
-                return await executeWrapupCommand(ctx, engine, invocation, runtime.promotionPolicy, runtime.recordLanguage);
-            }
-            case "pause":
-            case "resume": {
-                // The switch is independent of the static registration flag. A
-                // resume explicitly enables the Memory Agent; a pause leaves the
-                // enable bit intact so status explains the paused state.
-                const pausing = sub === "pause";
-                const defaultEnabled = runtime.autoReview ?? false;
-                const current = loadGateRuntime(engine.baseDir, defaultEnabled);
-                if (pausing && current.paused) {
-                    return success("automatic Memory Agent is already paused (no change).");
-                }
-                if (!pausing && current.enabled && !current.paused) {
-                    return success("automatic Memory Agent is already running (no change).");
-                }
-                saveGateRuntime(engine.baseDir, pausing, pausing ? current.enabled : true);
-                return success(pausing
-                    ? "automatic Memory Agent paused: no automatic memory extraction calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
-                    : "automatic Memory Agent resumed: successful turns will produce incremental memory snapshots immediately.");
-            }
-            case "status": {
-                return success(renderGateStatus(engine, sessionId, projectKeyOf(invocation.agent), runtime));
-            }
-            case "usage": {
-                return success(renderUsageReport(engine, sessionId, projectKeyOf(invocation.agent)));
-            }
-            case "goal": {
-                return executeGoalCommand(ctx, invocation, rest);
-            }
-            case "mount": {
-                return await executeMountCommand(ctx, engine, invocation, rest);
-            }
-            case "unmount": {
-                return await executeUnmountCommand(ctx, engine, rest);
-            }
-            case "benchmark": {
-                return await executeBenchmarkCommand(ctx, engine, invocation, rest, runtime);
-            }
-            default:
-                return error(`unknown subcommand: ${sub}\n${USAGE}`);
-        }
-    }
-    catch (cause) {
-        return error(cause instanceof Error ? cause.message : String(cause));
-    }
-}
-/**
- * Status answers whether the automatic listener is wired and what
- * stores/retention it currently sees.
- */
-function renderGateStatus(engine, sessionId, projectKey, runtime) {
-    const configuredDefault = runtime.autoReview === undefined ? "unknown" : runtime.autoReview ? "on" : "off";
-    const current = loadGateRuntime(engine.baseDir, runtime.autoReview ?? false);
-    const effective = current.paused
-        ? "PAUSED (resume with /evolve resume)"
-        : current.enabled
-            ? "Memory Agent running"
-            : "Memory Agent off (enable with /evolve resume)";
-    const gateLine = `gate: Memory Agent-only listener registered · config default ${configuredDefault} · runtime ${effective}`;
-    const countEntries = (state) => Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
-    const lines = [gateLine];
-    lines.push(`stores: global ${countEntries(engine.load("global", undefined))} entries · local(${sessionId}) ${countEntries(engine.load("local", sessionId))} entries`);
-    if (projectKey) {
-        try {
-            lines[lines.length - 1] += ` · project ${countEntries(engine.load("project", projectKey))} entries`;
-        }
-        catch {
-            lines[lines.length - 1] += " · project (unavailable)";
-        }
-    }
-    const retention = engine.retention;
-    if (retention) {
-        lines.push(`retention: snapshots ${retention.snapshots} · refinements ${retention.refinements} · reviews ${retention.reviews} · token usage ${retention.tokenUsage} (historyRetain)`);
-    }
-    return lines.join("\n");
-}
-/**
- * #21 P0 usage ledger: injection counts per entry across the stores the
- * human can see (global + this session + this project). Counts are
- * per-session since the v2 usage shape — "in how many sessions did this
- * entry surface" — the exposure half of the #18a归零实验 verdict.
- */
-function renderUsageReport(engine, sessionId, projectKey) {
-    const store = loadUsage(engine.baseDir);
-    const rows = [];
-    const seen = new Set();
-    const collect = (state) => {
-        for (const kind of Object.keys(state.entries)) {
-            for (const entry of Object.values(state.entries[kind])) {
-                const key = `${kind}:${entry.id}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const count = getUsageCount(store, kind, entry.id);
-                rows.push({
-                    key,
-                    title: entry.title,
-                    count,
-                    ...(store.lastSession?.[`${kind}:${entry.id}`] ? { lastSession: store.lastSession[`${kind}:${entry.id}`] } : {}),
-                });
-            }
-        }
-    };
-    collect(engine.load("global", undefined));
-    collect(engine.load("local", sessionId));
-    if (projectKey) {
-        try {
-            collect(engine.load("project", projectKey));
-        }
-        catch {
-            // project store unavailable here — global+local still report
-        }
-    }
-    const liveKeys = new Set(rows.map((r) => r.key));
-    const orphaned = Object.keys(store.counts).filter((k) => !liveKeys.has(k)).length;
-    const total = rows.reduce((n, r) => n + r.count, 0);
-    const injected = rows.filter((r) => r.count > 0).sort((a, b) => b.count - a.count || (a.key < b.key ? -1 : 1));
-    const stale = rows.filter((r) => r.count === 0).sort((a, b) => (a.key < b.key ? -1 : 1));
-    const lines = [`injected entries: ${total} injections across ${injected.length} of ${rows.length} stored entries${orphaned > 0 ? ` (+${orphaned} historical key(s) for deleted entries)` : ""}`];
-    if (injected.length > 0) {
-        lines.push("injected (top 15):");
-        for (const row of injected.slice(0, 15)) {
-            lines.push(`  ${row.key} — ${row.count}× · ${row.title}${row.lastSession ? ` (last in ${row.lastSession})` : ""}`);
-        }
-        if (injected.length > 15) {
-            lines.push(`  … and ${injected.length - 15} more`);
-        }
-    }
-    else {
-        lines.push("injected: (none yet — nothing has surfaced into a session prompt)");
-    }
-    if (stale.length > 0) {
-        lines.push(`never injected (${stale.length}):`);
-        for (const row of stale.slice(0, 20)) {
-            lines.push(`  ${row.key} · ${row.title}`);
-        }
-        if (stale.length > 20) {
-            lines.push(`  … and ${stale.length - 20} more`);
-        }
-    }
-    lines.push("", ...renderTokenUsageReport(loadTokenUsage(engine.baseDir), engine.retention.tokenUsage));
-    return lines.join("\n");
-}
-function renderResult(result) {
-    const applied = result.appliedEdits.filter((e) => e.applied);
-    const failed = result.appliedEdits.filter((e) => !e.applied);
-    const lines = [
-        `refinement ${result.id}${result.rollbackOf ? ` (rollback of ${result.rollbackOf})` : ""}: ${applied.length} applied, ${failed.length} failed`,
-        `summary: ${result.summary}`,
-    ];
-    for (const e of applied) {
-        lines.push(`- ${e.action} ${e.kind}:${e.id} (v${(e.after?.version ?? e.before?.version) ?? "?"})`);
-    }
-    for (const e of failed) {
-        lines.push(`- failed ${e.action} ${e.kind}:${e.id ?? "(computed)"} — ${e.error ?? "unknown error"}`);
-    }
-    lines.push(`expected outcome: ${result.expectedOutcome}`);
-    return lines.join("\n");
-}
-function toEntryRecord(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-}
-function parsePositiveInt(value, what) {
-    const n = Number(value);
-    if (!Number.isInteger(n) || n < 1) {
-        throw new Error(`${what} must be a positive integer, got "${value}"`);
-    }
-    return n;
-}
-function isValidExport(payload) {
-    if (typeof payload !== "object" || payload === null)
-        return false;
-    const entries = payload["entries"];
-    if (typeof entries !== "object" || entries === null || Array.isArray(entries))
-        return false;
-    const kinds = ["prompt", "memory", "skill", "subagent"];
-    return kinds.every((kind) => Object.prototype.hasOwnProperty.call(entries, kind));
-}
-function isResultRecord(value) {
-    return typeof value === "object" && value !== null && "id" in value && "appliedEdits" in value;
-}
-function success(text) {
-    return { kind: "success", text };
-}
-function error(text) {
-    return { kind: "error", text };
-}
-//# sourceMappingURL=command.js.map

package/lib/consolidate.d.ts

@@ -1,90 +0,0 @@
-/**
- * Global-store consolidation (R3): turn the two hygiene signals — R2's
- * `conflictHint` stamps and usage v2's zero-injection staleness — into one
- * deterministic, human-approved batch of archive edits (`/evolve consolidate`).
- *
- * Design (ADR implemented/feature/2026-08-24-consolidation-command.md):
- * - pure functions only; the command layer owns loading, reporting, and the
- *   apply phase, and ALWAYS re-scans fresh state before applying (the report
- *   and the apply are two separate invocations — prefer under-archiving over
- *   mis-archiving when state moved in between);
- * - archiving keeps data (ARCHIVED_AT_KEY stamp, restorable via
- *   `/evolve unarchive`) and preserves every existing metadata key including
- *   the conflictHint itself, so unarchived entries keep their trail;
- * - no LLM call anywhere: code proposes, the human disposes.
- */
-import type { HarnessState, RefinementEdit, RefinementKind } from "./types.js";
-import { type UsageStore } from "./usage.js";
-/** Zero-use entries at least this old are stale candidates (30d, matching the injection recency half-life scale). */
-export declare const STALE_MIN_AGE_MS: number;
-/** Parsed `<kind>:<id>:<score>` value of a {@link CONFLICT_HINT_KEY} stamp. */
-export interface ConflictHint {
-    kind: RefinementKind;
-    id: string;
-    score: number;
-}
-/**
- * Parse one conflictHint metadata value. Returns undefined for anything that
- * is not exactly `<kind>:<id>:<score>` with a known kind and a score in
- * [0, 1] — foreign or legacy junk must never crash the scan.
- */
-export declare function parseConflictHint(value: unknown): ConflictHint | undefined;
-/** One planned archive with its human-readable justification. */
-export interface ConsolidationCandidate {
-    kind: RefinementKind;
-    id: string;
-    title: string;
-    reason: string;
-    /**
-     * Merge tier (P1 反膨胀): set on conflict-pair candidates — the entry's
-     * content merges into this survivor (pointed-to original) before the
-     * entry itself archives, so nothing readable is lost by the archive. The
-     * plan only EMITS the merge when `mergeDuplicates` is on.
-     */
-    mergeInto?: {
-        kind: RefinementKind;
-        id: string;
-        title: string;
-    };
-}
-/**
- * Entries stamped by the write-time conflict guard whose target still exists
- * and is still active. The hinted (newer) entry is the archive candidate —
- * the pointed-to original stays as the live copy.
- */
-export declare function findConflictPairs(state: HarnessState): ConsolidationCandidate[];
-/**
- * Active global entries never injected in any session and untouched for at
- * least `minAgeMs`: prime staleness candidates. Operates on whatever state
- * it is handed (callers pass the global store).
- */
-export declare function findStaleEntries(state: HarnessState, store: UsageStore, now: number, minAgeMs?: number): ConsolidationCandidate[];
-/**
- * Append a source entry's content to a survivor with an attributed divider,
- * so the survivor's reader can see which part came from which entry.
- */
-export declare function mergeContent(target: string, source: string, sourceRef: string, dateIso: string): string;
-/**
- * Merge both scans (conflict reason wins on overlap), deduped by kind:id,
- * and build the batch archive edits. Each edit preserves the entry's full
- * content and existing metadata — only ARCHIVED_AT_KEY is added — so
- * `/evolve unarchive` restores everything intact.
- *
- * With `opts.mergeDuplicates`, conflict-pair candidates additionally merge
- * their content INTO the pointed-to survivor (an attributed `mergeContent`
- * section + a `mergedFrom` provenance stamp) before archiving — the #11
- * candidate-c tier the 2026-08-28 ecosystem review promoted. Per-target
- * accumulation composes multiple hints into one survivor (update edits
- * replace content/metadata wholesale, so parallel merge edits would clobber
- * each other).
- *
- * @param now Epoch ms used for the archivedAt stamp (injected for tests).
- */
-export declare function planConsolidation(state: HarnessState, store: UsageStore, now?: number, opts?: {
-    minAgeMs?: number;
-    mergeDuplicates?: boolean;
-}): {
-    candidates: ConsolidationCandidate[];
-    edits: RefinementEdit[];
-};
-//# sourceMappingURL=consolidate.d.ts.map