dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/benchmark.js

@@ -1,250 +0,0 @@
-/**
- * Benchmark store: file-backed case definitions and scoreboards under
- * `<baseDir>/evolve/benchmarks/<bid>/`.
- *
- * Layout:
- *   benchmark.json          title, runs (repeats per case), passThreshold
- *   cases/<cid>/statement.md   public task text
- *   cases/<cid>/rubric.json    encrypted scoring criteria (AES-256-GCM, see src/rubric.ts)
- *   scoreboard.json         code-owned aggregates + acceptance history
- *
- * Rubric isolation is code-enforced: rubric plaintext never reaches the
- * disk. Only the evaluation runner decrypts (into the child prompt); the
- * optimizer can read the file and sees ciphertext only. Legacy files that
- * predate encryption carry plaintext and are still readable.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { encryptRubric, DEV_RUBRIC_KEY, deriveKey } from "./rubric.js";
-/**
- * Close the acceptance loop: when the code-owned decision rejects a
- * candidate refinement, revert it deterministically. The rollback is the
- * same engine path as `/evolve rollback` (inverse edits rebuilt from the
- * applied result — no LLM re-guessing), so it snapshots, versions, and
- * audits like any other mutation. Failures (e.g. the refinement belongs to
- * another session's history) are reported, never thrown: the command shows
- * the manual fallback instead.
- */
-export function rollbackRejectedCandidate(engine, sessionId, candidateId) {
-    try {
-        const result = engine.rollback("local", sessionId, candidateId);
-        const applied = result.appliedEdits.filter((edit) => edit.applied).length;
-        return {
-            rolledBack: true,
-            message: `auto-rollback: reverted refinement ${candidateId} — ${applied} edits restored to the pre-refinement snapshot`,
-        };
-    }
-    catch (cause) {
-        return {
-            rolledBack: false,
-            message: `auto-rollback failed: ${cause instanceof Error ? cause.message : String(cause)} — roll back manually with /evolve rollback <${candidateId}>`,
-        };
-    }
-}
-export function benchmarkDir(baseDir, bid) {
-    return join(baseDir, "evolve", "benchmarks", bid);
-}
-export function sanitizeId(raw) {
-    const id = raw.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40);
-    if (!id) {
-        throw new Error("benchmark id must be a non-empty slug");
-    }
-    return id;
-}
-export function createBenchmark(baseDir, opts) {
-    const id = sanitizeId(opts.title);
-    const dir = benchmarkDir(baseDir, id);
-    if (existsSync(dir)) {
-        throw new Error(`benchmark ${id} already exists`);
-    }
-    const definition = {
-        id,
-        title: opts.title.trim(),
-        description: opts.description?.trim() ?? "",
-        runs: opts.runs ?? 1,
-        passThreshold: opts.passThreshold ?? 60,
-        createdAt: new Date().toISOString(),
-    };
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "benchmark.json"), `${JSON.stringify(definition, null, 2)}\n`, "utf8");
-    writeFileSync(join(dir, "scoreboard.json"), `${JSON.stringify({ candidates: [], decisions: [] }, null, 2)}\n`, "utf8");
-    return definition;
-}
-export function listBenchmarks(baseDir) {
-    const root = join(baseDir, "evolve", "benchmarks");
-    if (!existsSync(root))
-        return [];
-    return readdirSafe(root)
-        .map((id) => loadBenchmark(baseDir, id))
-        .filter((b) => b !== undefined);
-}
-export function loadBenchmark(baseDir, bid) {
-    const path = join(benchmarkDir(baseDir, bid), "benchmark.json");
-    if (!existsSync(path))
-        return undefined;
-    try {
-        return JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return undefined;
-    }
-}
-export function addCase(baseDir, bid, title, statement, rubric, rubricKey) {
-    const definition = loadBenchmark(baseDir, bid);
-    if (!definition) {
-        throw new Error(`benchmark ${bid} not found`);
-    }
-    const id = sanitizeId(title);
-    const caseDir = join(benchmarkDir(baseDir, bid), "cases", id);
-    if (existsSync(caseDir)) {
-        throw new Error(`case ${id} already exists in ${bid}`);
-    }
-    mkdirSync(caseDir, { recursive: true });
-    writeFileSync(join(caseDir, "statement.md"), statement, "utf8");
-    // Rubric plaintext never touches the disk; callers pass a resolved key
-    // (config → env → per-installation key file → dev fallback, see
-    // resolveRubricKey) and the dev key here is only a defensive last resort.
-    const stored = rubricKey ? encryptRubric(rubric, rubricKey) : encryptRubric(rubric, deriveKey(DEV_RUBRIC_KEY));
-    writeFileSync(join(caseDir, "rubric.json"), `${JSON.stringify(stored, null, 2)}\n`, "utf8");
-    // A5: initialize case metadata for quality gate.
-    saveCaseMeta(baseDir, bid, id, defaultCaseMeta());
-    return { id, title: title.trim(), statement, rubric };
-}
-export function listCases(baseDir, bid) {
-    const casesDir = join(benchmarkDir(baseDir, bid), "cases");
-    if (!existsSync(casesDir))
-        return [];
-    return readdirSafe(casesDir)
-        .map((id) => {
-        const statementPath = join(casesDir, id, "statement.md");
-        const rubricPath = join(casesDir, id, "rubric.json");
-        if (!existsSync(statementPath) || !existsSync(rubricPath))
-            return undefined;
-        try {
-            const statement = readFileSync(statementPath, "utf8");
-            const rubric = JSON.parse(readFileSync(rubricPath, "utf8"));
-            const meta = loadCaseMeta(baseDir, bid, id);
-            return { id, title: id, statement, rubric, ...(meta ? { status: meta.status } : {}) };
-        }
-        catch {
-            return undefined;
-        }
-    })
-        .filter((c) => c !== undefined);
-}
-export function loadScoreboard(baseDir, bid) {
-    const path = join(benchmarkDir(baseDir, bid), "scoreboard.json");
-    if (!existsSync(path)) {
-        return { candidates: [], decisions: [] };
-    }
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        return {
-            ...(raw.reference ? { reference: raw.reference } : {}),
-            candidates: raw.candidates ?? [],
-            decisions: raw.decisions ?? [],
-        };
-    }
-    catch {
-        return { candidates: [], decisions: [] };
-    }
-}
-export function saveScoreboard(baseDir, bid, board) {
-    writeFileSync(join(benchmarkDir(baseDir, bid), "scoreboard.json"), `${JSON.stringify(board, null, 2)}\n`, "utf8");
-}
-// ── Case meta (gap A5: quality gate + calibration history) ────────────
-export function loadCaseMeta(baseDir, bid, cid) {
-    const path = join(benchmarkDir(baseDir, bid), "cases", cid, "meta.json");
-    if (!existsSync(path))
-        return undefined;
-    try {
-        return JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return undefined;
-    }
-}
-export function saveCaseMeta(baseDir, bid, cid, meta) {
-    const metaDir = join(benchmarkDir(baseDir, bid), "cases", cid);
-    mkdirSync(metaDir, { recursive: true });
-    writeFileSync(join(metaDir, "meta.json"), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
-}
-/**
- * Transition a case's lifecycle state. Throws on illegal transitions.
- *   draft → calibrating (start pilot)
- *   calibrating → draft (abandon calibration)
- *   calibrating → frozen (lock baseline)
- */
-export function transitionCaseStatus(baseDir, bid, cid, to) {
-    const meta = loadCaseMeta(baseDir, bid, cid) ?? defaultCaseMeta();
-    const from = meta.status;
-    const valid = (from === "draft" && to === "calibrating") ||
-        (from === "calibrating" && to === "draft") ||
-        (from === "calibrating" && to === "frozen");
-    if (!valid) {
-        throw new Error(`illegal case status transition: ${from} → ${to}`);
-    }
-    meta.status = to;
-    saveCaseMeta(baseDir, bid, cid, meta);
-    return meta;
-}
-function defaultCaseMeta() {
-    return {
-        status: "draft",
-        capability: "",
-        distinguisher: "",
-        shortcuts: "",
-        calibrationHistory: [],
-    };
-}
-/**
- * Quality-check a case: mechanical validation without LLM calls.
- * Returns human-readable problems; empty array means the case passes.
- */
-export function caseCheckProblems(baseDir, bid, cid) {
-    const problems = [];
-    const statementPath = join(benchmarkDir(baseDir, bid), "cases", cid, "statement.md");
-    if (!existsSync(statementPath)) {
-        problems.push("statement.md missing");
-        return problems;
-    }
-    const statement = readFileSync(statementPath, "utf8").trim();
-    if (statement.length < 20) {
-        problems.push(`statement too short (${statement.length} chars, minimum 20)`);
-    }
-    const rubricPath = join(benchmarkDir(baseDir, bid), "cases", cid, "rubric.json");
-    if (!existsSync(rubricPath)) {
-        problems.push("rubric.json missing");
-        return problems;
-    }
-    try {
-        const raw = readFileSync(rubricPath, "utf8");
-        JSON.parse(raw);
-    }
-    catch {
-        problems.push("rubric.json is not valid JSON");
-    }
-    const meta = loadCaseMeta(baseDir, bid, cid);
-    if (!meta) {
-        problems.push("meta.json missing (run /evolve benchmark casecheck to initialize)");
-    }
-    else {
-        if (!meta.capability)
-            problems.push("capability contract is empty");
-        if (!meta.distinguisher)
-            problems.push("distinguisher is empty");
-        if (!meta.shortcuts)
-            problems.push("shortcuts annotation is empty");
-    }
-    return problems;
-}
-import { readdirSync } from "node:fs";
-function readdirSafe(dir) {
-    try {
-        return readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-}
-//# sourceMappingURL=benchmark.js.map

package/lib/command-util.d.ts

@@ -1,70 +0,0 @@
-/**
- * Shared command-surface utilities: pure input parsing, entry lookup, and
- * result rendering used by the `/evolve` router and every sub-command file.
- * Lives below the interface layer so sub-command files can import it without
- * cycling through command.ts.
- */
-import type { HarnessEntry, HarnessState, HarnessScope, RefinementKind, RefinementResult } from "./types.js";
-import type { CommandInvocation } from "@deepseek-ai/dsh-commands";
-import type { PromotionPolicy } from "./promotion.js";
-import type { RecordLanguagePreference } from "./record-language.js";
-export interface CommandGateOptions {
-    requireGlobalApproval: boolean;
-}
-export interface CommandRuntimeOptions {
-    rubricKey: Buffer;
-    /** When a benchmark decision rejects a candidate, roll the refinement back automatically. */
-    autoRollbackOnReject: boolean;
-    /** P1: capture failed evolution attempts as draft cases in the auto-regression benchmark. */
-    autoCase: boolean;
-    /** Mechanical promotion guards for wrapup (2026-08-22 policy). */
-    promotionPolicy: PromotionPolicy;
-    /**
-     * Initial Memory Agent default from plugin config. The listener is always
-     * registered; this is not a registration gate.
-     */
-    autoReview?: boolean;
-    /** Plugin `recordLanguage` preference for dialog copy (see `approval.ts`). */
-    recordLanguage?: RecordLanguagePreference;
-}
-/** Parse an optional leading scope token ("global" | "project") off the args. */
-export declare function scopeArg(tokens: string[]): {
-    scope: HarnessScope;
-    rest: string[];
-};
-/**
- * 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.
- */
-export declare function storeIdForCommand(scope: HarnessScope, invocation: CommandInvocation): string | 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 declare function tokenizeEvolveInput(rawInput: string): string[];
-/** Accept both `<id>` (help-text placeholder form) and bare `id`. */
-export declare function stripAngleBrackets(value: string): string;
-/**
- * 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 declare function findEntryById(state: HarnessState, id: string): [RefinementKind, HarnessEntry] | undefined;
-export declare function parsePositiveInt(value: string, what: string): number;
-/** Structural stand-in for the host `CommandResult` (kind + text only). */
-export interface CommandTextResult {
-    kind: "success" | "error";
-    text: string;
-}
-export declare function success(text: string): CommandTextResult;
-export declare function error(text: string): CommandTextResult;
-/** Human-readable one-refinement rendering shared by every apply path. */
-export declare function renderResult(result: RefinementResult): string;
-//# sourceMappingURL=command-util.d.ts.map

package/lib/command-util.js

@@ -1,123 +0,0 @@
-import { projectKeyOf } from "./project.js";
-/** Parse an optional leading scope token ("global" | "project") off the args. */
-export 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.
- */
-export 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;
-}
-export 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;
-}
-export function success(text) {
-    return { kind: "success", text };
-}
-export function error(text) {
-    return { kind: "error", text };
-}
-/** Human-readable one-refinement rendering shared by every apply path. */
-export 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");
-}
-//# sourceMappingURL=command-util.js.map

