toolcraft 0.0.243 → 0.0.245

package/composition.json

@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.243",
+      "version": "0.0.245",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.243",
+      "version": "0.0.245",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.243",
+      "version": "0.0.245",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.243",
+      "version": "0.0.245",
       "license": "MIT"
     },
     {

package/node_modules/tiny-stdio-mcp-server/dist/composition.json

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.243",
+      "version": "0.0.245",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-design/README.md

@@ -76,6 +76,12 @@ import { renderTable } from "toolcraft-design/render-table";
 - Root-level types: `Dashboard`, `DashboardOptions`.
 - The namespace also exports `renderDashboardSnapshot`, `defaultHints`, and the dashboard snapshot, state, output, command, statistics, and footer-hint types.
 
+Use `appearance: "conversation"` for a focused transcript with ordered plans, task progress, and current agent activity. Supply `onSubmit` to add a message and plan composer; the callback receives `{ kind, text, afterPlanId? }` and may reject to keep the draft editable. Populate `stats.run` with the current plan, tasks, steps, and queue.
+
+The composer queues with Enter or Tab, inserts a newline with Alt+Enter, switches between messages and plans with Ctrl+P, and selects the target plan with Alt+Up/Down. Arrow keys move within the draft, including wrapped lines and Unicode text. Esc opens browsing controls; `i` returns to messages, `p` adds a plan, `v` opens the scrollable task and plan list at the current work, and `d` reveals action details. In the list, `f` returns to current work and Home/End jump to either end. Shortcut labels wrap in narrow terminals. Optional `hints` and `keymap` customize harness controls while browsing. Ctrl+C remains available during submission.
+
+Output entries accept `role: "agent" | "user" | "action" | "reasoning" | "plan"` and a separate `detail` field. Reuse an entry ID to update an action or agent checklist in place. `acp.formatAgentPlan` produces a compact checklist and full details; `acp.renderAgentPlan` supports terminal, Markdown, and JSON output. Raw details and reasoning remain collapsed until requested; retained text and details are bounded for long runs.
+
 ### Explorer
 
 - `explorer`: namespace containing the complete explorer API.

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

@@ -2,3 +2,5 @@ export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasonin
 export type { AcpOutputState } from "./components.js";
 export { getAcpWriter, withAcpWriter } from "./writer.js";
 export type { AcpLineWriter } from "./writer.js";
+export { formatAgentPlan, renderAgentPlan } from "./plan.js";
+export type { AgentPlanEntry } from "./plan.js";

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

@@ -1,2 +1,3 @@
 export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError, renderPermissionRejected } from "./components.js";
 export { getAcpWriter, withAcpWriter } from "./writer.js";
+export { formatAgentPlan, renderAgentPlan } from "./plan.js";

package/node_modules/toolcraft-design/dist/acp/plan.d.ts

@@ -0,0 +1,10 @@
+export type AgentPlanEntry = {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+};
+/** A compact preview of an agent's checklist; the complete list stays in details. */
+export declare function formatAgentPlan(entries: readonly AgentPlanEntry[]): {
+    text: string;
+    detail?: string;
+};
+export declare function renderAgentPlan(entries: readonly AgentPlanEntry[]): void;

package/node_modules/toolcraft-design/dist/acp/plan.js

