cool-workflow 0.1.98 → 0.2.1

package/dist/daemon.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesktopSchedulerDaemon = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const scheduler_1 = require("./scheduler");
-const state_1 = require("./state");
-class DesktopSchedulerDaemon {
-    cwd;
-    intervalSeconds;
-    scheduler;
-    constructor(options = {}) {
-        this.cwd = node_path_1.default.resolve(String(options.cwd || process.cwd()));
-        this.intervalSeconds = Number(options.intervalSeconds || 60);
-        this.scheduler = new scheduler_1.Scheduler(this.cwd);
-    }
-    tick() {
-        const due = this.scheduler.due();
-        const checkedAt = new Date().toISOString();
-        const inboxPath = node_path_1.default.join(this.cwd, ".cw", "schedules", "due-inbox.json");
-        (0, state_1.writeJson)(inboxPath, {
-            schemaVersion: 1,
-            checkedAt,
-            due
-        });
-        return {
-            checkedAt,
-            dueCount: due.length,
-            dueIds: due.map((task) => task.id),
-            inboxPath
-        };
-    }
-    async run() {
-        node_fs_1.default.mkdirSync(node_path_1.default.join(this.cwd, ".cw", "schedules"), { recursive: true });
-        process.stdout.write(`${JSON.stringify(this.tick())}\n`);
-        setInterval(() => {
-            process.stdout.write(`${JSON.stringify(this.tick())}\n`);
-        }, Math.max(1, this.intervalSeconds) * 1000);
-    }
-}
-exports.DesktopSchedulerDaemon = DesktopSchedulerDaemon;

package/dist/dispatch.js

