xcoder-dna 0.0.0-stage → 1.3.0

package/dist/util/process-kill.js

@@ -0,0 +1,148 @@
+// xcoder:version 1 | xcoder:task task-edfac1 | xcoder:updated 2026-08-04T09:23:09.377Z | xcoder:subtask code-st-21c578
+/**
+ * Cross-platform process tree killer.
+ *
+ * On Windows: uses `taskkill /F /T /PID <pid>`
+ * On Unix: uses `kill(-pid)` to signal the entire process group;
+ *   falls back to recursive pgrep-based killing for resilience.
+ */
+import { execSync } from "node:child_process";
+/**
+ * Kill a process and all of its descendants.
+ *
+ * @param rootPid - The PID of the root process to kill.
+ * @param signal - 'SIGTERM' for graceful, 'SIGKILL' for force.
+ * @returns Promise that resolves when all descendants are confirmed dead or after 3s timeout.
+ */
+export function killProcessTree(rootPid, signal = "SIGKILL") {
+    return new Promise((resolve) => {
+        if (process.platform === "win32") {
+            killWindowsTree(rootPid, signal, resolve);
+        }
+        else {
+            killUnixTree(rootPid, signal, resolve);
+        }
+    });
+}
+function killWindowsTree(rootPid, signal, resolve) {
+    const forceFlag = signal === "SIGKILL" ? " /F" : "";
+    try {
+        execSync(`taskkill${forceFlag} /T /PID ${rootPid}`, {
+            timeout: 3000,
+            stdio: "pipe",
+        });
+    }
+    catch {
+        // taskkill may fail if process already exited — that's fine.
+    }
+    resolve();
+}
+function killUnixTree(rootPid, signal, resolve) {
+    const sigNum = signal === "SIGKILL" ? 9 : 15;
+    // Try process-group kill first (cleanest).
+    try {
+        process.kill(-rootPid, sigNum);
+    }
+    catch {
+        // Process group may not exist; fall through to recursive kill.
+    }
+    // Recursive pgrep kill as a fallback to ensure all children are dead.
+    try {
+        const descendants = getUnixDescendants(rootPid);
+        for (const pid of descendants) {
+            try {
+                process.kill(pid, sigNum);
+            }
+            catch {
+                // process already dead.
+            }
+        }
+    }
+    catch {
+        // pgrep may not be available — process-group kill is best-effort.
+    }
+    // Give a short grace period, then resolve.
+    setTimeout(resolve, 500);
+}
+/**
+ * Recursively collect all child PIDs under rootPid using `pgrep -P`.
+ */
+function getUnixDescendants(rootPid) {
+    const pids = [];
+    try {
+        const raw = execSync(`pgrep -P ${rootPid}`, {
+            timeout: 2000,
+            stdio: "pipe",
+            encoding: "utf8",
+        });
+        const children = raw
+            .trim()
+            .split("\n")
+            .filter(Boolean)
+            .map(Number)
+            .filter((n) => !isNaN(n));
+        for (const child of children) {
+            pids.push(child);
+            // Recurse into grandchildren.
+            pids.push(...getUnixDescendants(child));
+        }
+    }
+    catch {
+        // pgrep may not be available or already exited.
+    }
+    return pids;
+}
+// ── Global tracked PIDs ──
+/**
+ * A Set of tracked child process PIDs. Used by the signal handler to
+ * kill any surviving child processes on forced exit.
+ */
+export const trackedPids = new Set();
+/**
+ * Register a pid for cleanup tracking. Safe to call multiple times
+ * (Set deduplicates).
+ */
+export function trackPid(pid) {
+    trackedPids.add(pid);
+}
+/**
+ * Remove a pid from tracking (called when process exits normally).
+ */
+export function untrackPid(pid) {
+    trackedPids.delete(pid);
+}
+/**
+ * Kill all tracked PIDs and clear the set. Used in process 'exit'
+ * handler as a safety net to prevent orphaned processes.
+ */
+export async function killTrackedPids() {
+    const pids = Array.from(trackedPids);
+    trackedPids.clear();
+    for (const pid of pids) {
+        await killProcessTree(pid, "SIGKILL");
+    }
+}
+// Register an exit handler that kills any remaining tracked PIDs.
+process.on("exit", () => {
+    // Synchronous cleanup on exit: spawn taskkill/kill synchronously.
+    const pids = Array.from(trackedPids);
+    trackedPids.clear();
+    for (const pid of pids) {
+        try {
+            if (process.platform === "win32") {
+                execSync(`taskkill /F /T /PID ${pid}`, { timeout: 2000, stdio: "ignore" });
+            }
+            else {
+                try {
+                    process.kill(-pid, 9);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch {
+            // ignore — process already dead.
+        }
+    }
+});

package/dist/util/protocol-error-logger.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Called once at startup by the CLI action handler when --debug-protocol-error
+ * or PROTOCOL_ERROR_LOG is active. Sets module-level enabled flag. If logPath
+ * is provided, uses it; otherwise defaults to <cwd>/protocol_error.log.
+ */
+export declare function enableProtocolErrorLogging(customPath?: string, opts?: {
+    silent?: boolean;
+}): void;
+/** Read-only guard so call sites can conditionally gather data. */
+export declare function isProtocolErrorLoggingEnabled(): boolean;
+/** The data contract for each ndjson line. */
+export interface ProtocolErrorLogEntry {
+    ts: string;
+    taskId: string;
+    agentId: string;
+    iteration: number;
+    error: string;
+    raw: string;
+    model: string;
+    stopReason: string | null;
+    inputTokens: number;
+    outputTokens: number;
+}
+/**
+ * Appends one ndjson line to the log file. Never throws — all write
+ * failures are silently swallowed. Uses an internal promise-chain mutex to
+ * serialise appends without blocking the caller.
+ *
+ * On the FIRST call, writes a `#`-prefixed header block if the file
+ * doesn't already exist (checked via synchronous existsSync — cheap,
+ * and only happens on the first error which is rare).
+ */
+export declare function logProtocolError(entry: ProtocolErrorLogEntry): void;

package/dist/util/protocol-error-logger.js

@@ -0,0 +1,73 @@
+// xcoder:version 1 | xcoder:task task-54c54e | xcoder:updated 2026-08-04T15:30:01.164Z | xcoder:subtask code-st-43fc58
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { log } from "./logger.js";
+import { getOutputPaths } from "./output-paths.js";
+// ── Module-level state ──
+let enabled = false;
+let logPath = null;
+/** Serialises writes so parallel agents don't interleave lines. */
+let writeChain = Promise.resolve();
+let headerWritten = false;
+// ── Public API ──
+/**
+ * Called once at startup by the CLI action handler when --debug-protocol-error
+ * or PROTOCOL_ERROR_LOG is active. Sets module-level enabled flag. If logPath
+ * is provided, uses it; otherwise defaults to <cwd>/protocol_error.log.
+ */
+export function enableProtocolErrorLogging(customPath, opts) {
+    enabled = true;
+    if (customPath) {
+        logPath = path.resolve(customPath);
+    }
+    else {
+        const outputs = getOutputPaths();
+        outputs.ensureGitignore();
+        logPath = outputs.protocolErrorLogPath();
+    }
+    if (!opts?.silent) {
+        log.dim(`protocol_error diagnostic log: ${logPath}`);
+    }
+}
+/** Read-only guard so call sites can conditionally gather data. */
+export function isProtocolErrorLoggingEnabled() {
+    return enabled;
+}
+/**
+ * Appends one ndjson line to the log file. Never throws — all write
+ * failures are silently swallowed. Uses an internal promise-chain mutex to
+ * serialise appends without blocking the caller.
+ *
+ * On the FIRST call, writes a `#`-prefixed header block if the file
+ * doesn't already exist (checked via synchronous existsSync — cheap,
+ * and only happens on the first error which is rare).
+ */
+export function logProtocolError(entry) {
+    if (!enabled || !logPath)
+        return;
+    writeChain = writeChain.then(async () => {
+        try {
+            // Write header once, before the first entry.
+            if (!headerWritten) {
+                const fileExists = fs.existsSync(logPath);
+                if (!fileExists) {
+                    const header = [
+                        "# Xcoder SDLC protocol_error diagnostic log",
+                        `# Created: ${new Date().toISOString()}`,
+                        "# Fields: ts, taskId, agentId, iteration, error, raw, model, stopReason, inputTokens, outputTokens",
+                        "# Enabled by: --debug-protocol-error flag | PROTOCOL_ERROR_LOG env var",
+                        "",
+                    ].join("\n");
+                    await fsp.appendFile(logPath, header, "utf-8");
+                }
+                headerWritten = true;
+            }
+            const line = JSON.stringify(entry) + "\n";
+            await fsp.appendFile(logPath, line, "utf-8");
+        }
+        catch {
+            // Silently swallow — diagnostic logging must never break the agent loop.
+        }
+    });
+}

package/dist/util/redact.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Secret redaction for prompt/LLM logging (PRM-10 / CORE-07 / CORE-08).
+ *
+ * `appendLlm` runs every request/response body through `redactSecrets` before
+ * writing, so a key pasted into a prompt, echoed by a model, or captured in a
+ * tool observation never lands in the task llm.log under `.xcoder/logs`.
+ *
+ * Deliberately has NO module-load dependency on config/secret values — that
+ * would create a circular import with config loading. Pattern-based only.
+ * Never throws.
+ */
+export interface RedactionCount {
+    readonly kind: string;
+    readonly count: number;
+}
+export interface RedactionResult {
+    readonly text: string;
+    readonly redactions: readonly RedactionCount[];
+}
+export declare const REDACTED = "[REDACTED]";
+/**
+ * Masks API-key shapes, bearer tokens, private-key blocks and secret
+ * assignments. Never throws; benign text is returned unchanged.
+ */
+export declare function redactSecrets(text: string): RedactionResult;

package/dist/util/redact.js

@@ -0,0 +1,103 @@
+// xcoder:version 3 | xcoder:task task-ebf4f7 | xcoder:updated 2026-10-17T12:17:28.413Z | xcoder:subtask test-st-f454da
+/**
+ * Secret redaction for prompt/LLM logging (PRM-10 / CORE-07 / CORE-08).
+ *
+ * `appendLlm` runs every request/response body through `redactSecrets` before
+ * writing, so a key pasted into a prompt, echoed by a model, or captured in a
+ * tool observation never lands in the task llm.log under `.xcoder/logs`.
+ *
+ * Deliberately has NO module-load dependency on config/secret values — that
+ * would create a circular import with config loading. Pattern-based only.
+ * Never throws.
+ */
+export const REDACTED = "[REDACTED]";
+const RULES = [
+    // PEM private-key blocks (RSA/EC/OPENSSH/PGP and the generic PRIVATE KEY).
+    {
+        kind: "private-key",
+        pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+        replacement: "-----BEGIN PRIVATE KEY-----" + REDACTED + "-----END PRIVATE KEY-----",
+    },
+    // Authorization headers, any casing, bearer/basic/token schemes.
+    {
+        kind: "authorization-header",
+        pattern: /(Authorization[ \t]*:[ \t]*)(?:Bearer|Basic|Token)?[ \t]*[A-Za-z0-9._\-+/=]{8,}/gi,
+        replacement: "Authorization: " + REDACTED,
+    },
+    // OpenAI / Anthropic / DeepSeek style keys.
+    {
+        kind: "api-key",
+        pattern: /sk-[A-Za-z0-9_\-]{12,}/g,
+        replacement: "sk-" + REDACTED,
+    },
+    // GitHub tokens.
+    {
+        kind: "github-token",
+        pattern: /(?:gh[pousr]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,})/g,
+        replacement: REDACTED,
+    },
+    // AWS access key ids.
+    {
+        kind: "aws-access-key",
+        pattern: /(?:AKIA|ASIA)[0-9A-Z]{16}/g,
+        replacement: REDACTED,
+    },
+    // Slack / Google style tokens.
+    {
+        kind: "platform-token",
+        pattern: /(?:xox[baprs]-[A-Za-z0-9\-]{10,}|AIza[0-9A-Za-z_\-]{35})/g,
+        replacement: REDACTED,
+    },
+    // KEY=value / KEY: value assignments for secret-sounding names.
+    {
+        kind: "secret-assignment",
+        pattern: /([A-Za-z0-9_]*(?:API[_-]?KEY|SECRET|TOKEN|PASSWORD|PASSWD|CREDENTIAL)[A-Za-z0-9_]*)[ \t]*[=:][ \t]*["']?([^\s"',;]{6,})/gi,
+        replacement: REDACTED,
+    },
+    // userinfo embedded in a URL: scheme://user:password@host
+    {
+        kind: "url-credentials",
+        pattern: /([a-z][a-z0-9+\-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi,
+        replacement: "$1" + REDACTED + "@",
+    },
+];
+function redactOnce(text, hits) {
+    let out = text;
+    for (const rule of RULES) {
+        rule.pattern.lastIndex = 0;
+        let count = 0;
+        out = out.replace(rule.pattern, (...args) => {
+            count++;
+            const match = args[0];
+            const groups = args.slice(1, -2);
+            if (typeof rule.replacement === "function") {
+                return rule.replacement(match, ...groups);
+            }
+            // Expand simple $1 style backreferences in the replacement string.
+            return rule.replacement.replace(/\$(\d+)/g, (_m, d) => groups[Number(d) - 1] ?? "");
+        });
+        if (count > 0)
+            hits.set(rule.kind, (hits.get(rule.kind) ?? 0) + count);
+    }
+    return out;
+}
+/**
+ * Masks API-key shapes, bearer tokens, private-key blocks and secret
+ * assignments. Never throws; benign text is returned unchanged.
+ */
+export function redactSecrets(text) {
+    try {
+        if (typeof text !== "string" || text.length === 0) {
+            return { text: typeof text === "string" ? text : "", redactions: [] };
+        }
+        const hits = new Map();
+        const once = redactOnce(text, hits);
+        const twice = redactOnce(once, hits);
+        const redactions = [...hits.entries()].map(([kind, count]) => ({ kind, count }));
+        return { text: twice, redactions };
+    }
+    catch {
+        // Fail safe: emit no text rather than risk a leak.
+        return { text: REDACTED, redactions: [{ kind: "error", count: 1 }] };
+    }
+}

package/dist/util/scroll-region-guard.d.ts

@@ -0,0 +1,33 @@
+import type { FooterState } from "./footer-state.js";
+import type { FooterRenderer } from "./footer-renderer.js";
+/**
+ * ScrollRegionGuard — defensive layer that makes ALL stdout writes safe
+ * regardless of their source. When the footer has reserved a scroll region
+ * (bottom row), any write to stdout that scrolls the terminal will push
+ * the reserved footer row out of view. This guard intercepts writes,
+ * temporarily resets the scroll region to full-screen so the write lands
+ * correctly, then re-establishes the scroll region and re-renders the
+ * footer — keeping it pinned to the bottom row.
+ *
+ * Design: wraps process.stdout.write at a low level, so that ora, clack,
+ * thinking-spinner, and agent output all pass through this guard without
+ * requiring changes to those libraries.
+ */
+export interface ScrollRegionGuard {
+    /** Write safely within the scrollable area without displacing the footer. */
+    write(text: string): void;
+    /** Convenience: write(text + '\n'). */
+    writeln(text: string): void;
+    /** Force re-apply the scroll region (used after resize or after hide/show). */
+    reestablish(): void;
+    /** Reset scroll region to full screen, clear footer row. */
+    teardown(): void;
+}
+/**
+ * Create a ScrollRegionGuard that wraps writes to protect the footer's
+ * reserved bottom row.
+ *
+ * @param footerRenderer - The FooterRenderer instance (for re-rendering after writes).
+ * @param getState - A function returning the current FooterState (for re-render).
+ */
+export declare function createScrollRegionGuard(footerRenderer: FooterRenderer, getState: () => FooterState): ScrollRegionGuard;

package/dist/util/scroll-region-guard.js

@@ -0,0 +1,63 @@
+// ── ANSI sequences ──
+const SAVE_CURSOR = "\x1b7";
+const RESTORE_CURSOR = "\x1b8";
+const RESET_SCROLL_REGION = "\x1b[r";
+const CURSOR_TO_BOTTOM = "\x1b[999;1H";
+const CLEAR_LINE = "\x1b[2K";
+/**
+ * Create a ScrollRegionGuard that wraps writes to protect the footer's
+ * reserved bottom row.
+ *
+ * @param footerRenderer - The FooterRenderer instance (for re-rendering after writes).
+ * @param getState - A function returning the current FooterState (for re-render).
+ */
+export function createScrollRegionGuard(footerRenderer, getState) {
+    let active = false;
+    function getScrollBottom() {
+        const height = process.stdout.rows ?? 24;
+        return Math.max(1, height - 1);
+    }
+    function writeToStdout(text) {
+        process.stdout.write(text);
+    }
+    const guard = {
+        write(text) {
+            if (!active) {
+                writeToStdout(text);
+                return;
+            }
+            const scrollBottom = getScrollBottom();
+            const state = getState();
+            // Save cursor position
+            writeToStdout(SAVE_CURSOR);
+            // Reset scroll region to full screen so the write doesn't displace the footer
+            writeToStdout(RESET_SCROLL_REGION);
+            // Perform the actual write
+            writeToStdout(text);
+            // Re-establish the scroll region, keeping the bottom row reserved
+            writeToStdout(`\x1b[1;${scrollBottom}r`);
+            // Re-render the footer on the bottom row
+            footerRenderer.forceRender(state);
+            // Restore cursor position (so the caller's cursor tracking isn't broken)
+            writeToStdout(RESTORE_CURSOR);
+        },
+        writeln(text) {
+            guard.write(text + "\n");
+        },
+        reestablish() {
+            const scrollBottom = getScrollBottom();
+            writeToStdout(RESET_SCROLL_REGION);
+            writeToStdout(`\x1b[1;${scrollBottom}r`);
+            const state = getState();
+            footerRenderer.forceRender(state);
+        },
+        teardown() {
+            active = false;
+            writeToStdout(RESET_SCROLL_REGION);
+            // Clear the footer row
+            writeToStdout(CURSOR_TO_BOTTOM);
+            writeToStdout(CLEAR_LINE);
+        },
+    };
+    return guard;
+}

package/dist/util/spinner.d.ts

@@ -0,0 +1,15 @@
+export declare const AVAILABLE_SPINNER_STYLES: readonly ["clack", ...string[]];
+/**
+ * `--spinner <style>`: "clack" (default, Anthropic's own prompt library's
+ * spinner) or any named style from `cli-spinners` (the same package `ora`
+ * itself uses) — "dots", "line", "arc", "bounceBar", "star", etc. Falls
+ * back to "clack" on an unrecognized name rather than throwing, since a
+ * bad `--spinner` value shouldn't stop a task from running.
+ */
+export declare function setSpinnerStyle(style: string | undefined): void;
+export declare function getSpinnerStyle(): string;
+export interface SpinnerHandle {
+    stop(message: string): void;
+    fail(message: string): void;
+}
+export declare function createSpinner(startMessage: string): SpinnerHandle;

package/dist/util/spinner.js

@@ -0,0 +1,49 @@
+import * as clack from "@clack/prompts";
+import ora from "ora";
+import cliSpinners from "cli-spinners";
+export const AVAILABLE_SPINNER_STYLES = ["clack", ...Object.keys(cliSpinners)];
+let activeStyle = "clack";
+/**
+ * `--spinner <style>`: "clack" (default, Anthropic's own prompt library's
+ * spinner) or any named style from `cli-spinners` (the same package `ora`
+ * itself uses) — "dots", "line", "arc", "bounceBar", "star", etc. Falls
+ * back to "clack" on an unrecognized name rather than throwing, since a
+ * bad `--spinner` value shouldn't stop a task from running.
+ */
+export function setSpinnerStyle(style) {
+    if (!style)
+        return;
+    if (style === "clack" || style in cliSpinners) {
+        activeStyle = style;
+    }
+    else {
+        console.error(`Unknown --spinner "${style}". Using "clack". Available: clack, ${Object.keys(cliSpinners).slice(0, 12).join(", ")}, ... ` +
+            `(${Object.keys(cliSpinners).length} total from cli-spinners)`);
+    }
+}
+export function getSpinnerStyle() {
+    return activeStyle;
+}
+export function createSpinner(startMessage) {
+    if (activeStyle === "clack") {
+        const s = clack.spinner();
+        s.start(startMessage);
+        return {
+            stop: (msg) => s.stop(msg),
+            fail: (msg) => s.stop(msg, 1),
+        };
+    }
+    // Cast is safe: `activeStyle` is validated against `cliSpinners`'s own keys
+    // in `setSpinnerStyle` before it can ever reach here (or is the literal
+    // "clack" string, handled in the branch above).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const instance = ora({ text: startMessage, spinner: activeStyle }).start();
+    return {
+        stop: (msg) => {
+            instance.succeed(msg);
+        },
+        fail: (msg) => {
+            instance.fail(msg);
+        },
+    };
+}

package/dist/util/terminal-output.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interface for per-agent terminal output. The real terminal module
+ * (terminal.ts) conforms to this implicitly; SilentTerminal is a no-op
+ * implementation for UI-submitted tasks.
+ */
+export interface TerminalOutput {
+    startThinking(agentId: string): {
+        stop(thought: string): void;
+        fail(msg: string): void;
+    };
+    printAction(agentId: string, tool: string, input: unknown): void;
+    printObservation(agentId: string, ok: boolean, text: string): void;
+    printTokens(agentId: string, turn: {
+        inputTokens: number;
+        outputTokens: number;
+    }, cumulative: {
+        inputTokens: number;
+        outputTokens: number;
+    }): void;
+    printProtocolError(agentId: string, message: string): void;
+    printDuplicateWarning(agentId: string, message: string): void;
+    printCrash(agentId: string, message: string): void;
+    printFinalAnswer(agentId: string, summary: string): void;
+    taskIntro(taskId: string, goal: string): void;
+    taskOutro(status: string): void;
+    orchestratorNote(message: string): void;
+    printInterruptSummary(summary: {
+        taskId: string;
+        doneCount: number;
+        totalCount: number;
+        command: string;
+        file: string;
+    }): void;
+}

package/dist/util/terminal-output.js

@@ -0,0 +1 @@
+export {};

package/dist/util/terminal-silent.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalOutput } from "./terminal-output.js";
+/**
+ * No-op terminal adapter for `quiet` runs (swarm / sub-agent).
+ * Suppresses all per-agent console output; events still flow on the bus.
+ */
+export declare const silentTerminal: TerminalOutput;

package/dist/util/terminal-silent.js

@@ -0,0 +1,20 @@
+/**
+ * No-op terminal adapter for `quiet` runs (swarm / sub-agent).
+ * Suppresses all per-agent console output; events still flow on the bus.
+ */
+export const silentTerminal = {
+    startThinking(_agentId) {
+        return { stop: () => { }, fail: () => { } };
+    },
+    printAction(..._args) { },
+    printObservation(..._args) { },
+    printTokens(..._args) { },
+    printProtocolError(..._args) { },
+    printDuplicateWarning(..._args) { },
+    printCrash(..._args) { },
+    printFinalAnswer(..._args) { },
+    taskIntro(..._args) { },
+    taskOutro(..._args) { },
+    orchestratorNote(..._args) { },
+    printInterruptSummary(..._args) { },
+};

package/dist/util/terminal.d.ts

@@ -0,0 +1,56 @@
+/**
+ * One spinner per Sub Agent turn — "thinking" while the LLM call is in
+ * flight. This is the piece that makes a long silent wait (previously
+ * indistinguishable from a hang, which is part of what made a crash look
+ * like nothing was happening) visibly alive. Backend/style is selectable
+ * via `--spinner` — see `util/spinner.ts`.
+ */
+export declare function startThinking(agentId: string): {
+    stop: (thought: string) => void;
+    fail: (message: string) => void;
+};
+export declare function printAction(agentId: string, tool: string, input: unknown): void;
+export declare function printObservation(agentId: string, ok: boolean, text: string): void;
+export declare function printTokens(agentId: string, turn: {
+    inputTokens: number;
+    outputTokens: number;
+}, cumulative: {
+    inputTokens: number;
+    outputTokens: number;
+}): void;
+export declare function printProtocolError(agentId: string, message: string): void;
+export declare function printDuplicateWarning(agentId: string, message: string): void;
+export declare function printCrash(agentId: string, message: string): void;
+export declare function printFinalAnswer(agentId: string, summary: string): void;
+export declare function taskIntro(taskId: string, goal: string): void;
+export declare function taskOutro(status: string): void;
+export declare function orchestratorNote(message: string): void;
+/**
+ * Printed exactly once per interrupt, after state is flushed to disk.
+ * Shows task ID, done/total count, exact --resume command, and file path.
+ */
+export declare function printInterruptSummary(summary: {
+    taskId: string;
+    doneCount: number;
+    totalCount: number;
+    resumeCommand: string;
+    taskFilePath: string;
+}): void;
+/**
+ * Print a color-coded summary of an Instance Swarm run.
+ * Uses the same palette as the rest of the terminal module:
+ * - green for completed workers
+ * - coral for crashed/failed workers
+ * - amber for the swarm-level status line
+ * - dim for metadata (tokens, output dir)
+ */
+export declare function printSwarmSummary(result: {
+    instanceId: string;
+    status: "completed" | "failed" | "timeout";
+    errors: string[];
+    workerCount: number;
+    crashedCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    outputDir: string;
+}): void;