@@ -0,0 +1,50 @@
+import { color } from "../components/color.js";
+import { plainTerminalText } from "../dashboard/ansi.js";
+import { truncateToWidth } from "../dashboard/terminal-width.js";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { getAcpWriter } from "./writer.js";
+/** A compact preview of an agent's checklist; the complete list stays in details. */
+export function formatAgentPlan(entries) {
+    if (entries.length === 0)
+        return { text: "Agent checklist cleared" };
+    const completed = entries.filter((entry) => entry.status === "completed").length;
+    const heading = `Agent checklist · ${completed}/${entries.length}`;
+    const active = entries.findIndex((entry) => entry.status === "in_progress");
+    const pending = entries.findIndex((entry) => entry.status === "pending");
+    const focus = active >= 0 ? active : pending >= 0 ? pending : entries.length;
+    const start = Math.max(0, Math.min(focus - 1, entries.length - 5));
+    const end = Math.min(entries.length, start + 5);
+    const lines = [heading];
+    const full = [heading];
+    if (start > 0)
+        lines.push(`  ↑ ${start} earlier step${start === 1 ? "" : "s"}`);
+    let shortened = start > 0 || end < entries.length;
+    for (const [index, entry] of entries.entries()) {
+        const marker = { completed: "✓", in_progress: "›", pending: "○" }[entry.status];
+        const content = plainTerminalText(entry.content);
+        full.push(`  ${marker} ${content}`);
+        if (index < start || index >= end)
+            continue;
+        const preview = truncateToWidth(content, 100);
+        shortened ||= content !== preview;
+        lines.push(`  ${marker} ${preview}`);
+    }
+    if (end < entries.length)
+        lines.push(`  ↓ ${entries.length - end} more step${entries.length - end === 1 ? "" : "s"} · d Details`);
+    return { text: lines.join("\n"), ...(shortened ? { detail: full.join("\n") } : {}) };
+}
+export function renderAgentPlan(entries) {
+    const format = resolveOutputFormat();
+    if (format === "json") {
+        getAcpWriter()(JSON.stringify({ event: "plan", entries }));
+        return;
+    }
+    const plan = formatAgentPlan(entries);
+    const text = plan.detail ?? plan.text;
+    if (format === "markdown") {
+        const [heading, ...lines] = text.split("\n");
+        getAcpWriter()([`**${heading}**`, ...lines.map((line) => `- ${line.trimStart()}`)].join("\n"));
+    }
+    else
+        getAcpWriter()(color.dim(text));
+}

package/node_modules/toolcraft-design/dist/dashboard/components/output-pane.d.ts

@@ -8,5 +8,9 @@ export type VisualLine = {
     prefixStyle: CellStyle;
     segments?: StyledSegment[];
 };
-export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[], scrollOffset?: number): number;
-export declare function computeVisualLines(items: OutputItem[], width: number): VisualLine[];
+export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[], scrollOffset?: number, options?: {
+    conversation?: boolean;
+    details?: boolean;
+    now?: number;
+}): number;
+export declare function computeVisualLines(items: OutputItem[], width: number, preformatted?: boolean): VisualLine[];

package/node_modules/toolcraft-design/dist/dashboard/components/output-pane.js

@@ -1,15 +1,56 @@
 import { selectViewportTail } from "../../viewport.js";
 import { getTheme } from "../../internal/theme-detect.js";
+import { supportsColor } from "../../internal/color-support.js";
+import { parse, render } from "../../terminal-markdown/index.js";
 import { hasAnsi, parseAnsi } from "../ansi.js";
+import { formatElapsed } from "../elapsed.js";
 import { displayWidth, expandTabs, graphemes, graphemeWidth } from "../terminal-width.js";
 const TEXT_OFFSET = 3;
 const CONTINUATION_PREFIX = "│";
-export function renderOutputPane(buffer, rect, items, scrollOffset = 0) {
+const agentLines = new WeakMap();
+export function renderOutputPane(buffer, rect, items, scrollOffset = 0, options = {}) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0) {
         return 0;
     }
