xcoder-dna 0.0.0-stage → 1.3.0

package/dist/util/footer-renderer.js

@@ -0,0 +1,319 @@
+import { titleField, versionLabel } from "./footer-text.js";
+/**
+ * ANSI escape sequences for the built-in terminal color palette.
+ * Matches the existing palette in terminal.ts.
+ */
+const C = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    amber: "\x1b[38;5;214m",
+    cyan: "\x1b[38;5;80m",
+    green: "\x1b[38;5;78m",
+    coral: "\x1b[38;5;203m",
+    violet: "\x1b[38;5;140m",
+    white: "\x1b[38;5;255m",
+    bgFooter: "\x1b[48;5;236m",
+};
+// ── Scroll region helpers ──
+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";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+// Scroll up by 1 to make room for the footer when enabling.
+const SCROLL_UP = "\x1b[1S";
+/** Resolve current terminal width, with a fallback. */
+function getWidth() {
+    if (process.stdout && typeof process.stdout.columns === "number" && process.stdout.columns > 0) {
+        return process.stdout.columns;
+    }
+    return 80;
+}
+/** Truncate a single segment with "…" if too long. */
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + "…";
+}
+/** Spinner frames compatible with clack — simple Braille spinner. */
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Converts a FooterState into a single ANSI escape sequence string
+ * that paints a 1-row footer at the bottom of the terminal.
+ *
+ * Design:
+ * - 1-row footer using scroll region to reserve the bottom line.
+ * - Truncation priority: stage+spinner > action > tokens > agentId > taskDesc > docs.
+ * - Respects NO_COLOR and TTY detection.
+ * - Handles window resize by re-reading process.stdout.columns.
+ */
+export class FooterRenderer {
+    _active = false;
+    _hidden = false;
+    _spinnerIdx = 0;
+    _spinnerInterval = null;
+    _currentState = null;
+    _noColor = false;
+    /**
+     * Perform one-time setup: enable scroll region, hide cursor.
+     * Must be called before render(). Safe to call when already active (no-op).
+     */
+    setup(state) {
+        this._noColor = !state.tty;
+        if (!state.tty || this._active)
+            return;
+        this._active = true;
+        this._hidden = false;
+        // Reserve bottom row via scroll region (all rows except last).
+        const height = process.stdout.rows ?? 24;
+        // Scroll region: rows 1 to (height - 1), keeping row `height` free.
+        const scrollBottom = Math.max(1, height - 1);
+        process.stdout.write(HIDE_CURSOR);
+        process.stdout.write(`\x1b[1;${scrollBottom}r`);
+        this._render(state);
+    }
+    /**
+     * Render the current state to the reserved bottom row.
+     * Handles layout, truncation, and spinner animation.
+     */
+    render(state) {
+        if (!this._active || this._hidden || !state.tty) {
+            this._currentState = state;
+            return;
+        }
+        this._render(state);
+    }
+    /** Re-read terminal size and re-apply scroll region after a resize. */
+    reconfigure(state, partial) {
+        if (!state.tty || !this._active)
+            return;
+        const height = process.stdout.rows ?? 24;
+        const scrollBottom = Math.max(1, height - 1);
+        process.stdout.write(RESET_SCROLL_REGION);
+        process.stdout.write(`\x1b[1;${scrollBottom}r`);
+        if (partial) {
+            this.render({ ...state, ...partial });
+        }
+        else {
+            this.render(state);
+        }
+    }
+    /** Temporarily hide the footer (e.g. during interrupt prompts). */
+    hide() {
+        if (!this._active || this._hidden)
+            return;
+        this._hidden = true;
+        process.stdout.write(RESET_SCROLL_REGION);
+        process.stdout.write(SHOW_CURSOR);
+        // Clear the footer row.
+        this._clearFooterRow();
+    }
+    /** Restore the footer after being hidden. */
+    show(state) {
+        if (!this._active || !this._hidden)
+            return;
+        this._hidden = false;
+        const height = process.stdout.rows ?? 24;
+        const scrollBottom = Math.max(1, height - 1);
+        process.stdout.write(HIDE_CURSOR);
+        process.stdout.write(`\x1b[1;${scrollBottom}r`);
+        if (this._currentState) {
+            this._render(this._currentState);
+        }
+        else {
+            this._render(state);
+        }
+    }
+    /**
+     * Return the current reserved scroll-region bottom row index (height - 1).
+     * Used by ScrollRegionGuard to know which row to keep free.
+     */
+    getScrollBottom() {
+        const height = process.stdout.rows ?? 24;
+        return Math.max(1, height - 1);
+    }
+    /**
+     * Force-render the footer without checking _hidden/_active guards.
+     * Used by ScrollRegionGuard during re-establish after a guarded write.
+     */
+    forceRender(state) {
+        if (!state.tty)
+            return;
+        this._render(state);
+    }
+    /**
+     * Write text above the footer safely. Saves cursor, resets scroll region,
+     * writes the text, re-establishes scroll region, re-renders footer,
+     * and restores cursor. This is the core defensive write — it ensures
+     * no output can break the scroll region.
+     */
+    writeAbove(text, state) {
+        if (!this._active || !state.tty) {
+            process.stdout.write(text);
+            return;
+        }
+        const scrollBottom = this.getScrollBottom();
+        // Save cursor
+        process.stdout.write(SAVE_CURSOR);
+        // Reset scroll region so write lands in the scrollable area
+        process.stdout.write(RESET_SCROLL_REGION);
+        // Perform the write
+        process.stdout.write(text);
+        // Re-establish scroll region
+        process.stdout.write(`\x1b[1;${scrollBottom}r`);
+        // Re-render footer
+        this.forceRender(state);
+        // Restore cursor
+        process.stdout.write(RESTORE_CURSOR);
+    }
+    /**
+     * Tear down: reset scroll region, show cursor, clear footer.
+     */
+    teardown() {
+        if (!this._active)
+            return;
+        this._active = false;
+        this._hidden = false;
+        if (this._spinnerInterval) {
+            clearInterval(this._spinnerInterval);
+            this._spinnerInterval = null;
+        }
+        process.stdout.write(RESET_SCROLL_REGION);
+        process.stdout.write(SHOW_CURSOR);
+        this._clearFooterRow();
+    }
+    // ── private helpers ──
+    _render(state) {
+        this._currentState = state;
+        const width = getWidth();
+        // Build PAINTED segments as {text,color} — never measure colour codes.
+        // Order is fixed by design §3.7: phase, action, tokens, agent, TITLE, docs.
+        const segs = [];
+        // Stage (amber) + optional spinner
+        if (state.stage) {
+            const frame = SPINNER_FRAMES[this._spinnerIdx % SPINNER_FRAMES.length];
+            const stageText = state.spinner ? `${frame} ${state.stage}` : state.stage;
+            segs.push({ text: stageText, color: C.amber });
+        }
+        // Action
+        if (state.action) {
+            segs.push({ text: state.action, color: C.cyan });
+        }
+        // Tokens
+        if (state.tokens) {
+            segs.push({ text: state.tokens, color: C.dim });
+        }
+        // AgentId
+        if (state.agentId) {
+            segs.push({ text: `[${state.agentId}]`, color: C.green });
+        }
+        // Task title — the ≤50-char field. sanitizeTitle() also strips terminal
+        // control characters, so an untrusted goal can never inject ANSI here.
+        const title = titleField(state.taskDesc);
+        if (title) {
+            segs.push({ text: title, color: C.white });
+        }
+        // Docs
+        if (state.docs) {
+            segs.push({ text: state.docs, color: C.dim });
+        }
+        // Protected tail: "Xcoder <version>". Required fields are never the thing
+        // that gets dropped, so the core cluster is truncated to make room for it.
+        const tail = versionLabel(state.version);
+        const tailGap = 2; // two spaces between core and tail
+        const coreBudget = Math.max(0, width - visibleLength(tail) - (tail ? tailGap : 0));
+        const core = composeCore(segs, coreBudget, this._noColor);
+        const plain = tail ? (core ? `${core}${" ".repeat(tailGap)}${tail}` : tail) : core;
+        // Pad to full width (visible length, so ANSI codes don't inflate the count).
+        const pad = Math.max(0, width - visibleLength(plain));
+        const padded = plain + " ".repeat(pad);
+        // Paint the full line with background
+        const bgLine = this._noColor ? padded : `${C.bgFooter}${padded}${C.reset}`;
+        // Write: save cursor, go to bottom row, draw, restore cursor
+        process.stdout.write(SAVE_CURSOR);
+        process.stdout.write(CURSOR_TO_BOTTOM);
+        process.stdout.write(CLEAR_LINE);
+        process.stdout.write(bgLine);
+        process.stdout.write(RESTORE_CURSOR);
+    }
+    _clearFooterRow() {
+        process.stdout.write(CURSOR_TO_BOTTOM);
+        process.stdout.write(CLEAR_LINE);
+    }
+    /**
+     * Start spinner tick — called by FooterManager when initiating thinking.
+     * Managed here so the renderer owns the interval lifecycle.
+     */
+    startSpinner() {
+        if (this._spinnerInterval)
+            return;
+        this._spinnerInterval = setInterval(() => {
+            this._spinnerIdx++;
+            if (this._currentState && this._currentState.tty && !this._hidden) {
+                this._render({ ...this._currentState, spinner: true });
+            }
+        }, 100);
+    }
+    /**
+     * Stop spinner tick — called by FooterManager when thinking stops.
+     */
+    stopSpinner() {
+        if (this._spinnerInterval) {
+            clearInterval(this._spinnerInterval);
+            this._spinnerInterval = null;
+        }
+    }
+}
+function paint(code, text, noColor) {
+    return noColor ? text : `${code}${text}${C.reset}`;
+}
+/** ANSI CSI/OSC sequence matcher — used ONLY to measure, never to render. */
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b[\]P^_][\s\S]*?(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+/**
+ * Visible (printable) length of a string. Escape sequences occupy no terminal
+ * columns, so measuring `.length` on a paint()ed string inflates the count and
+ * silently truncated the footer short — the defect this replaced.
+ */
+function visibleLength(text) {
+    if (!text)
+        return 0;
+    return text.replace(ANSI_RE, "").length;
+}
+/**
+ * Join segments with a dim ` │ ` separator and truncate the result to `budget`
+ * VISIBLE characters (ending in `…`).
+ *
+ * Segments are consumed in priority order (phase first, docs last), so the
+ * optional tail is what gets dropped on a narrow terminal.
+ */
+function composeCore(segs, budget, noColor) {
+    if (segs.length === 0 || budget <= 0)
+        return "";
+    const sepVisible = 3; // " │ "
+    let used = 0;
+    const kept = [];
+    for (const seg of segs) {
+        const cost = visibleLength(seg.text) + (kept.length > 0 ? sepVisible : 0);
+        if (used + cost <= budget) {
+            kept.push(seg);
+            used += cost;
+            continue;
+        }
+        // Does not fit whole — take as much as the budget allows, appending "…"
+        // so the reader knows text was dropped.
+        const room = budget - used - (kept.length > 0 ? sepVisible : 0);
+        if (room > 1) {
+            const cut = Array.from(seg.text).slice(0, room - 1).join("") + "…";
+            kept.push({ text: cut, color: seg.color });
+        }
+        break;
+    }
+    if (kept.length === 0)
+        return "";
+    const sep = paint(C.dim, " │ ", noColor);
+    return kept.map((s) => paint(s.color, s.text, noColor)).join(sep);
+}

package/dist/util/footer-state.d.ts

@@ -0,0 +1,34 @@
+import type { SdlcStage } from "../types.js";
+/**
+ * The current values for every footer field.
+ * Single source of truth — FooterManager writes, FooterRenderer reads.
+ */
+export interface FooterState {
+    /** Current SDLC stage, derived from the DAG. */
+    stage: SdlcStage | null;
+    /** Agent currently thinking (or null if idle). */
+    agentId: string | null;
+    /**
+     * RAW task title. NOT pre-truncated by callers — the renderer owns the
+     * 50-character field (`titleField()` in footer-text.ts).
+     */
+    taskDesc: string | null;
+    /** Last action tool name. */
+    action: string | null;
+    /** Whether an observation is in flight. */
+    observing: boolean;
+    /** Whether the spinner should be active. */
+    spinner: boolean;
+    /** Cumulative token usage display string. */
+    tokens: string | null;
+    /** Document count or doc-related info. */
+    docs: string | null;
+    /** Whether the terminal supports ANSI (TTY + no NO_COLOR). */
+    tty: boolean;
+    /** Version string injected by FooterManager from XCODER_VERSION. null = omit the token. */
+    version: string | null;
+}
+/**
+ * Creates a default, idle footer state.
+ */
+export declare function createFooterState(overrides?: Partial<FooterState>): FooterState;

package/dist/util/footer-state.js

@@ -0,0 +1,18 @@
+/**
+ * Creates a default, idle footer state.
+ */
+export function createFooterState(overrides) {
+    return {
+        stage: null,
+        agentId: null,
+        taskDesc: null,
+        action: null,
+        observing: false,
+        spinner: false,
+        tokens: null,
+        docs: null,
+        tty: false,
+        version: null,
+        ...overrides,
+    };
+}

package/dist/util/footer-text.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Footer text fields — the single place that decides what the task-title and
+ * version fields of the bottom footer look like.
+ *
+ * Why this is a separate module: the title comes from an untrusted source
+ * (`run.spec.goal`, which can originate from a CLI argument, an ingested
+ * markdown/WBS file, or a backlog item). Anything written to stdout is an
+ * interpreter input for the terminal emulator, so it is sanitised HERE, once,
+ * rather than trusted at every call site (PRM-01, PRM-08).
+ */
+/** Maximum visible characters the task-title field may occupy (design AC-9). */
+export declare const FOOTER_TITLE_MAX = 50;
+/** Single-character ellipsis used when a title is cut. */
+export declare const ELLIPSIS = "\u2026";
+/**
+ * Strip terminal-control characters from untrusted text before it reaches
+ * stdout.
+ *
+ * Removes:
+ *  - `ESC` (0x1B) and any other C0 control (`0x00-0x1F`), which is what makes
+ *    ANSI CSI/OSC sequences possible (colour, cursor moves, OSC-52 clipboard
+ *    writes, window-title sets).
+ *  - `DEL` (0x7F) and the C1 block (`0x80-0x9F`), the 8-bit equivalents of
+ *    the same sequences.
+ *
+ * Newlines, carriage returns and tabs are collapsed to a single space first so
+ * a title can never break the one-row footer layout.
+ *
+ * This is a security control, not cosmetics — see design section 6.
+ */
+export declare function sanitizeTitle(raw: string | null): string;
+/**
+ * The task-title field: at most `max` visible characters.
+ *
+ * This is a MAXIMUM, not a fixed-width box — short titles are not right-padded
+ * (design tradeoff T3). When the sanitised title is longer than `max`, it is
+ * cut to `max - 1` characters and a single `…` is appended, so the result is
+ * exactly `max` characters.
+ *
+ * Splitting is done by code point, so an emoji or other astral character is
+ * never cut in half.
+ */
+export declare function titleField(raw: string | null, max?: number): string;
+/**
+ * The version segment of the footer: `"Xcoder <version>"`.
+ *
+ * Built in exactly one place so the product name and the spacing can never
+ * drift between call sites. A null/empty version yields an empty string, which
+ * the renderer treats as "omit the token".
+ */
+export declare function versionLabel(version: string | null): string;

package/dist/util/footer-text.js

@@ -0,0 +1,74 @@
+// xcoder:version 2 | xcoder:task task-3e056b | xcoder:updated 2026-11-03T17:56:20.605Z | xcoder:subtask code-st-f19254
+/**
+ * Footer text fields — the single place that decides what the task-title and
+ * version fields of the bottom footer look like.
+ *
+ * Why this is a separate module: the title comes from an untrusted source
+ * (`run.spec.goal`, which can originate from a CLI argument, an ingested
+ * markdown/WBS file, or a backlog item). Anything written to stdout is an
+ * interpreter input for the terminal emulator, so it is sanitised HERE, once,
+ * rather than trusted at every call site (PRM-01, PRM-08).
+ */
+/** Maximum visible characters the task-title field may occupy (design AC-9). */
+export const FOOTER_TITLE_MAX = 50;
+/** Single-character ellipsis used when a title is cut. */
+export const ELLIPSIS = "…";
+/**
+ * Strip terminal-control characters from untrusted text before it reaches
+ * stdout.
+ *
+ * Removes:
+ *  - `ESC` (0x1B) and any other C0 control (`0x00-0x1F`), which is what makes
+ *    ANSI CSI/OSC sequences possible (colour, cursor moves, OSC-52 clipboard
+ *    writes, window-title sets).
+ *  - `DEL` (0x7F) and the C1 block (`0x80-0x9F`), the 8-bit equivalents of
+ *    the same sequences.
+ *
+ * Newlines, carriage returns and tabs are collapsed to a single space first so
+ * a title can never break the one-row footer layout.
+ *
+ * This is a security control, not cosmetics — see design section 6.
+ */
+export function sanitizeTitle(raw) {
+    if (raw == null)
+        return "";
+    // Collapse line-breaking whitespace before stripping, so "a\nb" -> "a b",
+    // not "ab".
+    const collapsed = raw.replace(/[\r\n\t]+/g, " ");
+    // ESC + remaining C0, then DEL + C1. No control character survives.
+    const stripped = collapsed.replace(/\x1b/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+    return stripped.trim();
+}
+/**
+ * The task-title field: at most `max` visible characters.
+ *
+ * This is a MAXIMUM, not a fixed-width box — short titles are not right-padded
+ * (design tradeoff T3). When the sanitised title is longer than `max`, it is
+ * cut to `max - 1` characters and a single `…` is appended, so the result is
+ * exactly `max` characters.
+ *
+ * Splitting is done by code point, so an emoji or other astral character is
+ * never cut in half.
+ */
+export function titleField(raw, max = FOOTER_TITLE_MAX) {
+    const clean = sanitizeTitle(raw);
+    if (clean === "")
+        return "";
+    const codePoints = Array.from(clean);
+    if (codePoints.length <= max)
+        return clean;
+    if (max <= 1)
+        return ELLIPSIS;
+    return codePoints.slice(0, max - 1).join("") + ELLIPSIS;
+}
+/**
+ * The version segment of the footer: `"Xcoder <version>"`.
+ *
+ * Built in exactly one place so the product name and the spacing can never
+ * drift between call sites. A null/empty version yields an empty string, which
+ * the renderer treats as "omit the token".
+ */
+export function versionLabel(version) {
+    const v = sanitizeTitle(version ?? "");
+    return v === "" ? "" : `Xcoder ${v}`;
+}

package/dist/util/ids.d.ts

@@ -0,0 +1 @@
+export declare function shortId(prefix: string): string;

package/dist/util/ids.js

@@ -0,0 +1,4 @@
+import crypto from "node:crypto";
+export function shortId(prefix) {
+    return `${prefix}-${crypto.randomBytes(3).toString("hex")}`;
+}

package/dist/util/levenshtein.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compute the Levenshtein distance between two case-folded strings.
+ * The distance is the minimum number of single-character insertions,
+ * deletions, or substitutions required to transform `a` into `b`.
+ */
+export declare function levenshtein(a: string, b: string): number;

package/dist/util/levenshtein.js

@@ -0,0 +1,34 @@
+// xcoder:version 1 | xcoder:task task-c776f2 | xcoder:updated 2026-08-03T19:28:35.957Z | xcoder:subtask code-st-5c254e
+/**
+ * Compute the Levenshtein distance between two case-folded strings.
+ * The distance is the minimum number of single-character insertions,
+ * deletions, or substitutions required to transform `a` into `b`.
+ */
+export function levenshtein(a, b) {
+    const s = a.toLowerCase();
+    const t = b.toLowerCase();
+    // Ensure s is the shorter string (O(min(n,m)) space)
+    if (s.length > t.length) {
+        return levenshtein(b, a);
+    }
+    const m = s.length;
+    const n = t.length;
+    // Two-row DP arrays
+    let prev = new Array(m + 1);
+    let curr = new Array(m + 1);
+    for (let i = 0; i <= m; i++) {
+        prev[i] = i;
+    }
+    for (let j = 1; j <= n; j++) {
+        curr[0] = j;
+        for (let i = 1; i <= m; i++) {
+            const substitutionCost = s[i - 1] === t[j - 1] ? 0 : 1;
+            curr[i] = Math.min(prev[i] + 1, // deletion
+            curr[i - 1] + 1, // insertion
+            prev[i - 1] + substitutionCost);
+        }
+        // Swap rows
+        [prev, curr] = [curr, prev];
+    }
+    return prev[m];
+}

package/dist/util/logger.d.ts

@@ -0,0 +1,10 @@
+export declare const log: {
+    orchestrator(msg: string): void;
+    agent(id: string, msg: string): void;
+    ok(msg: string): void;
+    fail(msg: string): void;
+    dim(msg: string): void;
+    raw(msg: string): void;
+    sumurai(msg: string): void;
+    ninj(msg: string): void;
+};

package/dist/util/logger.js

@@ -0,0 +1,41 @@
+// xcoder:version 2 | xcoder:task task-e23ea7 | xcoder:updated 2026-08-05T09:43:25.115Z | xcoder:subtask code-st-a00941
+const COLOR = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    amber: "\x1b[38;5;214m",
+    cyan: "\x1b[38;5;80m",
+    green: "\x1b[38;5;78m",
+    coral: "\x1b[38;5;203m",
+};
+function useColor() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+}
+function paint(code, text) {
+    return useColor() ? `${code}${text}${COLOR.reset}` : text;
+}
+export const log = {
+    orchestrator(msg) {
+        console.log(paint(COLOR.amber, "[orchestrator]"), msg);
+    },
+    agent(id, msg) {
+        console.log(paint(COLOR.cyan, `[${id}]`), msg);
+    },
+    ok(msg) {
+        console.log(paint(COLOR.green, "✓"), msg);
+    },
+    fail(msg) {
+        console.log(paint(COLOR.coral, "✗"), msg);
+    },
+    dim(msg) {
+        console.log(paint(COLOR.dim, msg));
+    },
+    raw(msg) {
+        console.log(msg);
+    },
+    sumurai(msg) {
+        console.log(paint(COLOR.amber, "[Sumurai]"), msg);
+    },
+    ninj(msg) {
+        console.log(paint(COLOR.cyan, "[Ninj]"), msg);
+    },
+};

