toolcraft 0.0.231 → 0.0.233

package/node_modules/toolcraft-design/dist/dashboard/testing/pipeline-scenario.js

@@ -0,0 +1,126 @@
+import { createDashboard } from "../dashboard.js";
+import { createDashboardLineBuffer } from "../line-buffer.js";
+// Fake output only: no agent, credentials, repository writes, or network requests.
+const scenario = process.argv[2] ?? "streaming";
+const labelControl = scenario === "label-controls" ? "\u001b]52;c;" + "HIDDEN_".repeat(100) + "\u0007" : "";
+const dashboard = createDashboard({
+    title: scenario === "unicode-title" ? "Pipeline · 界界 · 👩‍💻 · é · ".repeat(3) : `Pipeline · ${scenario}${labelControl}`,
+    statsTitle: scenario === "unicode-title" ? "Run · 界界 · 👩‍💻 · é" : `Run${labelControl}`,
+    rightPaneWidth: 32,
+    hints: [
+        { key: "q", label: `Quit${labelControl}` },
+        { key: "↑↓", label: "Scroll" },
+        { key: "F", label: "Follow" }
+    ]
+});
+let count = 0;
+let timer;
+const append = (kind, text) => {
+    dashboard.appendOutput({ kind, text, ts: count++ });
+};
+const shutdown = () => {
+    clearInterval(timer);
+    dashboard.destroy();
+};
+dashboard.onCommand((command) => {
+    if (command === "quit" || command === "forceQuit")
+        shutdown();
+});
+process.once("SIGINT", shutdown);
+process.once("SIGTERM", shutdown);
+dashboard.start();
+if (scenario !== "empty")
+    dashboard.updateStats({
+        status: "running",
+        iterationsLabel: `Tasks${labelControl}`,
+        iterations: 1,
+        tokensIn: 24000,
+        tokensOut: 7000,
+        elapsedMs: 65000,
+        currentAction: "Improve streaming output (implement)"
+    });
+append("info", "Config · codex · model-example · docs/plans/fake-pipeline.md");
+if (scenario !== "empty")
+    append("status", "Task 2/8 · Improve streaming output (implement)");
+if (scenario === "empty") {
+    dashboard.updateStats({
+        status: "done",
+        iterationsLabel: "Tasks",
+        iterations: 0,
+        tokensIn: 0,
+        tokensOut: 0,
+        elapsedMs: 0,
+        currentAction: "Nothing to run"
+    });
+    append("info", "All tasks are already complete.");
+}
+else if (scenario === "oversized") {
+    append("tool", "output word ".repeat(50000) + "LATEST RESULT");
+}
+else if (scenario === "newline-free") {
+    const output = createDashboardLineBuffer((line) => append("tool", line));
+    for (let index = 0; index < 1000; index += 1)
+        output.push("output word ".repeat(100));
+    output.push("LATEST RESULT");
+    output.flush();
+}
+else if (scenario === "execution-error") {
+    append("error", "Fake execution threw before producing a task result");
+    dashboard.updateStats({ status: "error", currentAction: undefined });
+}
+else if (scenario === "failure") {
+    append("tool", "npm test · checking streaming output");
+    append("error", "Tool exited with code 1\nExpected task result, received empty output\nRetry after correcting the task.");
+    dashboard.updateStats({ status: "error", currentAction: "Task 2/8 failed (implement)" });
+}
+else if (scenario === "unicode") {
+    append("info", "解析中 · 界界 · café · 👩‍💻 · é");
+    append("tool", "\u001b[31merror\u001b[0m normal \u001b[1;32msuccess\u001b[0m\nindented\tcolumn\nprogress 10%\rprogress 100%");
+    append("success", "Unicode and ANSI fixture ready");
+}
+else if (scenario === "label-controls") {
+    append("success", "Label control fixture ready");
+}
+else if (scenario === "unicode-title") {
+    append("success", "Unicode heading fixture ready");
+}
+else if (scenario === "cursor-controls") {
+    append("tool", "\u001b[32m界界\rA\u001b[0m\n😀\bX\n👩‍💻\bX\né\bX\na\tB\rX");
+    append("tool", "\u001b]52;c;HIDDEN_OSC_PAYLOAD\u0007Visible OSC result");
+    append("tool", "\u001bP HIDDEN_DCS_PAYLOAD\u001b\\Visible DCS result");
+    append("tool", "\u001b[2J\u001b[1;1HFrame preserved");
+    append("tool", "left\u007fright · \u009b2JC1 frame preserved");
+    append("tool", "\u009dHIDDEN_C1_OSC\u009cVisible C1 OSC result");
+    append("tool", "\u0090HIDDEN_FIRST\u0007HIDDEN_SECOND\u009cVisible C1 DCS result");
+    append("tool", "\u001bP" + "HIDDEN_LONG_".repeat(4_000) + "\u001b\\Visible long DCS result");
+    const output = createDashboardLineBuffer((line) => append("tool", line));
+    output.push("\u001b]HIDDEN_FIRST\n");
+    output.push("HIDDEN_SECOND\nHIDDEN_THIRD\u001b");
+    output.push("\\Visible multiline OSC result\n");
+    append("tool", "\u001b[" + "0;".repeat(20_000) + "mVisible long CSI result");
+    append("tool", "\u001bPHIDDEN_CANCELLED_DCS\u0018Visible cancelled DCS result");
+    append("tool", "\u001b]HIDDEN_CANCELLED_OSC\u001aVisible cancelled OSC result");
+    append("tool", "\u001b[0;\u001b[32mVisible restarted CSI result\u001b[0m");
+    append("tool", "Tab preservation fixture\nABCDEF\r\tX");
+    append("tool", "\u001b[31mABCDEF\u001b[0m\r\tX\n界界AB\r\tX");
+    append("tool", "Erase-line fixture\nprogress 100%\rprogress 50%\u001b[K\nABCDE\rXX\u001b[1K");
+    append("tool", "界界\b\u001b[KX\n界界AB\rXX\u001b[1K");
+    append("success", "Cursor control fixture ready");
+}
+else {
+    for (let index = 0; index < 200; index += 1) {
+        append("tool", `[implement] Inspecting source file ${index} and running focused checks`);
+    }
+    if (scenario === "burst") {
+        timer = setInterval(() => {
+            for (let index = 0; index < 100; index += 1)
+                append("tool", `burst output ${count}`);
+        }, 100);
+    }
+    else {
+        timer = setInterval(() => append("info", `Streaming response ${count} · working on task 2/8`), 500);
+    }
+}
+// Keep terminal state visible until QA sends q, including completed/error scenarios.
+if (timer === undefined)
+    timer = setInterval(() => { }, 1000);