-    const { rows: visualLines, offset: actualOffset } = selectViewportTail(items, rect.height, scrollOffset, item => computeVisualLines([item], rect.width));
+    const { rows: visualLines, offset: actualOffset } = selectViewportTail(options.conversation && !options.details ? foldCompletedActions(items) : items, rect.height, scrollOffset, item => {
+        if (options.conversation && item.role === "reasoning" && !options.details)
+            return [];
+        let label = item.text;
+        const elapsed = options.now === undefined ? 0 : options.now - item.ts;
+        if (options.conversation && item.role === "action" && item.kind === "tool" && Number.isFinite(elapsed) && elapsed >= 1000) {
+            const duration = formatElapsed(elapsed);
+            label += ` · ${elapsed >= 3_600_000 ? duration : duration.slice(3)}`;
+        }
+        const text = options.details && item.detail ? item.role === "plan" ? item.detail : `${label}\n${item.detail}` : label;
+        const agentReply = options.conversation && item.role === "agent"
+            ? renderAgentLines(item, rect.width, rect.height + scrollOffset + 4) : undefined;
+        const lines = agentReply?.lines ?? computeVisualLines([text === item.text ? item : { ...item, text }], rect.width);
+        if (!options.conversation)
+            return lines;
+        const prose = item.role === "agent" || item.role === "user";
+        if (prose) {
+            while (lines.length > 0 && lines.at(-1).text.trim().length === 0)
+                lines.pop();
+            while (lines.length > 0 && lines[0].text.trim().length === 0)
+                lines.shift();
+        }
+        const style = item.kind === "error" ? getTheme().styles.error
+            : prose ? {} : getTheme().styles.muted;
+        const prefix = item.role === "user" ? "›" : item.role === "agent" ? "•"
+            : item.kind === "tool" ? "›" : item.kind === "success" ? "✓"
+                : item.kind === "error" ? "!" : "·";
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            line.prefix = index === 0 && agentReply?.complete !== false ? prefix : "";
+            line.prefixStyle = style;
+            line.style = style;
+        }
+        if (prose && lines.length > 0) {
+            lines.push({ text: "", prefix: "", style: {}, prefixStyle: {} });
+        }
+        return lines;
+    });
     const textRect = {
         x: rect.x + TEXT_OFFSET,
         y: rect.y,
@@ -46,7 +87,73 @@ export function renderOutputPane(buffer, rect, items, scrollOffset = 0) {
     }
     return actualOffset;
 }