package/lib/command.d.ts

@@ -1,13 +0,0 @@
-/**
- * The human-facing `/evolve` command router: parse the subcommand and hand
- * off to its implementation file. Subcommand logic lives in the
- * `*-command.ts` modules; this file owns only registration, help text, and
- * the core inspect/rollback flows.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { EvolutionEngine } from "./service.js";
-import { findEntryById, stripAngleBrackets, tokenizeEvolveInput, type CommandGateOptions, type CommandRuntimeOptions } from "./command-util.js";
-export { findEntryById, stripAngleBrackets, tokenizeEvolveInput };
-export type { CommandGateOptions, CommandRuntimeOptions };
-export declare function registerEvolveCommand(ctx: Context, engine: EvolutionEngine, opts: CommandGateOptions, runtime: CommandRuntimeOptions): void;
-//# sourceMappingURL=command.d.ts.map

package/lib/command.js

@@ -1,134 +0,0 @@
-import { formatHarnessStateForPrompt, historyForPrompt } from "./render.js";
-import { findEntryById, renderResult, scopeArg, stripAngleBrackets, storeIdForCommand, success, error, tokenizeEvolveInput, } from "./command-util.js";
-import { executePlanCommand } from "./plan-command.js";
-import { executeArchiveCommand, executeConsolidateCommand, executeExportCommand, executeFailuresCommand, executeImportCommand, executeLogCommand, } from "./maintenance-commands.js";
-import { executePauseResumeCommand, executeStatusCommand, executeUsageCommand } from "./runtime-commands.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";
-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 { findEntryById, stripAngleBrackets, tokenizeEvolveInput };
-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),
-    });
-}
-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": {
-                return await executeArchiveCommand(ctx, engine, invocation, sub, scopeArg(rest), USAGE);
-            }
-            case "consolidate":
-                return executeConsolidateCommand(engine, rest);
-            case "failures":
-                return executeFailuresCommand(engine);
-            case "log":
-                return executeLogCommand(engine, rest, USAGE);
-            case "export": {
-                const parsed = scopeArg(rest);
-                return executeExportCommand(engine, invocation, parsed, USAGE);
-            }
-            case "import": {
-                const parsed = scopeArg(rest);
-                return executeImportCommand(engine, invocation, parsed, parsed.rest[0]);
-            }
-            case "plan": {
-                const { scope, rest: after } = scopeArg(rest);
-                return await executePlanCommand(ctx, engine, invocation, scope, after, opts, runtime);
-            }
-            case "wrapup": {
-                return await executeWrapupCommand(ctx, engine, invocation, runtime.promotionPolicy, runtime.recordLanguage);
-            }
-            case "pause":
-            case "resume":
-                return executePauseResumeCommand(engine, sub, runtime);
-            case "status":
-                return executeStatusCommand(engine, sessionId, projectKeyOf(invocation.agent), runtime);
-            case "usage":
-                return executeUsageCommand(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));
-    }
-}
-//# 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