toolcraft 0.0.243 → 0.0.244

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

@@ -2,6 +2,8 @@ import { getTheme } from "../../internal/theme-detect.js";
 import { plainTerminalText } from "../ansi.js";
 import { displayWidth, graphemes, graphemeWidth, truncateToWidth } from "../terminal-width.js";
 import { computeVisualLines } from "./output-pane.js";
+import { formatElapsed } from "../elapsed.js";
+export { formatElapsed } from "../elapsed.js";
 export function renderCompactStatsPane(buffer, rect, stats) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0)
@@ -58,14 +60,6 @@ export function renderStatsPane(buffer, rect, stats) {
         buffer.putInRect({ x: rect.x + textStart, y: rect.y + row, width: rect.width - textStart, height: 1 }, 0, line.text, line.style);
     }
 }
-export function formatElapsed(ms) {
-    const safeMs = Number.isFinite(ms) ? ms : 0;
-    const totalSeconds = Math.max(0, Math.floor(safeMs / 1_000));
-    const hours = Math.floor(totalSeconds / 3_600);
-    const minutes = Math.floor((totalSeconds % 3_600) / 60);
-    const seconds = totalSeconds % 60;
-    return [hours, minutes, seconds].map((value) => value.toString().padStart(2, "0")).join(":");
-}
 export function formatNumber(n) {
     return new Intl.NumberFormat("en-US").format(n);
 }

package/node_modules/toolcraft-design/dist/dashboard/composer-layout.d.ts

@@ -0,0 +1,12 @@
+import type { ComposerState } from "./composer.js";
+type ComposerLayout = {
+    lines: string[];
+    starts: number[];
+    cursor: {
+        x: number;
+        y: number;
+    };
+};
+/** Shared display rows keep input navigation aligned with the rendered caret. */
+export declare function layoutComposer(state: ComposerState, width: number): ComposerLayout;
+export {};

package/node_modules/toolcraft-design/dist/dashboard/composer-layout.js

@@ -0,0 +1,45 @@
+import { graphemes, graphemeWidth } from "./terminal-width.js";
+const layouts = new WeakMap();
+/** Shared display rows keep input navigation aligned with the rendered caret. */
+export function layoutComposer(state, width) {
+    width = Math.max(1, width);
+    const cached = layouts.get(state);
+    if (cached?.text === state.text && cached.cursor === state.cursor && cached.width === width)
+        return cached.layout;
+    const lines = [""];
+    const starts = [0];
+    let column = 0;
+    let offset = 0;
+    let cursor = { x: 0, y: 0 };
+    for (const segment of graphemes(state.text)) {
+        const cells = segment === "\t" ? 2 : graphemeWidth(segment);
+        if (segment !== "\n" && column + cells > width) {
+            lines.push("");
+            starts.push(offset);
+            column = 0;
+        }
+        if (offset === state.cursor)
+            cursor = { x: column, y: lines.length - 1 };
+        if (segment === "\n") {
+            lines.push("");
+            starts.push(offset + 1);
+            column = 0;
+        }
+        else {
+            lines[lines.length - 1] += segment === "\t" ? "  " : segment;
+            column += cells;
+        }
+        offset += segment.length;
+    }
+    if (offset === state.cursor) {
+        if (column >= width) {
+            lines.push("");
+            starts.push(offset);
+            column = 0;
+        }
+        cursor = { x: column, y: lines.length - 1 };
+    }
+    const layout = { lines, starts, cursor };
+    layouts.set(state, { text: state.text, cursor: state.cursor, width, layout });
+    return layout;
+}

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

