dsh-continual-evolve 0.10.6 → 0.11.0

package/lib/command.js

@@ -1,24 +1,13 @@
-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 { 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";
-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)
@@ -51,6 +40,7 @@ const USAGE_ADVANCED = `Advanced:
   /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",
@@ -59,96 +49,6 @@ export function registerEvolveCommand(ctx, engine, opts, runtime) {
         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] ?? "";
@@ -181,226 +81,36 @@ async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
             }
             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")}`);
-            }
+                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 { 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}`);
+                const parsed = scopeArg(rest);
+                return executeExportCommand(engine, invocation, parsed, USAGE);
             }
             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}`);
+                const parsed = scopeArg(rest);
+                return executeImportCommand(engine, invocation, parsed, parsed.rest[0]);
             }
             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));
+                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": {
-                // 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 "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);
             }
@@ -421,148 +131,4 @@ async function executeEvolveCommand(ctx, engine, invocation, opts, runtime) {
         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/copy.d.ts

@@ -1,14 +1,14 @@
 /**
- * Backend user-visible copy for the four evolution confirmation dialogs,
- * in both shipped languages. Labels stay literal per language (the parsers
- * match them); guidance lives in `description`.
+ * Backend user-visible copy for the evolution confirmation dialogs, in both
+ * shipped languages. Labels stay literal per language (the parsers match
+ * them); guidance lives in `description`.
  *
  * Language is never hardcoded at a call site: every builder takes an
  * explicit `lang`, and dialog entry points resolve it per call
  * (explicit config upstream, else the durable DSH client preference,
  * else `en`) when the caller does not supply one.
  */
-import { type RecordLanguage } from "./record-language.js";
+import type { RecordLanguage } from "./record-language.js";
 export interface ConfirmOption {
     label: string;
     description: string;
@@ -27,18 +27,6 @@ export declare const COPY_WHAT_MAX_CHARS = 300;
  * @param lang Dialog language.
  */
 export declare function approvalCopy(scope: "project" | "global", what: string, lang: RecordLanguage): ConfirmCopy;
-export interface FateConsultSections {
-    promotable: string[];
-    splits: string[];
-    reviewArchives: string[];
-}
-/**
- * Local-fate homing consult (`evolve-fate-consult`).
- *
- * @param sections Pre-rendered per-item lines per group.
- * @param lang Dialog language.
- */
-export declare function fateConsultCopy(sections: FateConsultSections, lang: RecordLanguage): ConfirmCopy;
 /**
  * Single-entry wrap-up archive confirm (`evolve-wrapup-archive-review`).
  *
@@ -46,29 +34,4 @@ export declare function fateConsultCopy(sections: FateConsultSections, lang: Rec
  * @param lang Dialog language.
  */
 export declare function wrapupArchiveCopy(title: string, lang: RecordLanguage): ConfirmCopy;
-/**
- * Skill solidification consult (`evolve-skill-consult`).
- *
- * @param description Pre-rendered per-edit lines.
- * @param lang Dialog language.
- */
-export declare function skillConsultCopy(description: string, lang: RecordLanguage): ConfirmCopy;
-/**
- * One skill-edit line inside the solidification consult.
- *
- * @param action Edit action (`create` etc.).
- * @param title Entry title or id fallback.
- * @param skillKind `guidance` skills are SKILL.md documents.
- * @param lang Dialog language.
- */
-export declare function skillEditLine(action: string, title: string, skillKind: string | undefined, lang: RecordLanguage): string;
-/**
- * Resolve the dialog language for a call site that holds no explicit
- * choice: durable client preference first, `en` otherwise. (Dialogs carry
- * no trajectory text, so there is no detection tier here.)
- *
- * @param ctx Host context for the durable-preference read.
- * @returns The dialog language.
- */
-export declare function resolveDialogLanguage(ctx: unknown): RecordLanguage;
 //# sourceMappingURL=copy.d.ts.map