-export function computeVisualLines(items, width) {
+function renderAgentLines(item, width, budget) {
+    const theme = getTheme();
+    const color = supportsColor();
+    const cached = agentLines.get(item);
+    if (cached?.text === item.text && cached.width === width && cached.theme === theme && cached.color === color
+        && (cached.complete || cached.budget >= budget)) {
+        return { lines: cached.lines.map((line) => ({ ...line })), complete: cached.complete };
+    }
+    let lines;
+    let complete = true;
+    try {
+        const ast = parse(item.text).ast;
+        const options = { width: Math.max(1, width - TEXT_OFFSET), showFrontmatter: true };
+        let text;
+        if (ast.type !== "root" || containsFootnotes(ast))
+            text = render(ast, options);
+        else {
+            const fragments = [];
+            let rows = 0;
+            let index = ast.children.length - 1;
+            for (; index >= 0 && rows < budget; index--) {
+                const fragment = render(ast.children[index], options);
+                fragments.push(fragment);
+                rows += fragment.split("\n").length - 1;
+            }
+            complete = index < 0;
+            text = fragments.reverse().join("");
+        }
+        lines = computeVisualLines([{ ...item, text }], width, true);
+    }
+    catch {
+        // A partially streamed document can contain invalid frontmatter or syntax.
+        lines = computeVisualLines([item], width);
+    }
+    agentLines.set(item, { text: item.text, width, theme, color, budget, complete, lines });
+    return { lines: lines.map((line) => ({ ...line })), complete };
+}
+function containsFootnotes(node) {
+    return node.type === "footnoteDefinition" || node.type === "footnoteReference"
+        || ("children" in node && node.children.some(containsFootnotes));
+}
+function foldCompletedActions(items) {
+    const result = [];
+    let completed = [];
+    const flush = () => {
+        if (completed.length >= 4) {
+            result.push({ role: "action", kind: "status", ts: completed[0].ts,
+                text: `${completed.length - 2} earlier actions · d Details` }, ...completed.slice(-2));
+        }
+        else
+            result.push(...completed);
+        completed = [];
+    };
+    for (const item of items) {
+        if (item.role === "reasoning")
+            continue;
+        if (item.role === "action" && item.kind === "success")
+            completed.push(item);
+        else {
+            flush();
+            result.push(item);
+        }
+    }
+    flush();
+    return result;
+}
+export function computeVisualLines(items, width, preformatted = false) {
     if (width <= 0) {
         return [];
     }
@@ -55,8 +162,8 @@ export function computeVisualLines(items, width) {
     const visualLines = [];
     for (const item of items) {
         const itemStyle = getItemStyle(item.kind);
-        if (hasAnsi(item.text) || hasCursorControls(item.text)) {
-            const styledLines = parseAnsi(item.text, hasAnsi(item.text) ? {} : itemStyle);
+        if (preformatted || hasAnsi(item.text) || hasCursorControls(item.text)) {
+            const styledLines = parseAnsi(item.text, preformatted || hasAnsi(item.text) ? {} : itemStyle);
             let firstRow = true;
             for (const styledLine of styledLines) {
                 const rows = hardWrapSegments(styledLine.segments, textWidth);
@@ -177,10 +284,12 @@ function wrapParagraph(value, width) {
     const tokens = tokenize(value);
     const lines = [];
     let currentLine = "";
+    let currentWidth = 0;
     let pendingSpace = "";
     const flushLine = () => {
         lines.push(currentLine);
         currentLine = "";
+        currentWidth = 0;
         pendingSpace = "";
     };
     for (const token of tokens) {
@@ -194,13 +303,16 @@ function wrapParagraph(value, width) {
         for (let index = 0; index < chunks.length; index += 1) {
             const chunk = chunks[index] ?? "";
             const gap = index === 0 ? pendingSpace : "";
-            if (currentLine.length > 0 && displayWidth(`${currentLine}${gap}${chunk}`) > width) {
+            const chunkWidth = displayWidth(chunk);
+            if (currentLine.length > 0 && currentWidth + gap.length + chunkWidth > width) {
                 flushLine();
             }
             if (currentLine.length > 0 && gap.length > 0) {
                 currentLine += gap;
+                currentWidth += gap.length;
             }
             currentLine += chunk;
+            currentWidth += chunkWidth;
             pendingSpace = "";
             if (index < chunks.length - 1) {
                 flushLine();

package/node_modules/toolcraft-design/dist/dashboard/components/run-view.d.ts

@@ -0,0 +1,27 @@
+import type { ScreenBuffer } from "../buffer.js";
+import type { ComposerState } from "../composer.js";
+import type { DashboardStats, OutputItem, Rect } from "../types.js";
+import type { FooterHint } from "./footer.js";
+export type RunViewOptions = {
+    title: string;
+    stats: DashboardStats;
+    output: OutputItem[];
+    scrollOffset: number;
+    composer?: ComposerState;
+    submitting?: boolean;
+    showQueue?: boolean;
+    showDetails?: boolean;
+    workOffset?: number;
+    feedback?: string;
+    hints?: FooterHint[];
+    now?: number;
+};
+export declare function renderRunView(buffer: ScreenBuffer, options: RunViewOptions): {
+    scrollOffset: number;
+    outputRect: Rect;
+    workOffset: number;
+    cursor?: {
+        x: number;
+        y: number;
+    };
+};

package/node_modules/toolcraft-design/dist/dashboard/components/run-view.js

@@ -0,0 +1,275 @@
+import { getTheme } from "../../internal/theme-detect.js";
+import { plainTerminalText } from "../ansi.js";
+import { layoutComposer } from "../composer-layout.js";
+import { displayWidth, truncateToWidth } from "../terminal-width.js";
+import { renderOutputPane } from "./output-pane.js";
+import { formatElapsed, formatNumber } from "./stats-pane.js";
+export function renderRunView(buffer, options) {
+    const { stats } = options;
+    const composer = options.showQueue && !options.composer?.focused ? undefined : options.composer;
+    const run = stats.run;
+    const theme = getTheme().styles;
+    const width = Math.max(0, Math.min(164, buffer.width - 4));
+    const x = Math.max(0, Math.floor((buffer.width - width) / 2));
+    const sidebarWidth = !options.showQueue && width >= 106 ? Math.min(40, Math.floor(width * 0.29)) : 0;
+    const transcriptWidth = Math.max(0, width - (sidebarWidth > 0 ? sidebarWidth + 3 : 0));
+    const queue = run?.queue ?? [];
+    const plans = queue.filter((item) => item.kind === "plan");
+    const activePlanIndex = Math.max(0, plans.findIndex((item) => item.id === run?.activePlanId));
+    const activePlan = plans[activePlanIndex];
+    const nextPlan = plans[activePlanIndex + 1];
+    const progress = plans.length > 0 ? ` · Plan ${activePlanIndex + 1}/${plans.length}` : "";
+    put(buffer, { x, y: 0, width, height: 1 }, 0, `${options.title}${progress}`, { bold: true });
+    const context = [run?.agent, run?.model ?? (run?.agent ? "default model" : undefined), run?.cwd].filter(Boolean).join(" · ");
+    put(buffer, { x, y: 1, width, height: 1 }, 0, context, theme.muted);
+    const draft = composer ? layoutComposer(composer, Math.max(1, transcriptWidth - 3)) : undefined;
+    const inputLines = draft ? Math.min(3, draft.lines.length) : 0;
+    const composerHeight = composer ? inputLines + 3 : 0;
+    const hint = composer?.focused
+        ? composer.kind === "plan" ? "Enter Queue plan  Ctrl+P Message  Esc Browse"
+            : "Enter Queue  Alt+Enter Newline  Ctrl+P Plan  Alt+↑↓ Target  Esc Browse"
+        : options.showQueue ? "↑↓ Scroll  PgUp/PgDn Page  Home/End Jump  f Current  v Activity  i Message  q Quit"
+            : options.hints ? options.hints.map((hint) => `${hint.key} ${hint.label}`).join("  ")
+                : width < 100 ? "i Message  p Plan  v Tasks  d Details  ↑↓ Scroll  f Follow  q Quit"
+                    : "i Message  p Add plan  v Tasks & plans  d Details  ↑↓ Scroll  f Follow  q Quit";
+    const footerLines = [""];
+    for (const part of plainTerminalText(hint).split("  ")) {
+        const previous = footerLines.at(-1);
+        if (previous && displayWidth(`${previous}  ${part}`) > width)
+            footerLines.push(part);
+        else
+            footerLines[footerLines.length - 1] = previous ? `${previous}  ${part}` : part;
+    }
+    const footerY = Math.max(0, buffer.height - footerLines.length);
+    const composerY = Math.max(3, footerY - composerHeight);
+    const contentBottom = composer ? composerY - 1 : footerY - 1;
+    let outputY = 3;
+    if (sidebarWidth === 0) {
+        if (activePlan?.kind === "plan") {
+            put(buffer, { x, y: outputY++, width, height: 1 }, 0, `${marker(activePlan.status)} ${activePlanIndex + 1}. ${basename(activePlan.path)}`, { bold: true });
+        }
+        if (nextPlan?.kind === "plan" && !options.showQueue) {
+            put(buffer, { x, y: outputY++, width, height: 1 }, 0, `○ ${activePlanIndex + 2}. ${basename(nextPlan.path)} · next`, theme.muted);
+        }
+    }
+    const tasks = run?.tasks ?? [];
+    const completed = tasks.filter((task) => task.status === "completed").length;
+    const taskCount = tasks.length > 0 ? `${completed}/${tasks.length} tasks` : `${stats.iterationsLabel ?? "Iterations"} ${stats.iterations}`;
+    const step = run?.activeStep ? truncateToWidth(plainTerminalText(run.activeStep), Math.max(8, Math.floor(transcriptWidth / 4))) : undefined;
+    const progressLabel = [step, taskCount].filter(Boolean).join(" · ");
+    let phaseLabel = run?.phase ?? stats.currentAction ?? stats.status;
+    if (phaseLabel === "Follow-up") {
+        const messages = queue.filter((item) => item.kind === "message" && item.afterPlanId === run?.activePlanId);
+        const active = messages.findIndex((item) => item.status === "running");
+        if (active >= 0)
+            phaseLabel += ` ${active + 1}/${messages.length}`;
+    }
+    const phase = truncateToWidth(plainTerminalText(phaseLabel), Math.max(8, transcriptWidth - progressLabel.length - 7));
+    const statusMarker = { running: "●", error: "!", paused: "Ⅱ", idle: "○", done: "✓" }[stats.status];
+    put(buffer, { x, y: outputY++, width: transcriptWidth, height: 1 }, 0, `${statusMarker} ${phase} · ${progressLabel}${run?.activity ? ` · ${run.activity}` : ""}`, stats.status === "error" ? theme.error : { bold: true });
+    outputY++;
+    const outputRect = { x, y: outputY, width: transcriptWidth, height: Math.max(0, contentBottom - outputY) };
+    let scrollOffset = options.scrollOffset;
+    let workOffset = options.workOffset ?? 0;
+    if (options.showQueue) {
+        workOffset = renderWorkList(buffer, outputRect, stats, options.workOffset);
+    }
+    else {
+        scrollOffset = renderOutputPane(buffer, outputRect, options.output, options.scrollOffset, {
+            conversation: true, details: options.showDetails, now: stats.status === "running" ? options.now : undefined
+        });
+    }
+    if (sidebarWidth > 0) {
+        const sidebarX = x + transcriptWidth + 3;
+        const sidebarHeight = Math.max(0, contentBottom - 3);
+        for (let row = 3; row < contentBottom; row++)
+            buffer.put(sidebarX - 2, row, "│", theme.muted);
+        renderWorkPanel(buffer, { x: sidebarX, y: 3, width: sidebarWidth, height: sidebarHeight }, stats);
+    }
+    const usage = stats.usageAvailable === false || (stats.usageAvailable === undefined && stats.tokensIn + stats.tokensOut === 0)
+        ? "Usage unavailable" : `${formatNumber(stats.tokensIn + stats.tokensOut)} tokens`;
+    const pendingMessages = queue.filter((item) => item.kind === "message" && item.status === "pending").length;
+    const metrics = `${formatElapsed(stats.elapsedMs)} · ${usage}${pendingMessages ? ` · ${pendingMessages} message${pendingMessages === 1 ? "" : "s"} queued` : ""}${scrollOffset > 0 && !options.showQueue ? " · History paused" : ""}`;
+    put(buffer, { x, y: Math.max(outputY, contentBottom), width: transcriptWidth, height: 1 }, 0, metrics, theme.muted);
+    let cursor;
+    if (composer && draft) {
+        const rect = { x, y: composerY, width: transcriptWidth, height: composerHeight };
+        const target = plans.find((plan) => plan.id === composer.afterPlanId) ?? activePlan;
+        const label = composer.kind === "plan" ? "ADD PLAN · joins the end of the queue"
+            : `AFTER ${target?.kind === "plan" ? basename(target.path) : "CURRENT PLAN"}`;
+        put(buffer, rect, 0, "─".repeat(transcriptWidth), theme.muted);
+        put(buffer, rect, 1, options.submitting ? "Adding to queue…" : label, theme.muted);
+        const start = Math.max(0, Math.min(draft.cursor.y - inputLines + 1, draft.lines.length - inputLines));
+        for (let index = 0; index < inputLines; index++) {
+            const text = composer.text.length === 0
+                ? composer.kind === "plan" ? "docs/plans/next-plan.md" : "Queue a message for this plan…"
+                : draft.lines[start + index] ?? "";
+            put(buffer, rect, index + 2, `${index === 0 ? "›" : " "}  ${text}`, composer.text.length === 0 ? theme.muted : {});
+        }
+        if (composer.error)
+            put(buffer, rect, composerHeight - 1, composer.error, theme.error);
+        else if (options.feedback)
+            put(buffer, rect, composerHeight - 1, options.feedback, theme.success);
+        if (composer.focused && !options.submitting)
+            cursor = {
+                x: Math.min(buffer.width - 1, x + 3 + draft.cursor.x),
+                y: Math.max(0, Math.min(footerY - 1, composerY + 2 + draft.cursor.y - start))
+            };
+    }
+    for (const [index, line] of footerLines.entries()) {
+        put(buffer, { x, y: footerY + index, width, height: 1 }, 0, line, theme.muted);
+    }
+    return { scrollOffset, workOffset, outputRect, ...(cursor ? { cursor } : {}) };
+}
+function renderWorkList(buffer, rect, stats, requestedOffset) {
+    const theme = getTheme().styles;
+    const queue = stats.run?.queue ?? [];
+    const tasks = stats.run?.tasks ?? [];
+    const activeMessage = queue.findIndex((item) => item.kind === "message" && item.status === "running");
+    let currentLine = 1 + (activeMessage >= 0 ? activeMessage : queue.findIndex((item) => item.id === stats.run?.activePlanId));
+    let totalLines = queue.length + 3;
+    let completed = 0;
+    for (const task of tasks) {
+        if (task.status === "completed")
+            completed++;
+        if (requestedOffset === undefined && activeMessage < 0 && task.id === stats.run?.activeTaskId) {
+            const step = task.steps?.findIndex((step) => step.name === stats.run?.activeStep) ?? -1;
+            currentLine = totalLines + (step >= 0 ? step + 1 : 0);
+        }
+        totalLines += 1 + (task.steps?.length ?? 0);
+    }
+    const capacity = Math.max(0, rect.height - 2);
+    const offset = Math.max(0, Math.min(requestedOffset ?? Math.max(0, currentLine - 1), totalLines - capacity));
+    const end = offset + capacity;
+    let parent;
+    function paint(line, text, style) {
+        if (line >= offset && line < end)
+            put(buffer, rect, line - offset + 1, text, style);
+    }
+    paint(0, `PLANS · ${queue.filter((item) => item.kind === "plan").length}`, { bold: true });
+    let planNumber = 0;
+    let parentPlan;
+    for (let index = 0; index < Math.min(queue.length, end - 1); index++) {
+        const item = queue[index];
+        if (item.kind === "plan") {
+            planNumber++;
+            parentPlan = item.path;
+        }
+        if (index + 1 < offset)
+            continue;
+        const text = item.kind === "plan" ? `${planNumber}. ${displayPlanPath(item.path, stats.run?.cwd)}` : `  └ ${item.text}`;
+        paint(index + 1, `${marker(item.status)} ${text}`, tone(item.status));
+        if (index + 1 === offset && item.kind === "message" && parentPlan)
+            parent = `After ${displayPlanPath(parentPlan, stats.run?.cwd)}`;
+    }
+    paint(queue.length + 2, `TASKS · ${completed}/${tasks.length}`, { bold: true });
+    let line = queue.length + 3;
+    for (const [index, task] of tasks.entries()) {
+        if (line >= end)
+            break;
+        const next = line + 1 + (task.steps?.length ?? 0);
+        if (next <= offset) {
+            line = next;
+            continue;
+        }
+        const title = `${index + 1}. ${task.title}`;
+        const active = task.id === stats.run?.activeTaskId && stats.status === "running";
+        const status = active ? "running" : task.status;
+        paint(line, `${marker(status)} ${title}`, tone(status));
+        for (let stepIndex = Math.max(0, offset - line - 1); stepIndex < (task.steps?.length ?? 0) && line + stepIndex + 1 < end; stepIndex++) {
+            const step = task.steps[stepIndex];
+            const name = step.name;
+            const status = active && name === stats.run?.activeStep ? "running" : step.status;
+            paint(line + stepIndex + 1, `    ${marker(status)} ${name}`, tone(status));
+            if (line + stepIndex + 1 === offset)
+                parent = title;
+        }
+        line = next;
+    }
+    if (offset > 0)
+        put(buffer, rect, 0, `↑ earlier · ${parent ?? "tasks and plans"}`, theme.muted);
+    if (end < totalLines)
+        put(buffer, rect, rect.height - 1, "↓ more tasks and plans", theme.muted);
+    return offset;
+}
+function renderWorkPanel(buffer, rect, stats) {
+    const theme = getTheme().styles;
+    const queue = stats.run?.queue ?? [];
+    const tasks = stats.run?.tasks ?? [];
+    const plans = queue.filter((item) => item.kind === "plan");
+    const planIndex = Math.max(0, plans.findIndex((item) => item.id === stats.run?.activePlanId));
+    let row = 0;
+    put(buffer, rect, row++, `PLANS · ${plans.length > 0 ? planIndex + 1 : 0}/${plans.length}`, { bold: true });
+    const planRows = Math.min(Math.max(3, Math.floor(rect.height * .4)), Math.max(0, rect.height - 4));
+    const runningIndex = queue.findIndex((item) => item.status === "running");
+    const activeIndex = Math.max(0, runningIndex >= 0 ? runningIndex : queue.findIndex((item) => item.id === stats.run?.activePlanId));
+    const queueStart = Math.max(0, Math.min(activeIndex, queue.length - Math.max(1, planRows - 2)));
+    if (queueStart > 0) {
+        const first = queue[queueStart];
+        const parent = first?.kind === "message" ? plans.find((plan) => plan.id === first.afterPlanId) : undefined;
+        put(buffer, rect, row++, parent ? `↑ After ${basename(parent.path)}` : `↑ ${queueStart} earlier`, theme.muted);
+    }
+    let queueIndex = queueStart;
+    for (; queueIndex < queue.length && row < planRows; queueIndex++) {
+        const item = queue[queueIndex];
+        const number = item.kind === "plan" ? plans.findIndex((plan) => plan.id === item.id) + 1 : undefined;
+        const text = item.kind === "plan" ? `${number}. ${basename(item.path)}` : `  └ ${item.text}`;
+        put(buffer, rect, row++, `${marker(item.status)} ${text}`, tone(item.status));
+    }
+    if (queueIndex < queue.length)
+        put(buffer, rect, row++, "  ↓ more queued work", theme.muted);
+    row++;
+    if (tasks.length === 0) {
+        put(buffer, rect, row++, "TASKS", { bold: true });
+        put(buffer, rect, row, "Waiting for plan details…", theme.muted);
+        return;
+    }
+    const done = tasks.filter((task) => task.status === "completed").length;
+    put(buffer, rect, row++, `TASKS · ${done}/${tasks.length}`, { bold: true });
+    const active = tasks.findIndex((task) => task.id === stats.run?.activeTaskId);
+    const pending = tasks.findIndex((task) => task.status !== "completed");
+    const focus = active >= 0 ? active : Math.max(0, pending);
+    const capacity = Math.max(1, rect.height - row - 1);
+    const start = Math.max(0, Math.min(focus - 1, tasks.length - capacity));
+    if (start > 0)
+        put(buffer, rect, row++, `  ↑ ${start} earlier tasks`, theme.muted);
+    for (let index = start; index < tasks.length && row < rect.height; index++) {
+        if (row === rect.height - 1 && index < tasks.length - 1) {
+            put(buffer, rect, row, "  ↓ more tasks · v View all", theme.muted);
+            break;
+        }
+        const task = tasks[index];
+        const isActive = task.id === stats.run?.activeTaskId;
+        const status = isActive && stats.status === "running" ? "running" : task.status;
+        put(buffer, rect, row++, `${marker(status)} ${index + 1}. ${task.title}`, tone(status));
+        if (isActive && task.steps && row < rect.height - (index < tasks.length - 1 ? 1 : 0)) {
+            const steps = task.steps.map((step) => `${step.name === stats.run?.activeStep ? "›" : marker(step.status)} ${step.name}`).join("  ");
+            put(buffer, rect, row++, `  ${steps}`, theme.muted);
+        }
+    }
+}
+function marker(status) {
+    return ({ completed: "✓", running: "›", failed: "!", cancelled: "×", paused: "Ⅱ", pending: "○" })[status];
+}
+function tone(status) {
+    const theme = getTheme().styles;
+    if (status === "running")
+        return { ...theme.info, bold: true };
+    if (status === "failed")
+        return theme.error;
+    return theme.muted;
+}
+function basename(value) {
+    return value.split("/").at(-1) ?? value;
+}
+function displayPlanPath(value, cwd) {
+    if (!cwd)
+        return value;
+    const prefix = cwd.endsWith("/") ? cwd : `${cwd}/`;
+    return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+function put(buffer, rect, row, text, style) {
+    if (row < 0 || row >= rect.height || rect.y + row >= buffer.height)
+        return;
+    buffer.putInRect(rect, row, truncateToWidth(plainTerminalText(text), rect.width), style);
+}

package/node_modules/toolcraft-design/dist/dashboard/components/stats-pane.d.ts

@@ -1,8 +1,8 @@
 import { ScreenBuffer } from "../buffer.js";
 import type { DashboardStats, Rect } from "../types.js";
 import { type VisualLine } from "./output-pane.js";
+export { formatElapsed } from "../elapsed.js";
 export declare function renderCompactStatsPane(buffer: ScreenBuffer, rect: Rect, stats: DashboardStats): void;
 export declare function renderStatsPane(buffer: ScreenBuffer, rect: Rect, stats: DashboardStats): void;
-export declare function formatElapsed(ms: number): string;
 export declare function formatNumber(n: number): string;
 export declare function statsToLines(stats: DashboardStats, width: number): VisualLine[];