package/node_modules/toolcraft-design/dist/dashboard/types.d.ts

@@ -1,5 +1,7 @@
 export type OutputItemKind = "info" | "success" | "error" | "tool" | "status";
 export type OutputItem = {
+    /** Reusing an id replaces its retained preview in place, without changing held history. */
+    id?: string;
     kind: OutputItemKind;
     text: string;
     ts: number;
@@ -13,7 +15,7 @@ export type DashboardStats = {
     elapsedMs: number;
     currentAction?: string;
 };
-export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log";
+export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log" | "scroll-up" | "scroll-down" | "page-up" | "page-down" | "follow" | "render-stats";
 export type DashboardState = {
     output: OutputItem[];
     stats: DashboardStats;

package/node_modules/toolcraft-design/dist/event-groups.d.ts

@@ -0,0 +1,19 @@
+export interface GroupEvent {
+    id: string;
+    text: string;
+    error?: boolean;
+}
+export interface EventGroupRow extends GroupEvent {
+    groupId: string;
+    header?: boolean;
+    expanded?: boolean;
+}
+export declare function createEventGroups({ capacity, children }: {
+    capacity: number;
+    children: number;
+}): {
+    append(groupId: string, event: GroupEvent): void;
+    toggle(groupId: string): void;
+    rows(offset: number, height: number): EventGroupRow[];
+};
+export declare function renderEventGroupRows(rows: readonly EventGroupRow[], width: number): string[];

package/node_modules/toolcraft-design/dist/event-groups.js

@@ -0,0 +1,49 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { fitToWidth } from "./explorer/render/text.js";
+import { limitOutputPreview } from "./dashboard/output-preview.js";
+export function createEventGroups({ capacity, children }) {
+    if (!Number.isInteger(capacity) || capacity < 1 || !Number.isInteger(children) || children < 1)
+        throw new RangeError("positive capacities required");
+    const groups = new Map();
+    return {
+        append(groupId, event) {
+            let group = groups.get(groupId);
+            if (!group) {
+                group = { events: new Map(), expanded: false };
+                groups.set(groupId, group);
+            }
+            group.events.set(event.id, { ...event, text: limitOutputPreview(event.text) });
+            if (group.events.size > children)
+                group.events.delete(group.events.keys().next().value);
+            if (event.error)
+                group.expanded = true;
+            if (groups.size > capacity)
+                groups.delete(groups.keys().next().value);
+        },
+        toggle(groupId) { const group = groups.get(groupId); if (group)
+            group.expanded = !group.expanded; },
+        rows(offset, height) {
+            const result = [];
+            let index = 0;
+            for (const [groupId, group] of groups) {
+                if (index++ >= offset)
+                    result.push({ id: groupId, text: groupId, groupId, header: true, expanded: group.expanded });
+                if (result.length >= height)
+                    break;
+                if (group.expanded)
+                    for (const event of group.events.values()) {
+                        if (index++ >= offset)
+                            result.push({ ...event, groupId });
+                        if (result.length >= height)
+                            break;
+                    }
+                if (result.length >= height)
+                    break;
+            }
+            return height > 0 ? result : [];
+        }
+    };
+}
+export function renderEventGroupRows(rows, width) {
+    return rows.map(row => fitToWidth(`${row.header ? row.expanded ? "▾" : "▸" : row.error ? "  ■" : "  │"} ${plainTerminalText(row.text)}`, width));
+}

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -34,7 +34,7 @@ export type { RenderTemplateOptions, TemplateEscape } from "./components/templat
 export { openExternal } from "./components/browser.js";
 export * as acp from "./acp/index.js";
 export * as dashboard from "./dashboard/index.js";
-export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
+export { createDashboard, createDashboardLineBuffer, createStreamingDashboardLineBuffer, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
 export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
@@ -60,3 +60,8 @@ export { Screen } from "./screen/screen.js";
 export type { Cell as ScreenCell, ScreenSize, ScreenSurface } from "./screen/screen.js";
 export { packStyle, styleToSgrDelta } from "./screen/style.js";
 export type { PackedStyle } from "./screen/style.js";
+export { createRenderPerformanceMonitor, formatRenderPerformance } from "./render-performance.js";
+export type { RenderPerformanceSnapshot, RenderPercentiles } from "./render-performance.js";
+export { createViewport, selectViewportTail } from "./viewport.js";
+export { createNotices, createCommandRegistry, createOverlayManager, createEventGroups, createTaskTree, renderTaskRows, renderEventGroupRows, renderProgressGroup, createMetric, renderNotice } from "./primitives.js";
+export type { DesignCommand, GroupEvent, EventGroupRow, TaskNode, ProgressItem, InlineNotice } from "./primitives.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -26,7 +26,7 @@ export { openExternal } from "./components/browser.js";
 export * as acp from "./acp/index.js";
 // Dashboard
 export * as dashboard from "./dashboard/index.js";
-export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
+export { createDashboard, createDashboardLineBuffer, createStreamingDashboardLineBuffer, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 // Explorer
 export * as explorer from "./explorer/index.js";
 export { runExplorer, singleDetail, normalizeExplorerConfig } from "./explorer/index.js";
@@ -48,3 +48,7 @@ export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from ".
 export { createTerminalDriver } from "./terminal/driver.js";
 export { Screen } from "./screen/screen.js";
 export { packStyle, styleToSgrDelta } from "./screen/style.js";
+// Bounded render diagnostics
+export { createRenderPerformanceMonitor, formatRenderPerformance } from "./render-performance.js";
+export { createViewport, selectViewportTail } from "./viewport.js";
+export { createNotices, createCommandRegistry, createOverlayManager, createEventGroups, createTaskTree, renderTaskRows, renderEventGroupRows, renderProgressGroup, createMetric, renderNotice } from "./primitives.js";

package/node_modules/toolcraft-design/dist/inline-notice.d.ts

@@ -0,0 +1,14 @@
+export interface InlineNotice {
+    level: "info" | "success" | "warning" | "error";
+    text: string;
+}
+export declare function renderNotice(notice: InlineNotice, width: number): string;
+/** Notices expire during reads, so an idle terminal needs no repaint timer. */
+export declare function createNotices({ capacity, now }: {
+    capacity: number;
+    now?: () => number;
+}): {
+    put(id: string, notice: InlineNotice, durationMs?: number): void;
+    dismiss(id: string): void;
+    list(): InlineNotice[];
+};

package/node_modules/toolcraft-design/dist/inline-notice.js

@@ -0,0 +1,28 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { limitOutputPreview } from "./dashboard/output-preview.js";
+import { fitToWidth } from "./explorer/render/text.js";
+export function renderNotice(notice, width) {
+    const marker = { info: "●", success: "✓", warning: "▲", error: "■" }[notice.level];
+    return fitToWidth(`${marker} ${plainTerminalText(notice.text)}`, width);
+}
+/** Notices expire during reads, so an idle terminal needs no repaint timer. */
+export function createNotices({ capacity, now = () => performance.now() }) {
+    if (!Number.isInteger(capacity) || capacity < 1)
+        throw new RangeError("positive capacity required");
+    const notices = new Map();
+    return {
+        put(id, notice, durationMs = Infinity) {
+            notices.set(id, { notice: { ...notice, text: limitOutputPreview(notice.text) }, expires: now() + Math.max(0, durationMs) });
+            if (notices.size > capacity)
+                notices.delete(notices.keys().next().value);
+        },
+        dismiss(id) { notices.delete(id); },
+        list() {
+            const time = now();
+            for (const [id, entry] of notices)
+                if (entry.expires <= time)
+                    notices.delete(id);
+            return Array.from(notices.values(), entry => ({ ...entry.notice }));
+        }
+    };
+}

package/node_modules/toolcraft-design/dist/metric.d.ts

@@ -0,0 +1,8 @@
+export declare function createMetric({ capacity, unit }: {
+    capacity: number;
+    unit: string;
+}): {
+    push(value: number | null): void;
+    samples(): (number | null)[];
+    render(width: number): string;
+};

package/node_modules/toolcraft-design/dist/metric.js

@@ -0,0 +1,21 @@
+import { fitToWidth } from "./explorer/render/text.js";
+export function createMetric({ capacity, unit }) {
+    if (!Number.isInteger(capacity) || capacity < 1)
+        throw new RangeError("positive capacity required");
+    const values = Array(capacity).fill(null);
+    let count = 0;
+    let cursor = 0;
+    return {
+        push(value) { values[cursor] = value !== null && Number.isFinite(value) ? value : null; cursor = (cursor + 1) % capacity; count = Math.min(count + 1, capacity); },
+        samples() { return Array.from({ length: count }, (_, i) => values[(cursor - count + i + capacity) % capacity]); },
+        render(width) {
+            const samples = Array.from({ length: Math.min(count, Math.max(0, width)) }, (_, i) => values[(cursor - Math.min(count, Math.max(0, width)) + i + capacity) % capacity]);
+            const known = samples.filter((value) => value !== null);
+            const min = Math.min(...known);
+            const max = Math.max(...known);
+            const spark = samples.map(value => value === null ? "·" : "▁▂▃▄▅▆▇█"[max === min ? 3 : Math.round((value - min) / (max - min) * 7)]).join("");
+            const latest = count ? values[(cursor - 1 + capacity) % capacity] : null;
+            return fitToWidth(`${latest ?? "—"} ${unit} ${spark}`, width);
+        }
+    };
+}

package/node_modules/toolcraft-design/dist/overlay-manager.d.ts

@@ -0,0 +1,6 @@
+export declare function createOverlayManager(initialFocus: string): {
+    open(focus: string): AbortSignal;
+    close(): boolean;
+    focus(): string;
+    dispose(): void;
+};

package/node_modules/toolcraft-design/dist/overlay-manager.js

@@ -0,0 +1,10 @@
+export function createOverlayManager(initialFocus) {
+    const stack = [];
+    return {
+        open(focus) { const controller = new AbortController(); stack.push({ focus, controller }); return controller.signal; },
+        close() { const overlay = stack.pop(); overlay?.controller.abort(); return overlay !== undefined; },
+        focus() { return stack.at(-1)?.focus ?? initialFocus; },
+        dispose() { while (stack.length)
+            stack.pop().controller.abort(); }
+    };
+}

package/node_modules/toolcraft-design/dist/primitives.d.ts

@@ -0,0 +1,12 @@
+export { createCommandRegistry } from "./command-registry.js";
+export type { DesignCommand } from "./command-registry.js";
+export { createOverlayManager } from "./overlay-manager.js";
+export { createEventGroups, renderEventGroupRows } from "./event-groups.js";
+export type { GroupEvent, EventGroupRow } from "./event-groups.js";
+export { createTaskTree, renderTaskRows } from "./task-tree.js";
+export type { TaskNode } from "./task-tree.js";
+export { renderProgressGroup } from "./progress-group.js";
+export type { ProgressItem } from "./progress-group.js";
+export { createMetric } from "./metric.js";
+export { renderNotice, createNotices } from "./inline-notice.js";
+export type { InlineNotice } from "./inline-notice.js";

package/node_modules/toolcraft-design/dist/primitives.js

@@ -0,0 +1,7 @@
+export { createCommandRegistry } from "./command-registry.js";
+export { createOverlayManager } from "./overlay-manager.js";
+export { createEventGroups, renderEventGroupRows } from "./event-groups.js";
+export { createTaskTree, renderTaskRows } from "./task-tree.js";
+export { renderProgressGroup } from "./progress-group.js";
+export { createMetric } from "./metric.js";
+export { renderNotice, createNotices } from "./inline-notice.js";

package/node_modules/toolcraft-design/dist/progress-group.d.ts

@@ -0,0 +1,7 @@
+export interface ProgressItem {
+    label: string;
+    completed?: number;
+    total?: number;
+    status?: "running" | "success" | "error";
+}
+export declare function renderProgressGroup(items: readonly ProgressItem[], width: number): string[];

package/node_modules/toolcraft-design/dist/progress-group.js

@@ -0,0 +1,10 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { fitToWidth } from "./explorer/render/text.js";
+export function renderProgressGroup(items, width) {
+    return items.map(item => {
+        const known = item.total !== undefined && item.total > 0 && Number.isFinite(item.total) && item.completed !== undefined && Number.isFinite(item.completed);
+        const progress = known ? `${Math.round(Math.max(0, Math.min(1, item.completed / item.total)) * 100)}%` : "…";
+        const marker = item.status === "success" ? "✓" : item.status === "error" ? "■" : "●";
+        return fitToWidth(`${marker} ${plainTerminalText(item.label)} ${progress}`, width);
+    });
+}

package/node_modules/toolcraft-design/dist/render-performance.d.ts

@@ -0,0 +1,33 @@
+export interface RenderPercentiles {
+    p50: number;
+    p95: number;
+    max: number;
+}
+export interface RenderPerformanceSnapshot {
+    /** Rolling one-second repaint dispatch rate, with 10ms bucket resolution. */
+    fps: number;
+    frames: number;
+    renders: number;
+    requests: number;
+    coalesced: number;
+    changedCells: number;
+    sampleCount: number;
+    /** Paints exceeding the 60Hz frame budget (16.67ms), cumulative. */
+    slowFrames: number;
+    longestRenderMs: number;
+    renderMs: RenderPercentiles;
+    /** Time from oldest pending input to flush enqueue; terminal presentation is not observable. */
+    inputMs: RenderPercentiles;
+}
+export declare function createRenderPerformanceMonitor(options?: {
+    now?: () => number;
+    sampleSize?: number;
+}): {
+    request(kind: "input" | "update" | "resize"): void;
+    begin(): number;
+    end(startedAt: number, frame: {
+        changedCells: number;
+    }): void;
+    snapshot(): RenderPerformanceSnapshot;
+};
+export declare function formatRenderPerformance(stats: RenderPerformanceSnapshot, width: number): string;

package/node_modules/toolcraft-design/dist/render-performance.js

@@ -0,0 +1,71 @@
+import { fitToWidth } from "./explorer/render/text.js";
+export function createRenderPerformanceMonitor(options = {}) {
+    const now = options.now ?? (() => performance.now());
+    const capacity = options.sampleSize ?? 256;
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > 4096)
+        throw new Error("sampleSize must be an integer between 1 and 4096");
+    const durations = new Float64Array(capacity);
+    const inputs = new Float64Array(capacity);
+    const buckets = new Float64Array(101).fill(-Infinity);
+    const counts = new Uint32Array(101);
+    let renders = 0, frames = 0, requests = 0, pending = 0, coalesced = 0, changedCells = 0;
+    let inputCount = 0;
+    let slowFrames = 0, longestRenderMs = 0;
+    let firstInput;
+    return {
+        request(kind) {
+            requests++;
+            pending++;
+            if (kind === "input")
+                firstInput ??= now();
+        },
+        begin() { return now(); },
+        end(startedAt, frame) {
+            const finished = now();
+            const duration = Math.max(0, finished - startedAt);
+            durations[renders % capacity] = duration;
+            longestRenderMs = Math.max(longestRenderMs, duration);
+            if (frame.changedCells > 0 && duration > 1000 / 60)
+                slowFrames++;
+            renders++;
+            coalesced += Math.max(0, pending - 1);
+            pending = 0;
+            if (firstInput !== undefined) {
+                inputs[inputCount++ % capacity] = Math.max(0, finished - firstInput);
+                firstInput = undefined;
+            }
+            if (frame.changedCells > 0) {
+                frames++;
+                changedCells += frame.changedCells;
+                const bucket = Math.floor(finished / 10);
+                const index = bucket % buckets.length;
+                if (buckets[index] !== bucket) {
+                    buckets[index] = bucket;
+                    counts[index] = 0;
+                }
+                counts[index] = counts[index] + 1;
+            }
+        },
+        snapshot() {
+            const time = now();
+            let fps = 0;
+            for (let index = 0; index < buckets.length; index++) {
+                if (buckets[index] * 10 >= time - 1000 && buckets[index] * 10 <= time)
+                    fps += counts[index];
+            }
+            return { fps, frames, renders, requests, coalesced, changedCells, slowFrames, longestRenderMs,
+                sampleCount: Math.min(renders, capacity), renderMs: percentiles(durations, Math.min(renders, capacity)),
+                inputMs: percentiles(inputs, Math.min(inputCount, capacity)) };
+        }
+    };
+}
+function percentiles(samples, count) {
+    if (count === 0)
+        return { p50: 0, p95: 0, max: 0 };
+    const sorted = samples.slice(0, count).sort();
+    return { p50: sorted[Math.ceil(count * .5) - 1], p95: sorted[Math.ceil(count * .95) - 1], max: sorted[count - 1] };
+}
+export function formatRenderPerformance(stats, width) {
+    const value = `FPS ${stats.fps} · paint p95 ${stats.renderMs.p95.toFixed(1)}ms · input p95 ${stats.inputMs.p95.toFixed(1)}ms · slow ${stats.slowFrames} · merged ${stats.coalesced}`;
+    return fitToWidth(value, width);
+}

package/node_modules/toolcraft-design/dist/task-tree.d.ts

@@ -0,0 +1,22 @@
+export interface TaskNode {
+    id: string;
+    parentId?: string;
+    label: string;
+    status: "pending" | "running" | "success" | "error";
+    durationMs?: number;
+}
+export declare function createTaskTree({ capacity }?: {
+    capacity?: number;
+}): {
+    upsert(node: TaskNode): void;
+    remove(id: string): void;
+    toggle(id: string): void;
+    rows(offset: number, height: number): (TaskNode & {
+        depth: number;
+        collapsed: boolean;
+    })[];
+};
+export declare function renderTaskRows(rows: readonly (TaskNode & {
+    depth: number;
+    collapsed: boolean;
+})[], width: number): string[];

package/node_modules/toolcraft-design/dist/task-tree.js

@@ -0,0 +1,79 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { fitToWidth } from "./explorer/render/text.js";
+export function createTaskTree({ capacity = 10000 } = {}) {
+    if (!Number.isInteger(capacity) || capacity < 1)
+        throw new RangeError("positive capacity required");
+    const nodes = new Map();
+    const children = new Map();
+    const collapsed = new Set();
+    return {
+        upsert(node) {
+            if (!nodes.has(node.id) && nodes.size >= capacity)
+                throw new RangeError("Task capacity exceeded");
+            let parent = node.parentId;
+            const seen = new Set([node.id]);
+            while (parent !== undefined) {
+                if (seen.has(parent))
+                    throw new Error("Task cycle");
+                seen.add(parent);
+                parent = nodes.get(parent)?.parentId;
+            }
+            const previous = nodes.get(node.id);
+            if (previous)
+                children.get(previous.parentId)?.delete(node.id);
+            nodes.set(node.id, { ...node });
+            let siblings = children.get(node.parentId);
+            if (!siblings) {
+                siblings = new Set();
+                children.set(node.parentId, siblings);
+            }
+            siblings.add(node.id);
+        },
+        remove(id) {
+            const node = nodes.get(id);
+            if (!node)
+                return;
+            children.get(node.parentId)?.delete(id);
+            const pending = [id];
+            while (pending.length) {
+                const current = pending.pop();
+                for (const child of children.get(current) ?? [])
+                    pending.push(child);
+                children.delete(current);
+                nodes.delete(current);
+                collapsed.delete(current);
+            }
+        },
+        toggle(id) { if (collapsed.has(id))
+            collapsed.delete(id);
+        else
+            collapsed.add(id); },
+        rows(offset, height) {
+            const result = [];
+            const stack = [{ iterator: (children.get(undefined) ?? new Set()).values(), depth: 0 }];
+            let index = 0;
+            while (stack.length && result.length < height) {
+                const frame = stack[stack.length - 1];
+                const next = frame.iterator.next();
+                if (next.done) {
+                    stack.pop();
+                    continue;
+                }
+                const node = nodes.get(next.value);
+                if (index++ >= offset)
+                    result.push({ ...node, depth: frame.depth, collapsed: collapsed.has(node.id) });
+                if (!collapsed.has(node.id) && children.has(node.id))
+                    stack.push({ iterator: children.get(node.id).values(), depth: frame.depth + 1 });
+            }
+            return result;
+        }
+    };
+}
+export function renderTaskRows(rows, width) {
+    const markers = { pending: "○", running: "●", success: "✓", error: "■" };
+    return rows.map(row => {
+        const indent = " ".repeat(Math.min(Math.max(0, width), Math.max(0, row.depth) * 2));
+        const duration = row.durationMs !== undefined && Number.isFinite(row.durationMs) ? ` · ${Math.max(0, Math.round(row.durationMs))}ms` : "";
+        return fitToWidth(`${indent}${row.collapsed ? "▸" : "▾"} ${markers[row.status]} ${plainTerminalText(row.label)}${duration}`, width);
+    });
+}

package/node_modules/toolcraft-design/dist/viewport.d.ts

@@ -0,0 +1,18 @@
+/** Select wrapped rows from the tail, retaining only one viewport of rows. */
+export declare function selectViewportTail<T, R>(items: readonly T[], height: number, offset: number, renderRows: (item: T) => readonly R[]): {
+    rows: R[];
+    offset: number;
+};
+export declare function createViewport<T extends {
+    id: string;
+}>({ capacity }: {
+    capacity: number;
+}): {
+    append(item: T): void;
+    scroll(delta: number): void;
+    items(): readonly T[];
+    offset(): number;
+    unseen(): number;
+    find(predicate: (item: T) => boolean): number;
+    follow(): void;
+};