@@ -0,0 +1,24 @@
+import type { KeypressEvent } from "./terminal.js";
+export type DashboardSubmission = {
+    kind: "message" | "plan";
+    text: string;
+    afterPlanId?: string;
+};
+export type ComposerState = {
+    kind: DashboardSubmission["kind"];
+    text: string;
+    /** UTF-16 offset at a grapheme boundary. */
+    cursor: number;
+    focused: boolean;
+    afterPlanId?: string;
+    error?: string;
+    /** Preserve the intended display column across shorter rows during vertical movement. */
+    preferredColumn?: number;
+    preferredWidth?: number;
+};
+export declare function createComposerState(kind: DashboardSubmission["kind"], afterPlanId?: string): ComposerState;
+export declare function editComposer(state: ComposerState, event: KeypressEvent, width?: number): {
+    state: ComposerState;
+    handled: boolean;
+    submit?: DashboardSubmission;
+};

package/node_modules/toolcraft-design/dist/dashboard/composer.js

@@ -0,0 +1,107 @@
+import { parseAnsi } from "./ansi.js";
+import { graphemes, graphemeWidth } from "./terminal-width.js";
+import { layoutComposer } from "./composer-layout.js";
+const editingSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function createComposerState(kind, afterPlanId) {
+    return { kind, text: "", cursor: 0, focused: true, ...(afterPlanId ? { afterPlanId } : {}) };
+}
+export function editComposer(state, event, width = Number.MAX_SAFE_INTEGER) {
+    const key = event.name ?? event.ch;
+    if (!state.focused || (event.ctrl && key === "c"))
+        return { state, handled: false };
+    if (key === "escape")
+        return { state: { ...state, focused: false }, handled: true };
+    const next = { ...state, error: undefined, preferredColumn: undefined, preferredWidth: undefined };
+    if ((key === "up" || key === "down") && !event.ctrl && !event.meta) {
+        const layout = layoutComposer(state, width);
+        const row = Math.max(0, Math.min(layout.starts.length - 1, layout.cursor.y + (key === "up" ? -1 : 1)));
+        if (row === layout.cursor.y)
+            return { state, handled: true };
+        next.preferredColumn = (state.preferredWidth === width ? state.preferredColumn : undefined) ?? layout.cursor.x;
+        next.preferredWidth = width;
+        next.cursor = layout.starts[row];
+        let column = 0;
+        for (const segment of graphemes(state.text.slice(next.cursor, layout.starts[row + 1]))) {
+            const cells = segment === "\t" ? 2 : graphemeWidth(segment);
+            if (segment === "\n" || column + cells > next.preferredColumn)
+                break;
+            next.cursor += segment.length;
+            column += cells;
+        }
+        return { state: next, handled: true };
+    }
+    const segments = ["left", "right", "backspace", "delete"].includes(key ?? "") || (event.ctrl && (key === "d" || key === "w"))
+        ? editingSegmenter.segment(state.text) : undefined;
+    const previous = segments?.containing(state.cursor - 1)?.index ?? state.cursor;
+    const current = segments?.containing(state.cursor);
+    const following = current ? current.index + current.segment.length : state.cursor;
+    const lineStart = state.cursor === 0 ? 0 : state.text.lastIndexOf("\n", state.cursor - 1) + 1;
+    const newline = state.text.indexOf("\n", state.cursor);
+    const lineEnd = newline === -1 ? state.text.length : newline;
+    function replace(start, end, text = "") {
+        next.text = state.text.slice(0, start) + text + state.text.slice(end);
+        next.cursor = start + text.length;
+    }
+    if (event.name === "paste") {
+        const text = parseAnsi((event.ch ?? "").replaceAll("\r\n", "\n").replaceAll("\r", "\n"))
+            .map((line) => line.segments.map((segment) => segment.text).join(""))
+            .join("\n");
+        replace(state.cursor, state.cursor, text);
+    }
+    else if ((key === "return" || key === "enter") && (event.meta || event.shift)) {
+        replace(state.cursor, state.cursor, "\n");
+    }
+    else if (key === "return" || key === "enter" || key === "tab") {
+        if (!state.text.trim())
+            return { state, handled: true };
+        return { state, handled: true, submit: {
+                kind: state.kind,
+                text: state.text.trim(),
+                ...(state.kind === "message" && state.afterPlanId ? { afterPlanId: state.afterPlanId } : {})
+            } };
+    }
+    else if (key === "left" && !event.meta) {
+        next.cursor = previous;
+    }
+    else if (key === "right" && !event.meta) {
+        next.cursor = following;
+    }
+    else if (key === "home" || (event.ctrl && key === "a")) {
+        next.cursor = lineStart;
+    }
+    else if (key === "end" || (event.ctrl && key === "e")) {
+        next.cursor = lineEnd;
+    }
+    else if (key === "backspace") {
+        replace(previous, state.cursor);
+    }
+    else if (key === "delete" || (event.ctrl && key === "d")) {
+        replace(state.cursor, following);
+    }
+    else if (event.ctrl && key === "u") {
+        replace(lineStart, state.cursor);
+    }
+    else if (event.ctrl && key === "k") {
+        replace(state.cursor, lineEnd);
+    }
+    else if (event.ctrl && key === "w") {
+        let start = state.cursor;
+        let preceding = segments?.containing(start - 1);
+        while (preceding && preceding.segment.trim() === "") {
+            start = preceding.index;
+            preceding = segments?.containing(start - 1);
+        }
+        while (preceding && preceding.segment.trim() !== "") {
+            start = preceding.index;
+            preceding = segments?.containing(start - 1);
+        }
+        replace(start, state.cursor);
+    }
+    else if (event.ch !== undefined && !event.ctrl && !event.meta) {
+        replace(state.cursor, state.cursor, event.ch);
+    }
+    else {
+        return { state, handled: false };
+    }
+    return { state: next, handled: true };
+}

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