package/dist/util/logs.d.ts

@@ -0,0 +1,26 @@
+export { redactSecrets, REDACTED } from "./redact.js";
+export type { RedactionResult, RedactionCount } from "./redact.js";
+/** Reason (Thought) → Action → Observation trace, one line per step, human-readable. */
+export declare function appendThink(root: string, taskId: string, subtaskId: string, line: string): Promise<void>;
+/** System-level errors: crashes, tool exceptions, anything that would otherwise vanish silently. */
+export declare function appendSys(root: string, taskId: string, line: string): Promise<void>;
+/** Raw LLM request/response pairs, one JSON line each. */
+export declare function appendLlm(root: string, taskId: string, subtaskId: string, entry: {
+    direction: "request" | "response";
+    content: string;
+    stopReason?: string | null;
+}): Promise<void>;
+/** Token usage per LLM call, plus running totals — one line per call. */
+export declare function appendToken(root: string, taskId: string, subtaskId: string, usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cumulativeInput: number;
+    cumulativeOutput: number;
+}): Promise<void>;
+/** Reasoning-effectiveness score per subtask attempt, with its full breakdown — see orchestrator/reasoning-score.ts for what this is and isn't. */
+export declare function appendScore(root: string, taskId: string, subtaskId: string, score: {
+    score: number;
+    breakdown: string[];
+}): Promise<void>;
+export declare function appendFiles(root: string, taskId: string, subtaskId: string, line: string): Promise<void>;
+export declare function taskLogDir(root: string, taskId: string): string;