@@ -1,250 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextDispatchTasks = nextDispatchTasks;
-exports.createDispatchManifest = createDispatchManifest;
-exports.firstRunnablePhase = firstRunnablePhase;
-exports.updatePhaseStatuses = updatePhaseStatuses;
-exports.formatDispatchTask = formatDispatchTask;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("./state");
-const pipeline_contract_1 = require("./pipeline-contract");
-const state_node_1 = require("./state-node");
-const worker_isolation_1 = require("./worker-isolation");
-const sandbox_profile_1 = require("./sandbox-profile");
-const execution_backend_1 = require("./execution-backend");
-const multi_agent_1 = require("./multi-agent");
-function nextDispatchTasks(run, limit) {
-    const runnablePhase = firstRunnablePhase(run);
-    if (!runnablePhase)
-        return [];
-    const max = Number(limit || run.workflow.limits.maxConcurrentAgents || 4);
-    const runnableTaskIds = new Set(runnablePhase.taskIds);
-    return run.tasks
-        .filter((task) => task.status === "pending" && runnableTaskIds.has(task.id))
-        .slice(0, max)
-        .map(formatDispatchTask);
-}
-function createDispatchManifest(run, limit, options = {}) {
-    const requestedSandboxProfileId = options.sandboxProfileId || options.sandbox;
-    const sandboxProfileId = String(requestedSandboxProfileId || sandbox_profile_1.DEFAULT_SANDBOX_PROFILE_ID);
-    (0, sandbox_profile_1.resolveSandboxProfileById)(sandboxProfileId, (0, sandbox_profile_1.sandboxContextForValidation)(run.cwd));
-    // H7: if the requested profile is a CUSTOM profile loaded from a FILE (non-bundled,
-    // existing file), persist its DEFINITION on run.customSandboxProfiles keyed by the
-    // definition's logical id. This makes the custom profile durable with run state so a
-    // worker boundary can re-resolve it by logical id after a scope snapshot is lost
-    // (re-resolving against the worker context, not the dispatch-time file path).
-    persistCustomSandboxProfile(run, sandboxProfileId);
-    // Resolve the execution backend once (mechanism vs policy): the kernel records
-    // WHICH backend was selected; it never branches on which one. Defaults to node
-    // (behavior-preserving) when no `--backend` flag / CW_BACKEND env is set.
-    const backendSelection = (0, execution_backend_1.resolveBackendSelection)(options.backendId);
-    const tasks = nextDispatchTasks(run, limit);
-    if (!tasks.length) {
-        return {
-            schemaVersion: 1,
-            runId: run.id,
-            dispatchId: null,
-            tasks: [],
-            manifestPath: null,
-            sandboxProfileId,
-            backendId: backendSelection.backendId,
-            backendSelection
-        };
-    }
-    const dispatchId = createDispatchId(run);
-    const manifestPath = node_path_1.default.join(run.paths.dispatchesDir, `${dispatchId}.json`);
-    node_fs_1.default.mkdirSync(run.paths.dispatchesDir, { recursive: true });
-    const taskIds = new Set(tasks.map((task) => task.id));
-    const createdAt = new Date().toISOString();
-    const selectedSandboxProfileIds = new Set();
-    let sandboxPolicy;
-    for (const task of run.tasks) {
-        if (taskIds.has(task.id)) {
-            const taskSandboxProfileId = String(requestedSandboxProfileId || task.sandboxProfileId || sandbox_profile_1.DEFAULT_SANDBOX_PROFILE_ID);
-            selectedSandboxProfileIds.add(taskSandboxProfileId);
-            task.status = "running";
-            task.loopStage = "act";
-            task.dispatchId = dispatchId;
-            task.dispatchedAt = createdAt;
-            const scope = (0, worker_isolation_1.allocateWorkerScope)(run, task, {
-                dispatchId,
-                sandboxProfileId: taskSandboxProfileId,
-                backendSelection,
-                status: "running",
-                persist: false,
-                metadata: { dispatchId, phase: task.phase }
-            });
-            sandboxPolicy = sandboxPolicy || scope.sandboxPolicy;
-        }
-    }
-    const selectedRunTasks = run.tasks.filter((task) => taskIds.has(task.id));
-    const multiAgentAttachment = (0, multi_agent_1.attachDispatchToMultiAgent)(run, {
-        multiAgentRunId: options.multiAgentRunId,
-        groupId: options.multiAgentGroupId,
-        roleId: options.multiAgentRoleId,
-        fanoutId: options.multiAgentFanoutId,
-        dispatchId,
-        tasks: selectedRunTasks,
-        sandboxProfileId: selectedSandboxProfileIds.size === 1 ? [...selectedSandboxProfileIds][0] : "mixed",
-        concurrencyLimit: limit
-    });
-    for (const task of selectedRunTasks) {
-        const worker = task.workerId ? (0, worker_isolation_1.syncWorkerScopeFromTask)(run, task.workerId) : undefined;
-        if (worker)
-            (0, worker_isolation_1.writeWorkerManifest)(run, worker);
-    }
-    const manifest = {
-        schemaVersion: 1,
-        runId: run.id,
-        dispatchId,
-        createdAt,
-        phase: tasks[0].phase,
-        instructions: "Spawn one worker per task when the user explicitly authorized agent/parallel/background work. Save each final summary as Markdown and record it with `cw.js result <run-id> <task-id> <file>`.",
-        tasks: selectedRunTasks.map(formatDispatchTask),
-        manifestPath,
-        workerIndexPath: run.paths.workersDir ? node_path_1.default.join(run.paths.workersDir, "index.json") : undefined,
-        sandboxProfileId: selectedSandboxProfileIds.size === 1 ? [...selectedSandboxProfileIds][0] : "mixed",
-        sandboxPolicy: selectedSandboxProfileIds.size === 1 ? sandboxPolicy : undefined,
-        backendId: backendSelection.backendId,
-        backendSelection,
-        backendAttestation: selectedRunTasks.find((task) => task.backendAttestation)?.backendAttestation,
-        multiAgent: multiAgentAttachment.multiAgent
-            ? {
-                ...multiAgentAttachment.multiAgent,
-                membershipIds: multiAgentAttachment.membershipIds
-            }
-            : undefined
-    };
-    const dispatchNode = (0, state_node_1.appendRunNode)(run, (0, state_node_1.createStateNode)({
-        id: `${run.id}:dispatch:${dispatchId}`,
-        kind: "dispatch",
-        status: "running",
-        loopStage: "act",
-        inputs: { taskIds: tasks.map((task) => task.id), phase: manifest.phase, sandboxProfileId: manifest.sandboxProfileId },
-        outputs: { dispatchId, sandboxProfileId: manifest.sandboxProfileId },
-        artifacts: [{ id: "dispatch", kind: "json", path: manifestPath }],
-        parents: tasks.map((task) => `${run.id}:task:${task.id}`),
-        contractId: pipeline_contract_1.DEFAULT_PIPELINE_CONTRACT_ID,
-        metadata: { sandboxProfileId: manifest.sandboxProfileId, sandboxPolicy: manifest.sandboxPolicy }
-    }));
-    manifest.stateNodeId = dispatchNode.id;
-    for (const task of run.tasks) {
-        if (!taskIds.has(task.id) || !task.stateNodeId)
-            continue;
-        const node = run.nodes?.find((candidate) => candidate.id === task.stateNodeId);
-        if (node && node.status === "pending") {
-            (0, state_node_1.appendRunNode)(run, (0, state_node_1.transitionStateNode)(node, { status: "running", loopStage: "act" }));
-        }
-    }
-    run.dispatches.push({
-        id: dispatchId,
-        phase: manifest.phase || "",
-        taskIds: tasks.map((task) => task.id),
-        manifestPath,
-        createdAt,
-        stateNodeId: dispatchNode.id,
-        workerIds: selectedRunTasks.filter((task) => task.workerId).map((task) => String(task.workerId)),
-        sandboxProfileId: manifest.sandboxProfileId,
-        backendId: backendSelection.backendId,
-        multiAgent: manifest.multiAgent
-    });
-    updatePhaseStatuses(run);
-    (0, state_1.writeJson)(manifestPath, manifest);
-    return manifest;
-}
-function firstRunnablePhase(run) {
-    for (const phase of run.phases) {
-        const phaseTasks = run.tasks.filter((task) => phase.taskIds.includes(task.id));
-        if (phaseTasks.some((task) => task.status === "running"))
-            return phase;
-        if (phaseTasks.some((task) => task.status === "pending"))
-            return phase;
-        if (!phaseTasks.every((task) => task.status === "completed"))
-            return null;
-    }
-    return null;
-}
-function updatePhaseStatuses(run) {
-    for (const phase of run.phases) {
-        const phaseTasks = run.tasks.filter((task) => phase.taskIds.includes(task.id));
-        if (phaseTasks.every((task) => task.status === "completed")) {
-            phase.status = "completed";
-        }
-        else if (phaseTasks.some((task) => task.status === "running" || task.status === "completed")) {
-            phase.status = "running";
-        }
-        else {
-            phase.status = "pending";
-        }
-    }
-}
-function formatDispatchTask(task) {
-    return {
-        id: task.id,
-        kind: task.kind,
-        phase: task.phase,
-        status: task.status,
-        taskPath: task.taskPath,
-        prompt: task.prompt,
-        workerId: task.workerId,
-        workerManifestPath: task.workerManifestPath,
-        workerDir: task.workerManifestPath ? node_path_1.default.dirname(task.workerManifestPath) : undefined,
-        workerResultPath: task.workerId && task.workerManifestPath ? node_path_1.default.join(node_path_1.default.dirname(task.workerManifestPath), "result.md") : undefined,
-        sandboxProfileId: task.sandboxProfileId,
-        sandboxPolicy: task.sandboxPolicy,
-        backendId: task.backendId,
-        backendAttestation: task.backendAttestation,
-        multiAgent: task.multiAgent
-    };
-}
-// Deterministic dispatch id (replay-determinism self-audit): the wall-clock stamp
-// is an edge timestamp for human readability. Set CW_DETERMINISTIC_RUN_IDS=1 to
-// use a content-hash-based id without wall-clock, so re-running the same workflow
-// yields byte-identical dispatch ids. The suffix is a per-run sequence, so each
-// dispatch still gets a distinct, monotonically increasing id.
-function createDispatchId(run) {
-    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
-    const seq = (run.dispatches?.length || 0) + 1;
-    if (/^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || "")) {
-        return `dispatch-${String(seq).padStart(4, "0")}`;
-    }
-    return `dispatch-${stamp}-${String(seq).padStart(4, "0")}`;
-}
-// H7: persist a CUSTOM sandbox profile DEFINITION (loaded from a FILE at dispatch)
-// onto run.customSandboxProfiles, keyed by the definition's logical id. Only fires
-// for a non-bundled id that resolves to a readable, valid profile file. The
-// resolveSandboxProfileById call above has already validated the file (it throws on
-// invalid), so this re-parses only to recover the raw DEFINITION — we store the
-// definition (not a resolved policy) so worker-specific path tokens re-bind to the
-// correct worker context on every later re-resolve. Bundled ids and unknown ids are
-// left untouched, so this never shadows a bundled profile or masks a fail-closed.
-function persistCustomSandboxProfile(run, requested) {
-    if (!requested || (0, sandbox_profile_1.isBundledSandboxProfileId)(requested))
-        return;
-    const absolute = node_path_1.default.resolve(requested);
-    if (!node_fs_1.default.existsSync(absolute) || !node_fs_1.default.statSync(absolute).isFile())
-        return;
-    const validation = (0, sandbox_profile_1.validateSandboxProfileFile)(requested, (0, sandbox_profile_1.sandboxContextForValidation)(run.cwd));
-    if (!validation.valid || !validation.profile)
-        return;
-    let definition;
-    try {
-        definition = JSON.parse(node_fs_1.default.readFileSync(absolute, "utf8"));
-    }
-    catch {
-        return;
-    }
-    if (!definition || typeof definition !== "object" || typeof definition.id !== "string" || !definition.id)
-        return;
-    run.customSandboxProfiles = run.customSandboxProfiles || {};
-    const previous = run.customSandboxProfiles[definition.id];
-    if (previous && JSON.stringify(previous) !== JSON.stringify(definition)) {
-        throw new Error(`Sandbox profile id collision: "${definition.id}" is already defined by a different custom profile ` +
-            `(source: ${absolute}). Use a unique id in each custom profile file.`);
-    }
-    run.customSandboxProfiles[definition.id] = definition;
-}