@@ -1,5 +1,6 @@
 import { type RenderPerformanceSnapshot } from "../render-performance.js";
 import type { FooterHint } from "./components/footer.js";
+import { type DashboardSubmission } from "./composer.js";
 import type { Command, DashboardStats, OutputItem } from "./types.js";
 export type DashboardOptions = {
     title?: string;
@@ -9,6 +10,9 @@ export type DashboardOptions = {
     hints?: FooterHint[];
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
+    appearance?: "panels" | "conversation";
+    /** Resolves once the runtime accepts the input; rejection keeps the draft editable. */
+    onSubmit?: (submission: DashboardSubmission) => void | Promise<void>;
     /** Observe bounded performance snapshots without forcing idle repaints. */
     onPerformance?: (stats: RenderPerformanceSnapshot) => void;
 };

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

@@ -3,9 +3,12 @@ import { createLogger } from "../components/logger.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { ScreenBuffer, diff } from "./buffer.js";
 import { renderContextPane } from "./components/context-pane.js";
+import { plainTerminalText } from "./ansi.js";
 import { renderBorder } from "./components/border.js";
 import { defaultHints, renderFooter } from "./components/footer.js";
 import { renderOutputPane } from "./components/output-pane.js";
+import { renderRunView } from "./components/run-view.js";
+import { createComposerState, editComposer } from "./composer.js";
 import { renderCompactStatsPane, renderStatsPane } from "./components/stats-pane.js";
 import { createKeymap } from "./keymap.js";
 import { computeDashboardLayout } from "./layout.js";
@@ -22,6 +25,7 @@ export function createDashboard(opts = {}) {
     const title = opts.title ?? DEFAULT_TITLE;
     const statsTitle = opts.statsTitle ?? DEFAULT_STATS_TITLE;
     const rightPaneWidth = opts.rightPaneWidth ?? DEFAULT_RIGHT_PANE_WIDTH;
+    const conversation = opts.appearance === "conversation" || opts.onSubmit !== undefined;
     const commandHandlers = new Set();
     const fallbackLogger = createLogger((message) => {
         stdout.write(`${message}\n`);
@@ -39,7 +43,17 @@ export function createDashboard(opts = {}) {
     let scrollOffset = 0;
     let outputViewportHeight = 0;
     let heldOutput;
+    let heldAt;
     let renderTimer;
+    let composer = opts.onSubmit ? createComposerState("message") : undefined;
+    let otherDraft = createComposerState("plan");
+    let submitting = false;
+    let showQueue = false;
+    let workOffset = 0;
+    let feedback;
+    let showDetails = false;
+    let lastActivePlanId;
+    let outputRect;
     function appendOutput(item) {
         if (destroyed) {
             return;
@@ -67,6 +81,8 @@ export function createDashboard(opts = {}) {
         driver.enterAltScreen();
         driver.disableLineWrap();
         driver.hideCursor();
+        if (opts.onSubmit)
+            driver.write("\u001b[?2004h");
         render();
         const activeStore = getStore();
         let previousStats = activeStore.getState().stats;
@@ -90,18 +106,110 @@ export function createDashboard(opts = {}) {
             }
         });
         unsubscribeKeypress = driver.onKeypress((event) => {
+            performanceMonitor.request("input");
+            if (composer && !(event.ctrl && event.name === "c")) {
+                if (submitting)
+                    return;
+                if (event.ctrl && event.name === "p") {
+                    feedback = undefined;
+                    [composer, otherDraft] = [otherDraft, composer];
+                    composer.focused = true;
+                    render();
+                    return;
+                }
+                if (composer.focused && event.meta && (event.name === "up" || event.name === "down")) {
+                    feedback = undefined;
+                    const run = getStore().getState().stats.run;
+                    const plans = run?.queue?.filter((item) => item.kind === "plan") ?? [];
+                    const activeIndex = Math.max(0, plans.findIndex((item) => item.id === run?.activePlanId));
+                    const available = plans.slice(activeIndex);
+                    if (available.length > 0) {
+                        const index = available.findIndex((item) => item.id === composer.afterPlanId);
+                        const next = index < 0 ? 0 : (index + (event.name === "up" ? -1 : 1) + available.length) % available.length;
+                        composer = { ...composer, afterPlanId: available[next].id };
+                        render();
+                    }
+                    return;
+                }
+                if (!composer.focused && (event.ch === "i" || event.ch === "p" || event.name === "return")) {
+                    feedback = undefined;
+                    const kind = event.ch === "p" ? "plan" : "message";
+                    if (composer.kind !== kind)
+                        [composer, otherDraft] = [otherDraft, composer];
+                    composer.focused = true;
+                    render();
+                    return;
+                }
+                const edit = editComposer(composer, event, Math.max(1, (outputRect?.width ?? 80) - 3));
+                if (edit.handled) {
+                    feedback = undefined;
+                    composer = edit.state;
+                    if (edit.submit) {
+                        const submission = edit.submit;
+                        submitting = true;
+                        render();
+                        void (async () => {
+                            try {
+                                await opts.onSubmit(submission);
+                                const run = store?.getState().stats.run;
+                                const activeIndex = run?.queue?.findIndex((item) => item.id === run.activePlanId) ?? -1;
+                                const targetIndex = run?.queue?.findIndex((item) => item.id === submission.afterPlanId) ?? -1;
+                                const target = targetIndex < activeIndex ? run?.activePlanId : submission.afterPlanId;
+                                composer = createComposerState(submission.kind, target);
+                                const planNumber = (run?.queue?.filter((item) => item.kind === "plan").findIndex((item) => item.id === submission.afterPlanId) ?? -1) + 1;
+                                feedback = submission.kind === "plan" ? "Plan queued" : `Message queued${planNumber > 0 ? ` after plan ${planNumber}` : ""}`;
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                composer = { ...composer, error: message };
+                                if (destroyed)
+                                    fallbackLogger.error(`Could not queue ${submission.kind}: ${plainTerminalText(message)}`);
+                            }
+                            finally {
+                                submitting = false;
+                                render();
+                            }
+                        })();
+                    }
+                    else {
+                        renderTimer ??= setTimeout(render, 16);
+                    }
+                    return;
+                }
+            }
+            if (conversation && !composer?.focused && (event.ch === "v" || event.ch === "d")) {
+                if (event.ch === "v") {
+                    showQueue = !showQueue;
+                    if (showQueue)
+                        workOffset = undefined;
+                }
+                else
+                    showDetails = !showDetails;
+                render();
+                return;
+            }
+            if (showQueue && !composer?.focused && event.name === "home") {
+                workOffset = 0;
+                render();
+                return;
+            }
             const command = resolveCommand(event);
             if (command === undefined) {
                 return;
             }
-            performanceMonitor.request("input");
             if (command === "render-stats") {
                 showPerformance = !showPerformance;
                 render();
                 return;
             }
             if (command === "follow") {
+                if (showQueue) {
+                    workOffset = event.name === "end" ? Number.MAX_SAFE_INTEGER : undefined;
+                    render();
+                    return;
+                }
                 heldOutput = undefined;
+                heldAt = undefined;
                 scrollOffset = 0;
                 render();
                 return;
@@ -110,14 +218,23 @@ export function createDashboard(opts = {}) {
                 command === "scroll-down" ||
                 command === "page-up" ||
                 command === "page-down") {
-                const page = Math.max(1, outputViewportHeight);
+                const page = Math.max(1, outputRect?.height ?? outputViewportHeight);
                 const amount = command === "page-up" || command === "page-down" ? page : 1;
                 const direction = command === "scroll-up" || command === "page-up" ? 1 : -1;
-                if (direction > 0)
-                    heldOutput ??= getStore().getState().output;
+                if (showQueue) {
+                    workOffset = Math.max(0, (workOffset ?? 0) - amount * direction);
+                    renderTimer ??= setTimeout(render, 16);
+                    return;
+                }
+                if (direction > 0 && heldOutput === undefined) {
+                    heldOutput = getStore().getState().output;
+                    heldAt = Date.now();
+                }
                 scrollOffset = Math.max(0, scrollOffset + amount * direction);
-                if (scrollOffset === 0)
+                if (scrollOffset === 0) {
                     heldOutput = undefined;
+                    heldAt = undefined;
+                }
                 renderTimer ??= setTimeout(render, 16);
                 return;
             }
@@ -143,6 +260,8 @@ export function createDashboard(opts = {}) {
             started = false;
             return;
         }
+        if (opts.onSubmit)
+            driver.write("\u001b[?2004l");
         driver.destroy();
         driver = undefined;
         previousBuffer = new ScreenBuffer(0, 0);
@@ -159,6 +278,10 @@ export function createDashboard(opts = {}) {
             return;
         }
         stop();
+        for (const draft of [composer, otherDraft]) {
+            if (draft?.error)
+                fallbackLogger.error(`Could not queue ${draft.kind}: ${plainTerminalText(draft.error)}`);
+        }
         commandHandlers.clear();
         store = undefined;
         destroyed = true;
@@ -183,45 +306,83 @@ export function createDashboard(opts = {}) {
             footerHeight: state.stats.session ? 2 : 1
         });
         const nextBuffer = new ScreenBuffer(cols, rows);
-        renderBorder(nextBuffer, layout, {
-            leftTitle: title,
-            rightTitle: statsTitle,
-            style: { dim: true }
-        });
-        if (state.stats.context?.length) {
-            const contextRect = layout.summary ?? layout.leftPane;
-            // Context spans both panes on wide terminals.
-            const remaining = renderContextPane(nextBuffer, {
-                x: contextRect.x, y: contextRect.y, width: Math.max(0, cols - 2),
-                height: layout.summary ? layout.summary.height + layout.leftPane.height : layout.leftPane.height
-            }, state.stats.context);
-            const height = remaining.y - contextRect.y;
-            if (layout.summary) {
-                layout.summary.y = remaining.y;
-                layout.summary.height = Math.min(layout.summary.height, remaining.height);
-                layout.leftPane.y = layout.summary.y + layout.summary.height;
-                layout.leftPane.height = Math.max(0, remaining.height - layout.summary.height);
+        let cursor;
+        if (conversation) {
+            const activePlanId = state.stats.run?.activePlanId;
+            if (activePlanId !== lastActivePlanId)
+                feedback = undefined;
+            if (composer && (composer.afterPlanId === undefined ||
+                (composer.text.length === 0 && composer.afterPlanId === lastActivePlanId))) {
+                composer = { ...composer, afterPlanId: activePlanId };
+            }
+            if (otherDraft.afterPlanId === undefined ||
+                (otherDraft.text.length === 0 && otherDraft.afterPlanId === lastActivePlanId)) {
+                otherDraft = { ...otherDraft, afterPlanId: activePlanId };
             }
-            else {
-                layout.leftPane.y += height;
-                layout.leftPane.height -= height;
-                layout.rightPane.y += height;
-                layout.rightPane.height -= height;
+            lastActivePlanId = activePlanId;
+            const view = renderRunView(nextBuffer, {
+                title, stats: state.stats, output: heldOutput ?? state.output, scrollOffset,
+                composer, submitting, showQueue, showDetails, workOffset, feedback, hints: opts.hints,
+                now: heldOutput === undefined ? Date.now() : heldAt
+            });
+            scrollOffset = view.scrollOffset;
+            workOffset = view.workOffset;
+            outputRect = view.outputRect;
+            cursor = view.cursor;
+        }
+        else {
+            renderBorder(nextBuffer, layout, {
+                leftTitle: title,
+                rightTitle: statsTitle,
+                style: { dim: true }
+            });
+            if (state.stats.context?.length) {
+                const contextRect = layout.summary ?? layout.leftPane;
+                // Context spans both panes on wide terminals.
+                const remaining = renderContextPane(nextBuffer, {
+                    x: contextRect.x, y: contextRect.y, width: Math.max(0, cols - 2),
+                    height: layout.summary ? layout.summary.height + layout.leftPane.height : layout.leftPane.height
+                }, state.stats.context);
+                const height = remaining.y - contextRect.y;
+                if (layout.summary) {
+                    layout.summary.y = remaining.y;
+                    layout.summary.height = Math.min(layout.summary.height, remaining.height);
+                    layout.leftPane.y = layout.summary.y + layout.summary.height;
+                    layout.leftPane.height = Math.max(0, remaining.height - layout.summary.height);
+                }
+                else {
+                    layout.leftPane.y += height;
+                    layout.leftPane.height -= height;
+                    layout.rightPane.y += height;
+                    layout.rightPane.height -= height;
+                }
             }
+            outputViewportHeight = Math.max(0, layout.leftPane.height - (showPerformance ? 1 : 0));
+            scrollOffset = renderOutputPane(nextBuffer, { ...layout.leftPane, height: outputViewportHeight }, heldOutput ?? state.output, scrollOffset);
+            if (scrollOffset === 0)
+                heldOutput = undefined;
+            renderStatsPane(nextBuffer, layout.rightPane, state.stats);
+            if (layout.summary)
+                renderCompactStatsPane(nextBuffer, layout.summary, state.stats);
+            renderFooter(nextBuffer, layout.footer, footerHints, state.stats.session);
         }
-        outputViewportHeight = Math.max(0, layout.leftPane.height - (showPerformance ? 1 : 0));
-        scrollOffset = renderOutputPane(nextBuffer, { ...layout.leftPane, height: outputViewportHeight }, heldOutput ?? state.output, scrollOffset);
-        if (scrollOffset === 0)
+        if (scrollOffset === 0) {
             heldOutput = undefined;
-        renderStatsPane(nextBuffer, layout.rightPane, state.stats);
-        if (layout.summary)
-            renderCompactStatsPane(nextBuffer, layout.summary, state.stats);
-        renderFooter(nextBuffer, layout.footer, footerHints, state.stats.session);
-        if (showPerformance && layout.leftPane.height > 0) {
-            nextBuffer.putInRect(layout.leftPane, layout.leftPane.height - 1, formatRenderPerformance(performanceMonitor.snapshot(), layout.leftPane.width), { dim: true });
+            heldAt = undefined;
+        }
+        const performanceRect = outputRect ?? layout.leftPane;
+        if (showPerformance && performanceRect.height > 0) {
+            nextBuffer.putInRect(performanceRect, performanceRect.height - 1, formatRenderPerformance(performanceMonitor.snapshot(), performanceRect.width), { dim: true });
         }
         const changes = diff(previousBuffer, nextBuffer);
         driver.flush(changes);
+        if (cursor) {
+            driver.moveTo(cursor.x, cursor.y);
+            driver.showCursor();
+        }
+        else {
+            driver.hideCursor();
+        }
         performanceMonitor.end(startedAt, { changedCells: changes.length });
         opts.onPerformance?.(performanceMonitor.snapshot());
         previousBuffer = nextBuffer;

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

@@ -0,0 +1 @@
+export declare function formatElapsed(ms: number): string;

package/node_modules/toolcraft-design/dist/dashboard/elapsed.js

@@ -0,0 +1,8 @@
+export function formatElapsed(ms) {
+    const safeMs = Number.isFinite(ms) ? ms : 0;
+    const totalSeconds = Math.max(0, Math.floor(safeMs / 1_000));
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    return [hours, minutes, seconds].map((value) => value.toString().padStart(2, "0")).join(":");
+}

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

@@ -3,8 +3,9 @@ export { createDashboardLineBuffer, createStreamingDashboardLineBuffer } from ".
 export { limitOutputPreview, createOutputPreviewBuffer } from "./output-preview.js";
 export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
 export type { Dashboard, DashboardOptions } from "./dashboard.js";
+export type { DashboardSubmission } from "./composer.js";
 export { renderDashboardSnapshot } from "./snapshot.js";
 export type { SnapshotOptions } from "./snapshot.js";
-export type { OutputItem, OutputItemKind, DashboardStats, Command, DashboardState } from "./types.js";
+export type { OutputItem, OutputItemKind, DashboardStats, DashboardTask, DashboardRunState, DashboardQueueItem, DashboardWorkStatus, Command, DashboardState } from "./types.js";
 export { defaultHints } from "./components/footer.js";
 export type { FooterHint } from "./components/footer.js";

package/node_modules/toolcraft-design/dist/dashboard/store.js

@@ -22,7 +22,8 @@ export function createStore() {
     }
     function appendOutput(item) {
         const preview = limitOutputPreview(item.text);
-        const retainedItem = preview === item.text ? item : { ...item, text: preview };
+        const detail = item.detail === undefined ? undefined : limitOutputPreview(item.detail);
+        const retainedItem = preview === item.text && detail === item.detail ? item : { ...item, text: preview, detail };
         const existing = item.id === undefined ? -1 : state.output.findIndex((entry) => entry.id === item.id);
         const next = existing !== -1
             ? state.output.map((entry, index) => index === existing ? retainedItem : entry)

package/node_modules/toolcraft-design/dist/dashboard/terminal-width.js

@@ -2,7 +2,7 @@ const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme
 export function graphemes(value) {
     for (let index = 0; index < value.length; index += 1) {
         const code = value.charCodeAt(index);
-        if ((code < 0x20 || code > 0x7e) && (code < 0x4e00 || code > 0x9fff)) {
+        if ((code < 0x20 || code > 0x7e) && code !== 0x09 && code !== 0x0a && (code < 0x4e00 || code > 0x9fff)) {
             return Array.from(graphemeSegmenter.segment(value), ({ segment }) => segment);
         }
     }