package/dist/doctor.js

@@ -1,212 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDoctor = runDoctor;
-exports.formatDoctorReport = formatDoctorReport;
-exports.formatDoctorFixes = formatDoctorFixes;
-// `cw doctor` — environment diagnostics, in the spirit of `brew doctor`.
-//
-// Homebrew's `doctor` turned "something is subtly wrong with your setup" into a
-// proactive, named list of problems each paired with a concrete fix. We borrow
-// that idea: instead of letting a missing agent / old Node / unwritable state
-// surface as a confusing mid-run failure, `cw doctor` probes the host up front
-// and prints WHAT is wrong and WHAT TO DO about it.
-//
-// Discipline:
-//  - READ-ONLY. Probes versions, $PATH, and the WRITABILITY of the nearest
-//    existing ancestor dir (via access(2)) — it never creates `.cw/` or $CW_HOME
-//    as a side effect, so running `doctor` changes nothing on disk.
-//  - FAIL CLOSED. Any `fail` check ⇒ `ok:false` ⇒ the CLI exits non-zero. A
-//    `warn` (e.g. no agent yet — demo/preview still work) does not fail.
-//  - TWO RENDERINGS. Human text by default; a stable `--json` payload for scripts.
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const agent_config_1 = require("./agent-config");
-const onramp_1 = require("./onramp");
-const term_1 = require("./term");
-/** Resolve a bare binary name against $PATH (or accept an explicit path). Returns
- *  the resolved path, or undefined when not found. No spawning. */
-function whichBinary(bin, env) {
-    if (bin.includes("/") || bin.includes("\\")) {
-        try {
-            return node_fs_1.default.statSync(bin).isFile() ? bin : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    const dirs = (env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean);
-    const exts = process.platform === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
-    for (const dir of dirs) {
-        for (const ext of exts) {
-            const candidate = node_path_1.default.join(dir, bin + ext);
-            try {
-                if (node_fs_1.default.statSync(candidate).isFile())
-                    return candidate;
-            }
-            catch { /* keep looking */ }
-        }
-    }
-    return undefined;
-}
-/** True when `target` could be created/written: walk up to the nearest EXISTING
- *  ancestor and require it to be a writable DIRECTORY. (A file in the path is not
- *  writable-as-a-dir even though access(2) W_OK on the file itself would pass.)
- *  Does NOT create anything — a diagnostic must not have side effects. */
-function dirWritable(target) {
-    let dir = node_path_1.default.resolve(target);
-    for (;;) {
-        let stat;
-        try {
-            stat = node_fs_1.default.statSync(dir);
-        }
-        catch {
-            const parent = node_path_1.default.dirname(dir);
-            if (parent === dir)
-                return false;
-            dir = parent;
-            continue;
-        }
-        if (!stat.isDirectory())
-            return false; // an existing file blocks mkdir beneath it
-        try {
-            node_fs_1.default.accessSync(dir, node_fs_1.default.constants.W_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-function runDoctor(args = {}, env = process.env, cwd = process.cwd()) {
-    const checks = [];
-    // 1. Node runtime — the one hard prerequisite (README: v18+).
-    const major = Number((process.version.match(/^v(\d+)/) || [])[1]);
-    checks.push(Number.isFinite(major) && major >= 18
-        ? { name: "node", status: "ok", detail: `Node ${process.version} (>= 18).` }
-        : { name: "node", status: "fail", detail: `Node ${process.version} is below the required v18.`, fix: "Install Node.js 18+ (e.g. `brew install node`, or https://nodejs.org)." });
-    // 2. Agent backend — CW delegates execution; without one, real runs park.
-    const cfg = (0, agent_config_1.resolveAgentConfig)(args, env);
-    if (cfg.source === "auto") {
-        const vendor = (cfg.model && cfg.model.startsWith("builtin:")) ? cfg.model.slice("builtin:".length) : "auto";
-        checks.push({
-            name: "agent",
-            status: "ok",
-            detail: `Agent auto-detected: ${vendor}. Set CW_AGENT_COMMAND or --agent-command to override.`
-        });
-    }
-    else if (cfg.source === "none") {
-        checks.push({
-            name: "agent",
-            status: "warn",
-            detail: "No agent backend configured — `demo` and `--preview` work, but a real run reports status: blocked.",
-            fix: 'Pass --agent-command "claude -p", set $CW_AGENT_COMMAND, or use --agent-command builtin:claude.'
-        });
-    }
-    else {
-        const binToken = cfg.command ? String(cfg.command).split(/\s+/)[0] : undefined;
-        checks.push({
-            name: "agent",
-            status: "ok",
-            detail: `Agent configured from ${cfg.source}${binToken ? `: ${binToken}` : cfg.endpoint ? " (HTTP endpoint)" : ""}.`
-        });
-        // 2b. If it is a command agent, is the binary actually on PATH?
-        if (binToken) {
-            const resolved = whichBinary(binToken, env);
-            checks.push(resolved
-                ? { name: "agent-binary", status: "ok", detail: `Agent binary "${binToken}" found at ${resolved}.` }
-                : { name: "agent-binary", status: "warn", detail: `Configured agent binary "${binToken}" is not on $PATH.`, fix: `Install "${binToken}", or correct --agent-command / $CW_AGENT_COMMAND.` });
-        }
-    }
-    // 3. git — only needed for commit provenance (git HEAD); a warn, not a hard fail.
-    const git = (0, node_child_process_1.spawnSync)("git", ["--version"], { encoding: "utf8", timeout: 5000 });
-    checks.push(!git.error && git.status === 0
-        ? { name: "git", status: "ok", detail: (String(git.stdout || "git").trim()) + "." }
-        : { name: "git", status: "warn", detail: "git is not available — commit provenance (git HEAD) is recorded as absent.", fix: "Install git (e.g. `brew install git`) if you want commit provenance." });
-    // 4. Home registry — the cross-repo run index lives here; must be writable.
-    const home = env.CW_HOME && String(env.CW_HOME).trim()
-        ? node_path_1.default.resolve(String(env.CW_HOME))
-        : node_path_1.default.join(node_os_1.default.homedir(), ".local", "state", "cool-workflow");
-    checks.push(dirWritable(home)
-        ? { name: "home-registry", status: "ok", detail: `Home registry location is writable (${home}).` }
-        : { name: "home-registry", status: "fail", detail: `Home registry location is not writable: ${home}`, fix: "Set $CW_HOME to a writable directory, or fix the permissions." });
-    // 5. Working-dir state — per-repo runs land under <cwd>/.cw.
-    const cwState = node_path_1.default.join(node_path_1.default.resolve(cwd), ".cw");
-    checks.push(dirWritable(cwState)
-        ? { name: "repo-state", status: "ok", detail: `Run state location is writable (${cwState}).` }
-        : { name: "repo-state", status: "warn", detail: `Cannot write run state under ${cwState}.`, fix: "Run from a writable working directory, or pass --cwd PATH." });
-    const fails = checks.filter((c) => c.status === "fail").length;
-    const warns = checks.filter((c) => c.status === "warn").length;
-    const ok = fails === 0;
-    const summary = ok
-        ? warns === 0
-            ? "ready — all checks passed"
-            : `ready, with ${warns} warning${warns === 1 ? "" : "s"}`
-        : `${fails} blocking problem${fails === 1 ? "" : "s"} found`;
-    return {
-        schemaVersion: 1,
-        ok,
-        checks,
-        summary,
-        ...((0, onramp_1.optionEnabled)(args.onramp)
-            ? { onramp: (0, onramp_1.buildDoctorOnramp)({ cwd, env, changedFrom: typeof args["changed-from"] === "string" ? args["changed-from"] : undefined }) }
-            : {})
-    };
-}
-/** Human rendering (TTY/default). `--json` callers use the report object directly. */
-function formatDoctorReport(report) {
-    const lines = [(0, term_1.bold)("cw doctor")];
-    for (const check of report.checks) {
-        lines.push(`  ${(0, term_1.doctorGlyph)(check.status)} ${check.name}: ${check.detail}`);
-        if (check.fix && check.status !== "ok")
-            lines.push(`      fix: ${check.fix}`);
-    }
-    lines.push("");
-    const summaryGlyph = report.ok ? (0, term_1.green)("✓") : (0, term_1.red)("✗");
-    lines.push(`${summaryGlyph} ${report.summary}`);
-    if (report.onramp) {
-        lines.push("");
-        lines.push("Quick start (3 steps):");
-        lines.push("  1. cw demo tamper        — prove trust checks work (30s)");
-        lines.push("  2. cw demo bundle         — prove portable bundles (30s)");
-        lines.push('  3. cw -q "what risks?"     — your first real report (needs an agent)');
-        lines.push('     cw quickstart research-synthesis --repo <folder> --question "..."  — cited report over a docs/papers folder, not only code');
-        lines.push("");
-        lines.push("Onramp");
-        lines.push(`  ${report.onramp.summary}`);
-        if (report.onramp.recommendedChecks) {
-            lines.push("");
-            lines.push("  Recommended Checks");
-            for (const command of report.onramp.recommendedChecks.commands)
-                lines.push(`    - ${command}`);
-        }
-        if (report.onramp.contract && !report.onramp.contract.ok) {
-            lines.push("");
-            lines.push("  Contract Issues");
-            for (const issue of report.onramp.contract.issues) {
-                lines.push(`    - ${issue.code}: ${issue.detail}`);
-                lines.push(`      fix: ${issue.fix}`);
-            }
-        }
-        for (const section of report.onramp.sections) {
-            lines.push("");
-            lines.push(`  ${section.title}: ${section.summary}`);
-            for (const action of section.actions) {
-                lines.push(`    - ${action.command}`);
-                lines.push(`      ${action.reason}`);
-            }
-        }
-    }
-    return lines.join("\n");
-}
-/** `--fix` rendering: consolidates all fix strings into an actionable block. */
-function formatDoctorFixes(report) {
-    const fixes = report.checks.filter((c) => c.fix && c.status !== "ok").map((c) => c.fix);
-    if (!fixes.length)
-        return "No fixes needed.";
-    return [(0, term_1.bold)("Fix Commands"), ...fixes.map((f, i) => `  ${i + 1}. ${f}`), ""].join("\n");
-}