linersh 0.5.0

package/dist/screens/PhaseRunner.js

@@ -0,0 +1,1119 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { Header } from "../components/Header.js";
+import { KeyHints } from "../components/KeyHints.js";
+import { LabeledBox } from "../components/LabeledBox.js";
+import { CURRENT, ERROR, HEADING, STRUCTURE, SUCCESS } from "../colors.js";
+import { useApp } from "../store.js";
+import { detectAgents, resolveSkillPath } from "../agents/detect.js";
+import { resolveConfiguredAgent } from "../config.js";
+import { runPhaseWithAgent } from "../agents/runner.js";
+import { computePhases, readGateState, writeGateState, } from "../phases.js";
+import { markPhaseComplete, readProgress } from "../progress.js";
+import { projectFolder } from "../yaml-io.js";
+// Tool list viewport. Always shows VIEWPORT rows; arrow keys move the cursor
+// and scroll the window when the cursor hits an edge. Replaces the previous
+// "press t to expand / collapse" toggle — keeps the layout perfectly stable
+// regardless of how many tool calls the agent made.
+const TOOLS_VIEWPORT = 8;
+export function PhaseRunner({ tape, folder, phaseId, }) {
+    const app = useApp();
+    const project = useMemo(() => projectFolder(folder), [folder]);
+    const phase = useMemo(() => computePhases(project, tape, readProgress(folder)).find((p) => p.id === phaseId) ?? null, [project, tape, phaseId, folder]);
+    const skillPath = useMemo(() => resolveSkillPath(), []);
+    const initial = useMemo(() => initialStage(skillPath), [skillPath]);
+    const [stage, setStage] = useState(initial.stage);
+    // Structured state derived from AgentEvent stream.
+    const [tools, setTools] = useState([]);
+    const [finalText, setFinalText] = useState("");
+    // Refs mirror state for the handle.done.then() closure.
+    const finalTextRef = useRef("");
+    const currentTextRef = useRef("");
+    const [stats, setStats] = useState({ events: 0, tokens: zeroTokens() });
+    // Index into the full `tools` array. Drives the cursor in the done-state
+    // tool list and the detail panel below it. Snaps to the last tool when the
+    // run finishes.
+    const [toolCursor, setToolCursor] = useState(0);
+    // First tool index visible in the viewport. The arrow handlers maintain
+    // the invariant that `toolCursor` is always inside [scrollTop, scrollTop +
+    // VIEWPORT) by scrolling when the cursor hits an edge.
+    const [toolScrollTop, setToolScrollTop] = useState(0);
+    // Inspect mode is a modal toggle pressed with `t`. When OFF (default), the
+    // tool list is just a static viewport showing the tail end of the call
+    // history — no cursor, no detail panel, arrow keys don't do anything.
+    // When ON, arrows scroll the cursor through the full list and a detail
+    // panel renders below showing the selected call's full input + result.
+    // Press `t` again to exit. This keeps the default done view compact and
+    // makes the inspection ritual explicit instead of "you happen to be in
+    // arrow mode all the time."
+    const [inspectMode, setInspectMode] = useState(false);
+    const handleRef = useRef(null);
+    const handleEvent = useCallback((event) => {
+        setStats((s) => ({ ...s, events: s.events + 1 }));
+        switch (event.kind) {
+            case "init":
+                return;
+            case "text":
+                // Track the latest assistant text for the "final response" pane on
+                // the done state. We don't render it live anymore — that was the
+                // source of the scrollback laddering bug on long runs.
+                currentTextRef.current = currentTextRef.current
+                    ? currentTextRef.current + "\n\n" + event.text
+                    : event.text;
+                return;
+            case "tool_start":
+                setTools((prev) => [
+                    ...prev,
+                    {
+                        id: event.id,
+                        name: event.name,
+                        input: event.input,
+                        inputPreview: summarizeInput(event.input),
+                        status: "running",
+                    },
+                ]);
+                return;
+            case "tool_done":
+                setTools((prev) => prev.map((t) => t.id === event.id
+                    ? {
+                        ...t,
+                        status: event.ok ? "ok" : "failed",
+                        resultPreview: event.preview,
+                    }
+                    : t));
+                return;
+            case "tokens":
+                setStats((s) => ({
+                    ...s,
+                    tokens: {
+                        input: s.tokens.input + event.inputTokens,
+                        output: s.tokens.output + event.outputTokens,
+                        cacheRead: s.tokens.cacheRead + event.cacheReadTokens,
+                        cacheCreation: s.tokens.cacheCreation + event.cacheCreationTokens,
+                    },
+                }));
+                return;
+            case "summary":
+                setStats((s) => ({
+                    ...s,
+                    cost: event.costUsd ?? s.cost,
+                    durationMs: event.durationMs ?? s.durationMs,
+                }));
+                if (event.finalText) {
+                    setFinalText(event.finalText);
+                    finalTextRef.current = event.finalText;
+                }
+                return;
+            case "rate_limit":
+                // Surface rate limits via a notification so they don't get lost in the
+                // event stream, but don't dedicate UI space to them in the compact view.
+                app.setNotification({
+                    kind: "error",
+                    message: `Rate limit: ${event.status}`,
+                });
+                return;
+            case "raw":
+                // Quietly drop. Anything important we already surfaced; raw stderr
+                // junk was making the screen flicker.
+                return;
+        }
+    }, [app]);
+    function launch(agent, opts = {}) {
+        if (!skillPath) {
+            setStage({ kind: "missing_skill" });
+            return;
+        }
+        setStage({ kind: "running", agent });
+        setTools([]);
+        setFinalText("");
+        currentTextRef.current = "";
+        finalTextRef.current = "";
+        setStats({ events: 0, tokens: zeroTokens(), startedAt: Date.now() });
+        const handle = runPhaseWithAgent({
+            agent,
+            phaseId,
+            project: folder,
+            skillPath,
+            tape,
+            resume: opts.resume,
+            onEvent: handleEvent,
+        });
+        handleRef.current = handle;
+        handle.done.then(({ code }) => {
+            setStage({ kind: "done", agent, code });
+            // Surface the agent's final-line summary as a notification so it
+            // survives navigation. The full final response stays on this screen.
+            const summary = finalTextRef.current || currentTextRef.current;
+            if (summary) {
+                const oneLine = summary.split("\n").find((l) => l.trim().length > 0) ?? "";
+                if (oneLine) {
+                    const truncated = oneLine.length > 140 ? oneLine.slice(0, 139) + "…" : oneLine;
+                    app.setNotification({
+                        kind: code === 0 ? "info" : "error",
+                        message: `${phase?.label ?? phaseId}: ${truncated}`,
+                    });
+                }
+            }
+            // On clean success, advance the progress cursor by one. Assembly is
+            // the exception — its "real" completion lands in TapeDraftReview when
+            // the curator accepts the proposed sources. Compile and the gates are
+            // their own screens and advance themselves.
+            if (code === 0 && phaseId !== "assembly") {
+                markPhaseComplete(folder, phaseId);
+            }
+            // Phase 7 special-case: a successful assembly run wrote
+            // working/07-tape-draft.yaml. Jump straight into the draft-review.
+            if (code === 0 && phaseId === "assembly") {
+                app.navigate({ kind: "tapeDraft", tape, folder });
+            }
+        });
+    }
+    function cancel() {
+        handleRef.current?.cancel();
+    }
+    useEffect(() => {
+        if (initial.autoLaunch) {
+            launch(initial.autoLaunch);
+        }
+        return () => {
+            handleRef.current?.cancel();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // When entering the done state, park the tool cursor on the most recent
+    // call so the detail panel below the table immediately shows something
+    // useful (the last thing the agent did before finishing). Snap the scroll
+    // window so the cursor sits at the bottom of the viewport.
+    useEffect(() => {
+        if (stage.kind === "done" && tools.length > 0) {
+            const cursor = tools.length - 1;
+            setToolCursor(cursor);
+            setToolScrollTop(Math.max(0, cursor - TOOLS_VIEWPORT + 1));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [stage.kind]);
+    function advance() {
+        if (stage.kind !== "done")
+            return;
+        const next = nextScreenFor(phaseId, tape, folder);
+        if (next)
+            app.navigate(next);
+        else
+            app.navigate({ kind: "hub", tape, folder });
+    }
+    useInput((input, key) => {
+        if (stage.kind === "picking_agent") {
+            if (key.upArrow || input === "k") {
+                setStage({ ...stage, selectedIndex: Math.max(0, stage.selectedIndex - 1) });
+            }
+            else if (key.downArrow || input === "j") {
+                setStage({
+                    ...stage,
+                    selectedIndex: Math.min(stage.agents.length - 1, stage.selectedIndex + 1),
+                });
+            }
+            else if (key.return) {
+                const agent = stage.agents[stage.selectedIndex];
+                if (agent)
+                    launch(agent);
+            }
+            else if (key.escape) {
+                app.navigate({ kind: "hub", tape, folder });
+            }
+            return;
+        }
+        if (stage.kind === "missing_agent" || stage.kind === "missing_skill") {
+            if (key.escape || input === "b") {
+                app.navigate({ kind: "hub", tape, folder });
+            }
+            return;
+        }
+        if (stage.kind === "running") {
+            if (key.escape || input === "c")
+                cancel();
+            return;
+        }
+        if (stage.kind === "done") {
+            const failed = stage.code !== 0;
+            // `t` is the modal toggle. Always available, regardless of mode.
+            if (input === "t") {
+                setInspectMode((m) => {
+                    // Entering inspect mode: snap cursor + window to the last call so
+                    // the detail panel renders something useful from the start.
+                    if (!m && tools.length > 0) {
+                        const cursor = tools.length - 1;
+                        setToolCursor(cursor);
+                        setToolScrollTop(Math.max(0, cursor - TOOLS_VIEWPORT + 1));
+                    }
+                    return !m;
+                });
+                return;
+            }
+            if (inspectMode) {
+                // Inspect mode: arrows scroll, esc / b / t exit, everything else
+                // (enter to advance, r to re-run) is intentionally locked so the
+                // user doesn't accidentally move forward while scanning calls.
+                if (key.upArrow || input === "k") {
+                    if (tools.length === 0)
+                        return;
+                    setToolCursor((c) => {
+                        const next = Math.max(0, c - 1);
+                        setToolScrollTop((s) => (next < s ? next : s));
+                        return next;
+                    });
+                }
+                else if (key.downArrow || input === "j") {
+                    if (tools.length === 0)
+                        return;
+                    setToolCursor((c) => {
+                        const next = Math.min(tools.length - 1, c + 1);
+                        setToolScrollTop((s) => next >= s + TOOLS_VIEWPORT ? next - TOOLS_VIEWPORT + 1 : s);
+                        return next;
+                    });
+                }
+                else if (key.pageUp) {
+                    if (tools.length === 0)
+                        return;
+                    setToolCursor((c) => {
+                        const next = Math.max(0, c - TOOLS_VIEWPORT);
+                        setToolScrollTop(Math.max(0, next));
+                        return next;
+                    });
+                }
+                else if (key.pageDown) {
+                    if (tools.length === 0)
+                        return;
+                    setToolCursor((c) => {
+                        const next = Math.min(tools.length - 1, c + TOOLS_VIEWPORT);
+                        setToolScrollTop(Math.max(0, next - TOOLS_VIEWPORT + 1));
+                        return next;
+                    });
+                }
+                else if (key.escape) {
+                    // Esc inside inspect mode = exit the mode (does NOT bail to hub).
+                    setInspectMode(false);
+                }
+                return;
+            }
+            // Default mode: enter advances, b/esc backs to hub, r retries on fail.
+            if (key.return) {
+                // On failure, Enter = resume (cheap continuation, no re-fetching).
+                // On success, Enter = advance to the next logical screen.
+                if (failed)
+                    launch(stage.agent, { resume: true });
+                else
+                    advance();
+            }
+            else if (input === "r" && failed) {
+                // Failure-only escape hatch: re-run from scratch.
+                launch(stage.agent);
+            }
+            else if (key.escape || input === "b") {
+                app.navigate({ kind: "hub", tape, folder });
+            }
+            return;
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Header, { title: `phase ${phase?.number ?? "?"} — ${phase?.label ?? phaseId}`, subtitle: subtitleFor(stage, skillPath) }),
+        stage.kind === "picking_agent" ? (React.createElement(PickingAgentView, { stage: stage })) : null,
+        stage.kind === "missing_agent" ? React.createElement(MissingAgentView, null) : null,
+        stage.kind === "missing_skill" ? React.createElement(MissingSkillView, null) : null,
+        stage.kind === "running" ? (React.createElement(RunningView, { agent: stage.agent, phase: phase, phaseId: phaseId, tools: tools, stats: stats })) : null,
+        stage.kind === "done" ? (React.createElement(DoneView, { agent: stage.agent, code: stage.code, phaseId: phaseId, phase: phase, tape: tape, folder: folder, tools: tools, finalText: finalText || currentTextRef.current, stats: stats, toolCursor: toolCursor, toolScrollTop: toolScrollTop, inspectMode: inspectMode })) : null,
+        app.notification ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: app.notification.kind === "error" ? ERROR : SUCCESS }, app.notification.message))) : null,
+        React.createElement(KeyHints, { hints: hintsFor(stage, inspectMode) })));
+}
+// ---------------------------------------------------------------------------
+// Sub-views
+// ---------------------------------------------------------------------------
+function PickingAgentView({ stage, }) {
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Text, null, "Multiple agents available \u2014 pick one:"),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" }, stage.agents.map((a, i) => (React.createElement(Box, { key: a.id },
+            React.createElement(Text, { color: i === stage.selectedIndex ? STRUCTURE : undefined },
+                i === stage.selectedIndex ? "▶ " : "  ",
+                a.name),
+            React.createElement(Text, { dimColor: true },
+                "  ",
+                a.bin))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Tip: pick once in the splash menu (",
+                React.createElement(Text, { color: STRUCTURE }, "[s]"),
+                " Settings) to skip this prompt forever \u2014 or set ",
+                React.createElement(Text, { color: STRUCTURE }, "LINER_AGENT=claude"),
+                " in your shell."))));
+}
+function MissingAgentView() {
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Text, { color: ERROR }, "No agent CLI found on PATH."),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, null, "Liner can drive the methodology with either:"),
+            React.createElement(Text, null,
+                "  - Claude Code (",
+                React.createElement(Text, { color: STRUCTURE }, "claude"),
+                ") \u2014 install: ",
+                React.createElement(Text, { color: STRUCTURE }, "npm install -g @anthropic-ai/claude-code")),
+            React.createElement(Text, null,
+                "  - OpenAI Codex (",
+                React.createElement(Text, { color: STRUCTURE }, "codex"),
+                ") \u2014 see https://github.com/openai/codex"))));
+}
+function MissingSkillView() {
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Text, { color: ERROR }, "Couldn't find the curating-mixtapes skill bundle."),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Set ",
+                React.createElement(Text, { color: STRUCTURE }, "LINER_SKILL_PATH"),
+                " to the directory containing SKILL.md."))));
+}
+/**
+ * Compact running view. Two lines + a bordered status block — fits any
+ * terminal height. The full tool list and final response wait for the done
+ * state so the live view never overflows the viewport.
+ */
+function RunningView({ agent, phase, phaseId, tools, stats, }) {
+    const latest = tools[tools.length - 1];
+    const liveDuration = stats.startedAt
+        ? formatDuration(Date.now() - stats.startedAt)
+        : "";
+    const totalTokens = stats.tokens.input +
+        stats.tokens.output +
+        stats.tokens.cacheRead +
+        stats.tokens.cacheCreation;
+    const phaseLabel = phase
+        ? `Phase ${phase.number} — ${phase.label}`
+        : `Phase ${phaseId}`;
+    return (React.createElement(Box, { marginBottom: 1 },
+        React.createElement(LabeledBox, { label: phaseLabel, color: CURRENT, paddingX: 1, paddingY: 1 },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: CURRENT },
+                    React.createElement(Spinner, { type: "dots" }),
+                    " "),
+                React.createElement(Text, null, agent.name),
+                React.createElement(Text, { dimColor: true }, "   ·   running")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    stats.events,
+                    " event",
+                    stats.events === 1 ? "" : "s",
+                    "  ·  ",
+                    tools.length,
+                    " tool",
+                    tools.length === 1 ? "" : "s",
+                    "  ·  ",
+                    formatTokens(totalTokens),
+                    " tokens",
+                    liveDuration ? `  ·  ${liveDuration}` : "")),
+            latest ? (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "latest: "),
+                React.createElement(Text, { color: latest.status === "ok" ? SUCCESS : latest.status === "failed" ? ERROR : STRUCTURE },
+                    latest.status === "ok" ? "✓" : latest.status === "failed" ? "✗" : "⟳",
+                    " "),
+                React.createElement(Text, null, latest.name.replace(/^mcp__[^_]+__/, "")),
+                React.createElement(Text, { dimColor: true },
+                    "  ",
+                    previewify(latest.inputPreview, 60)))) : (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "warming up\u2026"))))));
+}
+function DoneView({ agent, code, phaseId, phase, tape, folder, tools, finalText, stats, toolCursor, toolScrollTop, inspectMode, }) {
+    // Fixed-size scroll viewport. Cursor index drives both the highlighted
+    // row in the list and the content of the detail panel below.
+    const visibleStart = Math.max(0, Math.min(tools.length, toolScrollTop));
+    const visibleEnd = Math.min(tools.length, visibleStart + TOOLS_VIEWPORT);
+    const visibleTools = tools.slice(visibleStart, visibleEnd);
+    const hiddenAbove = visibleStart;
+    const hiddenBelow = Math.max(0, tools.length - visibleEnd);
+    const clampedCursor = Math.max(0, Math.min(tools.length - 1, toolCursor));
+    const selectedTool = tools[clampedCursor];
+    const totalTokens = stats.tokens.input +
+        stats.tokens.output +
+        stats.tokens.cacheRead +
+        stats.tokens.cacheCreation;
+    const next = nextScreenFor(phaseId, tape, folder);
+    const nextLabel = nextScreenLabel(phaseId, tape, folder);
+    return (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: code === 0 ? SUCCESS : ERROR, bold: true }, code === 0 ? "✓ done" : `✗ exited with code ${code}`),
+            React.createElement(Text, { dimColor: true },
+                "   ",
+                agent.name,
+                "  ·  ",
+                stats.events,
+                " events",
+                "  ·  ",
+                tools.length,
+                " tools",
+                "  ·  ",
+                formatTokens(totalTokens),
+                " tokens",
+                stats.durationMs ? `  ·  ${formatDuration(stats.durationMs)}` : "",
+                stats.cost != null ? `  ·  $${stats.cost.toFixed(3)}` : "")),
+        finalText ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(LabeledBox, { label: "final response", color: code === 0 ? SUCCESS : ERROR },
+                React.createElement(MarkdownBody, { text: finalText, maxLines: 18 })))) : null,
+        tools.length > 0 ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(LabeledBox, { label: inspectMode
+                    ? `inspecting tool calls  ·  ${clampedCursor + 1} / ${tools.length}`
+                    : `tool calls  ·  ${tools.length} total  ·  press t to inspect`, color: inspectMode ? CURRENT : STRUCTURE, paddingX: 1 },
+                hiddenAbove > 0 ? (React.createElement(Text, { dimColor: true }, `  ↑ ${hiddenAbove} earlier call${hiddenAbove === 1 ? "" : "s"} above`)) : (React.createElement(Text, { dimColor: true }, "  ")),
+                Array.from({ length: TOOLS_VIEWPORT }).map((_, idx) => {
+                    const tool = visibleTools[idx];
+                    if (!tool)
+                        return React.createElement(Text, { key: `pad-${idx}` }, " ");
+                    return (React.createElement(ToolCallRow, { key: tool.id, call: tool, active: inspectMode && visibleStart + idx === clampedCursor }));
+                }),
+                hiddenBelow > 0 ? (React.createElement(Text, { dimColor: true }, `  ↓ ${hiddenBelow} more call${hiddenBelow === 1 ? "" : "s"} below`)) : (React.createElement(Text, { dimColor: true }, "  "))))) : null,
+        inspectMode ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: CURRENT, bold: true }, "\u25B8 inspect mode  "),
+            React.createElement(Text, { dimColor: true }, "use "),
+            React.createElement(Text, { color: STRUCTURE }, "\u2191\u2193"),
+            React.createElement(Text, { dimColor: true }, " to move, "),
+            React.createElement(Text, { color: STRUCTURE }, "pgup/pgdn"),
+            React.createElement(Text, { dimColor: true }, " to jump, "),
+            React.createElement(Text, { color: STRUCTURE }, "t"),
+            React.createElement(Text, { dimColor: true }, " or "),
+            React.createElement(Text, { color: STRUCTURE }, "esc"),
+            React.createElement(Text, { dimColor: true }, " to exit"))) : null,
+        selectedTool && inspectMode ? (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(LabeledBox, { label: `detail · ${friendlyToolName(selectedTool.name)}`, color: CURRENT, paddingY: 1 },
+                React.createElement(ToolDetailBody, { call: selectedTool })))) : null,
+        React.createElement(Box, { marginBottom: 1 }, code === 0 ? (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: STRUCTURE }, "enter"),
+            React.createElement(Text, { dimColor: true }, ` → ${nextLabel}${next ? "" : " — back to the hub"}`))) : (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: STRUCTURE }, "enter"),
+            React.createElement(Text, { dimColor: true }, " → resume from where the agent stopped (no re-fetching)"))))));
+}
+function ToolCallRow({ call, active = false, }) {
+    // Guard: every now and then the agent stream emits a tool_start with no
+    // name and no input. Skip those rows so they don't punch holes in the box.
+    if (!call.name && !call.inputPreview)
+        return null;
+    const glyph = call.status === "ok" ? "✓" : call.status === "failed" ? "✗" : "⟳";
+    const glyphColor = call.status === "ok" ? SUCCESS : call.status === "failed" ? ERROR : STRUCTURE;
+    const friendlyName = friendlyToolName(call.name);
+    // The "effect" string leads the row — what the tool produced, not what we
+    // sent it. For successful calls that's the result preview; for failures
+    // it's the cleaned-up error; for in-flight calls it's a status line.
+    const effect = effectFor(call);
+    // The input/path becomes a dim trailing chip — the where, not the what.
+    const inputChip = call.inputPreview ? `  [${previewify(call.inputPreview, 40)}]` : "";
+    return (React.createElement(Box, null,
+        React.createElement(Text, { color: active ? CURRENT : undefined, bold: active }, active ? "▸ " : "  "),
+        React.createElement(Text, { color: glyphColor, bold: true },
+            glyph,
+            " "),
+        React.createElement(Text, { color: active ? CURRENT : STRUCTURE, bold: active }, friendlyName.padEnd(13, " ")),
+        React.createElement(Text, { color: call.status === "failed" ? ERROR : undefined }, truncate(effect, 54)),
+        inputChip ? React.createElement(Text, { dimColor: true }, inputChip) : null));
+}
+// Fixed counts so the detail panel always occupies the same vertical space.
+// Switching between tool calls never causes the layout below the box to shift.
+// Empty rows are rendered with a single space so Ink keeps them as real
+// lines (and not collapsed whitespace).
+const DETAIL_INPUT_LINES = 3;
+const DETAIL_RESULT_LINES = 6;
+/**
+ * Detail panel body for the currently-selected tool call. Shows the full
+ * input (path/URL/command/JSON object) and the un-truncated result preview.
+ * The total rendered height is constant: status row + input header + 3 input
+ * lines + result header + 6 result lines + spacers. Padding empty rows when
+ * content is shorter keeps the surrounding layout (NextSteps, KeyHints)
+ * anchored as the user moves the cursor through different tools.
+ */
+function ToolDetailBody({ call }) {
+    const statusColor = call.status === "ok" ? SUCCESS : call.status === "failed" ? ERROR : STRUCTURE;
+    const rawInputLines = formatInputDetail(call.name, call.input);
+    const inputLines = padLines(rawInputLines, DETAIL_INPUT_LINES);
+    const inputTruncated = rawInputLines.length > DETAIL_INPUT_LINES;
+    const resultText = call.resultPreview ? cleanResultPreview(call.resultPreview) : "";
+    const rawResultLines = resultText ? resultText.split("\n") : [];
+    const resultLines = padLines(rawResultLines, DETAIL_RESULT_LINES);
+    const resultTruncated = rawResultLines.length > DETAIL_RESULT_LINES;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: statusColor, bold: true },
+                call.status === "ok" ? "✓" : call.status === "failed" ? "✗" : "⟳",
+                " "),
+            React.createElement(Text, { bold: true }, friendlyToolName(call.name)),
+            React.createElement(Text, { dimColor: true },
+                "  \u00B7  ",
+                call.status)),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: HEADING, bold: true },
+                "input",
+                inputTruncated ? (React.createElement(Text, { dimColor: true }, ` (showing first ${DETAIL_INPUT_LINES} of ${rawInputLines.length})`)) : null),
+            inputLines.map((line, i) => (React.createElement(Text, { key: `in-${i}`, dimColor: true }, "  " + (line || " "))))),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { color: HEADING, bold: true },
+                "result",
+                resultTruncated ? (React.createElement(Text, { dimColor: true }, ` (showing first ${DETAIL_RESULT_LINES} of ${rawResultLines.length})`)) : null),
+            resultLines.map((line, i) => (React.createElement(Text, { key: `res-${i}`, dimColor: true }, "  " + (line || " ")))))));
+}
+/**
+ * Truncate `lines` to `target` rows, padding with empty strings when shorter.
+ * Used to keep the detail panel's render height constant regardless of how
+ * much content the selected tool produced.
+ */
+function padLines(lines, target) {
+    if (lines.length >= target)
+        return lines.slice(0, target);
+    return [...lines, ...new Array(target - lines.length).fill("")];
+}
+/**
+ * Multi-line detail for a tool's input, formatted per tool type. Returns the
+ * full path/URL/command (no truncation) plus secondary fields where they
+ * exist. Falls back to a pretty-printed JSON dump for unknown shapes.
+ */
+function formatInputDetail(name, input) {
+    if (input == null)
+        return [];
+    // String inputs (e.g. a bare shell command Codex emits) still deserve to
+    // show up in the detail panel — fall back to a single line keyed by the
+    // tool's natural label rather than rendering nothing.
+    if (typeof input === "string") {
+        return input ? [`${name === "bash" ? "command" : "input"}: ${input}`] : [];
+    }
+    if (typeof input !== "object")
+        return [];
+    const o = input;
+    const tool = name.replace(/^mcp__[^_]+__/, "");
+    const lines = [];
+    const fieldOrder = [
+        ["url", "url"],
+        ["file_path", "path"],
+        ["path", "path"],
+        ["query", "query"],
+        ["pattern", "pattern"],
+        ["command", "command"],
+        ["prompt", "prompt"],
+        ["description", "description"],
+    ];
+    const known = new Set();
+    for (const [field, label] of fieldOrder) {
+        const v = o[field];
+        if (typeof v === "string" && v) {
+            lines.push(`${label}: ${v}`);
+            known.add(field);
+        }
+    }
+    // Anything else in the input — fall back to a one-line JSON dump per key.
+    // For TodoWrite specifically the `todos` array is the meaningful payload;
+    // render it line-by-line so the curator can read the plan.
+    if (tool === "TodoWrite" && Array.isArray(o["todos"])) {
+        lines.push("todos:");
+        for (const todo of o["todos"]) {
+            const t = (todo ?? {});
+            const status = String(t["status"] ?? "?");
+            const content = String(t["content"] ?? "");
+            const glyph = status === "completed" ? "✓" : status === "in_progress" ? "▸" : "○";
+            lines.push(`  ${glyph} ${content}`);
+        }
+        known.add("todos");
+    }
+    // Any remaining fields go as one-liner key: value JSON-ish entries.
+    for (const [k, v] of Object.entries(o)) {
+        if (known.has(k))
+            continue;
+        if (v == null)
+            continue;
+        const s = typeof v === "string" ? v : JSON.stringify(v);
+        if (!s)
+            continue;
+        lines.push(`${k}: ${s.slice(0, 200)}`);
+    }
+    return lines;
+}
+/**
+ * One-line "what happened" string for a tool call. Falls back through the
+ * available signals so a row never goes empty:
+ *  - result preview (post-call), with `<tool_use_error>` wrappers stripped
+ *  - "fetching…" / "writing…" / etc. for in-flight calls
+ *  - the raw input preview if nothing else is available
+ */
+function effectFor(call) {
+    if (call.status === "running") {
+        return inFlightVerb(call.name);
+    }
+    if (call.resultPreview) {
+        // First line only for the row display; the detail panel shows the full
+        // multi-line preview when the row is selected.
+        return firstLineOf(cleanResultPreview(call.resultPreview));
+    }
+    // Nothing reported — fall back to a tool-typed default so the row stays
+    // informative rather than displaying an empty string.
+    if (call.status === "ok")
+        return defaultDoneFor(call.name);
+    if (call.status === "failed")
+        return "failed without an error message";
+    return "";
+}
+function firstLineOf(s) {
+    const nl = s.indexOf("\n");
+    return nl < 0 ? s : s.slice(0, nl);
+}
+/**
+ * Strip Claude's `<tool_use_error>...</tool_use_error>` envelope and the
+ * "File has not been read yet" preamble that surfaces frequently. Surfacing
+ * the bare message gives the curator a fighting chance at understanding what
+ * went wrong.
+ */
+function cleanResultPreview(s) {
+    let out = s.trim();
+    // Strip XML-style envelope.
+    const m = /<tool_use_error>\s*(.*?)\s*<\/tool_use_error>/is.exec(out);
+    if (m && m[1])
+        out = m[1];
+    // Strip common HTTP-error preambles that don't carry useful information
+    // for someone watching the stream.
+    out = out.replace(/^Error:\s+/i, "");
+    return out;
+}
+/** Human-friendly title for a tool name. */
+function friendlyToolName(raw) {
+    const stripped = raw.replace(/^mcp__[^_]+__/, "");
+    switch (stripped) {
+        case "WebSearch":
+            return "Web search";
+        case "WebFetch":
+            return "Web fetch";
+        case "Read":
+            return "Read file";
+        case "Write":
+            return "Write file";
+        case "Edit":
+            return "Edit file";
+        case "Glob":
+            return "Find files";
+        case "Grep":
+            return "Search code";
+        case "TodoWrite":
+            return "Update plan";
+        case "Bash":
+            return "Shell";
+        default:
+            return stripped;
+    }
+}
+function inFlightVerb(raw) {
+    const n = raw.replace(/^mcp__[^_]+__/, "");
+    switch (n) {
+        case "WebSearch":
+            return "searching the web…";
+        case "WebFetch":
+            return "fetching…";
+        case "Read":
+            return "reading…";
+        case "Write":
+            return "writing…";
+        case "Edit":
+            return "editing…";
+        case "Glob":
+            return "globbing…";
+        case "Grep":
+            return "searching…";
+        case "TodoWrite":
+            return "updating the plan…";
+        case "Bash":
+            return "running…";
+        default:
+            return "working…";
+    }
+}
+function defaultDoneFor(raw) {
+    const n = raw.replace(/^mcp__[^_]+__/, "");
+    switch (n) {
+        case "WebSearch":
+            return "search complete";
+        case "WebFetch":
+            return "fetched";
+        case "Read":
+            return "read";
+        case "Write":
+            return "written";
+        case "Edit":
+            return "edited";
+        case "Glob":
+            return "matched";
+        case "Grep":
+            return "matched";
+        case "TodoWrite":
+            return "plan updated";
+        case "Bash":
+            return "executed";
+        default:
+            return "done";
+    }
+}
+function initialStage(skillPath) {
+    if (!skillPath)
+        return { stage: { kind: "missing_skill" }, autoLaunch: null };
+    const agents = detectAgents();
+    if (agents.length === 0)
+        return { stage: { kind: "missing_agent" }, autoLaunch: null };
+    // Resolution order is centralized in resolveConfiguredAgent:
+    //   LINER_AGENT env > ~/.liner/config.yaml > single-installed > null.
+    // If it returns a non-null agent, we auto-launch and skip the picker. If
+    // it returns null (multiple agents, no config, no env hint), we render
+    // the picker as before.
+    const resolved = resolveConfiguredAgent(agents);
+    if (resolved) {
+        return {
+            stage: {
+                kind: "picking_agent",
+                agents,
+                selectedIndex: agents.indexOf(resolved),
+            },
+            autoLaunch: resolved,
+        };
+    }
+    return {
+        stage: { kind: "picking_agent", agents, selectedIndex: 0 },
+        autoLaunch: null,
+    };
+}
+function subtitleFor(stage, skillPath) {
+    if (stage.kind === "running")
+        return `agent: ${stage.agent.name}`;
+    if (stage.kind === "done")
+        return `agent: ${stage.agent.name}  ·  exit ${stage.code}`;
+    if (stage.kind === "picking_agent")
+        return skillPath ? `skill: ${skillPath}` : "";
+    return "";
+}
+function hintsFor(stage, inspectMode = false) {
+    if (stage.kind === "picking_agent") {
+        return [
+            { key: "↑↓", label: "pick" },
+            { key: "enter", label: "launch" },
+            { key: "esc", label: "cancel" },
+        ];
+    }
+    if (stage.kind === "running") {
+        return [{ key: "esc", label: "cancel run" }];
+    }
+    if (stage.kind === "done") {
+        // Hints split by mode: when inspecting tool calls, only the scroll keys
+        // and the exit keys matter; enter/b are intentionally locked so the user
+        // doesn't accidentally leave inspect mode by advancing.
+        if (inspectMode) {
+            return [
+                { key: "↑↓", label: "move cursor" },
+                { key: "pgup/pgdn", label: "jump page" },
+                { key: "t", label: "exit inspect" },
+                { key: "esc", label: "exit inspect" },
+            ];
+        }
+        const failed = stage.code !== 0;
+        return [
+            { key: "enter", label: failed ? "try again" : "continue" },
+            { key: "t", label: "inspect tool calls" },
+            { key: "b", label: "back to hub" },
+        ];
+    }
+    return [{ key: "b", label: "back" }];
+}
+/**
+ * After a phase run completes, what's the obvious next screen? Returns null
+ * when we should just go back to the hub.
+ *
+ * Mode-aware: quick mode skips the gate review screens (per CURATION.md v2.0
+ * — "Quick mode defaults them to continue"). We auto-accept the gate state
+ * file as a side effect here so the hub's progress strip still shows the
+ * gate as ✓ complete.
+ */
+function nextScreenFor(phaseId, tape, folder) {
+    const isQuick = (tape.mode ?? "quick") !== "methodology";
+    const project = projectFolder(folder);
+    switch (phaseId) {
+        case "framing":
+            if (isQuick) {
+                // Quick mode skips the gate. Auto-accept gate0 + advance the cursor
+                // so the progress strip stays consistent (no skipped step).
+                const state = readGateState(project);
+                writeGateState(project, { ...state, gate0Accepted: true });
+                markPhaseComplete(folder, "gate0");
+                return { kind: "phaseRunner", tape, folder, phaseId: "candidates" };
+            }
+            return { kind: "gate0", tape, folder };
+        case "candidates":
+            if (isQuick) {
+                // Auto-accept Gate 1 — both the legacy gate-state file (so other
+                // surfaces still recognise it as accepted) and the progress cursor.
+                const state = readGateState(project);
+                writeGateState(project, { ...state, gate1Accepted: true });
+                markPhaseComplete(folder, "gate1");
+                return { kind: "phaseRunner", tape, folder, phaseId: "evaluation" };
+            }
+            return { kind: "gate1", tape, folder };
+        case "evaluation":
+            return { kind: "phaseRunner", tape, folder, phaseId: "quality" };
+        case "quality":
+            if (isQuick) {
+                const state = readGateState(project);
+                writeGateState(project, { ...state, gate2Accepted: true });
+                markPhaseComplete(folder, "gate2");
+                return { kind: "phaseRunner", tape, folder, phaseId: "synthesis" };
+            }
+            return { kind: "gate2", tape, folder };
+        case "synthesis":
+            return { kind: "phaseRunner", tape, folder, phaseId: "assembly" };
+        case "assembly":
+            // Handled in the .then() — auto-navigates to tape draft. If somehow we
+            // land on done without a draft, go back to the hub.
+            return null;
+        case "empirical":
+            return null;
+        default:
+            return null;
+    }
+}
+function nextScreenLabel(phaseId, tape, _folder) {
+    const isQuick = (tape.mode ?? "quick") !== "methodology";
+    switch (phaseId) {
+        case "framing":
+            return isQuick
+                ? "continue to Phase 2 — Candidate discovery (framing auto-confirmed in quick mode)"
+                : "continue to Confirm framing — review the knowledge map";
+        case "candidates":
+            return isQuick
+                ? "continue to Phase 3 — Evaluation (candidates auto-confirmed in quick mode)"
+                : "continue to Confirm candidates — review the long-list";
+        case "evaluation":
+            return "continue to Phase 4 — Quality checks";
+        case "quality":
+            return isQuick
+                ? "continue to Phase 5 — Synthesis (evaluation auto-confirmed in quick mode)"
+                : "continue to Confirm evaluation — review keep-list + checks";
+        case "synthesis":
+            return "continue to Phase 6 — Assembly";
+        case "assembly":
+            return "review the proposed sources";
+        case "empirical":
+            return "back to the hub";
+        default:
+            return "back to the hub";
+    }
+}
+function summarizeInput(input) {
+    if (!input || typeof input !== "object")
+        return "";
+    const o = input;
+    if (typeof o["file_path"] === "string")
+        return o["file_path"];
+    if (typeof o["path"] === "string")
+        return o["path"];
+    if (typeof o["url"] === "string")
+        return o["url"];
+    if (typeof o["pattern"] === "string")
+        return o["pattern"];
+    if (typeof o["command"] === "string")
+        return o["command"];
+    if (typeof o["query"] === "string")
+        return o["query"];
+    try {
+        return JSON.stringify(o).slice(0, 80);
+    }
+    catch {
+        return "";
+    }
+}
+function formatTokens(n) {
+    if (n < 1_000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(0)}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.floor((ms % 60_000) / 1000);
+    return `${minutes}m${seconds.toString().padStart(2, "0")}s`;
+}
+function zeroTokens() {
+    return { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+/**
+ * Right-anchored truncation for file paths. The basename is the load-bearing
+ * part of any path the agent reads/writes; keeping it visible is much more
+ * useful than seeing "/Users/arturo/Docu…" without the actual filename.
+ */
+function truncatePath(s, n) {
+    if (s.length <= n)
+        return s;
+    return "…" + s.slice(-(n - 1));
+}
+/**
+ * Heuristic: looks like a filesystem path? Used to pick path-style vs.
+ * plain truncation for the tool-call preview line.
+ */
+function looksLikePath(s) {
+    return s.startsWith("/") || s.startsWith("./") || s.startsWith("../") ||
+        /^[A-Za-z]:[\\/]/.test(s) ||
+        (s.includes("/") && !s.includes(" ") && !s.includes("://"));
+}
+/**
+ * Truncate a value smartly: file paths keep their basename, URLs and other
+ * strings get standard right-trim ellipsis.
+ */
+function previewify(s, n) {
+    if (!s)
+        return "";
+    if (looksLikePath(s))
+        return truncatePath(s, n);
+    return truncate(s, n);
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering for the agent's final response.
+//
+// The agent produces a small markdown blob with `**heading:**` lines, `-` bullets,
+// and inline `` `code` `` / `[bracketed paths]`. Rendering it raw shows the
+// asterisks as literal characters, which looks unfinished. This renderer:
+//
+//   - Strips ** and renders the bold runs with weight + a heading color for
+//     start-of-line headings (the ones ending with `:`).
+//   - Renders `-` / `*` bullets with a cyan `•` glyph and indents the rest.
+//   - Renders ``backtick code`` runs in cyan.
+//   - Detects trailing `[paths/with/slashes]` and dims them so the verb-phrase
+//     leads.
+//
+// Intentionally not a full markdown engine — just enough to make the agent's
+// output legible. If the format grows beyond this, swap in `marked-terminal`
+// or `ink-markdown`.
+// ---------------------------------------------------------------------------
+function MarkdownBody({ text, maxLines = 18, }) {
+    const lines = text.split("\n");
+    const shown = lines.slice(0, maxLines);
+    const truncated = lines.length > maxLines;
+    return (React.createElement(Box, { flexDirection: "column" },
+        shown.map((line, i) => (React.createElement(MarkdownLine, { key: i, line: line }))),
+        truncated ? (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "\u2026 ",
+                lines.length - maxLines,
+                " more lines"))) : null));
+}
+function MarkdownLine({ line }) {
+    // Empty line → one-row spacer (keep paragraphs visible).
+    if (!line.trim()) {
+        return React.createElement(Text, null, " ");
+    }
+    // Bullet line: -  / *  prefix.
+    const bullet = /^(\s*)([-*])\s+(.*)$/.exec(line);
+    if (bullet) {
+        const [, indent, , rest] = bullet;
+        return (React.createElement(Box, null,
+            React.createElement(Text, null, indent),
+            React.createElement(Text, { color: STRUCTURE }, "\u2022 "),
+            React.createElement(InlineSegments, { text: rest ?? "" })));
+    }
+    return (React.createElement(Box, null,
+        React.createElement(InlineSegments, { text: line, headingDetect: true })));
+}
+/**
+ * Tokenize a single line by `**bold**` and `` `code` `` runs.
+ * `**` and backticks themselves are dropped. Unclosed markers fall back to
+ * plain text so we never lose content.
+ */
+function tokenize(s) {
+    const out = [];
+    let i = 0;
+    let buf = "";
+    const flush = () => {
+        if (buf) {
+            out.push({ kind: "plain", text: buf });
+            buf = "";
+        }
+    };
+    while (i < s.length) {
+        if (s[i] === "*" && s[i + 1] === "*") {
+            const end = s.indexOf("**", i + 2);
+            if (end > 0) {
+                flush();
+                out.push({ kind: "bold", text: s.slice(i + 2, end) });
+                i = end + 2;
+                continue;
+            }
+        }
+        if (s[i] === "`") {
+            const end = s.indexOf("`", i + 1);
+            if (end > 0) {
+                flush();
+                out.push({ kind: "code", text: s.slice(i + 1, end) });
+                i = end + 1;
+                continue;
+            }
+        }
+        buf += s[i];
+        i++;
+    }
+    flush();
+    return out;
+}
+/**
+ * Render the inline segments of a line. If `headingDetect` is set and the
+ * first segment is a bold-ending-with-`:`, treat it as a section heading and
+ * give the bold run a cyan tint — so the agent's `**Wrote:**` style ledes
+ * carry the eye.
+ */
+function InlineSegments({ text, headingDetect = false, }) {
+    const segs = tokenize(text);
+    const firstBold = segs[0]?.kind === "bold" && segs[0].text.trim().endsWith(":");
+    return (React.createElement(React.Fragment, null, segs.map((seg, i) => renderSeg(seg, i, headingDetect && firstBold && i === 0))));
+}
+function renderSeg(seg, key, isHeading) {
+    if (seg.kind === "code") {
+        return (React.createElement(Text, { key: key, color: STRUCTURE }, seg.text));
+    }
+    if (seg.kind === "bold") {
+        return (React.createElement(Text, { key: key, bold: true, color: isHeading ? HEADING : undefined }, seg.text));
+    }
+    // Plain text — dim `[bracketed paths]` so they recede.
+    return renderPlainWithBrackets(seg.text, key);
+}
+/**
+ * Plain text, with `[paths/like/this.md]` substrings rendered dim. The
+ * heuristic: a `[...]` run that contains at least one `/` or `.` is treated
+ * as a path/citation. Anything else is rendered as-is.
+ */
+function renderPlainWithBrackets(text, key) {
+    const parts = [];
+    let i = 0;
+    let cursor = 0;
+    let k = 0;
+    while (i < text.length) {
+        if (text[i] === "[") {
+            const close = text.indexOf("]", i + 1);
+            if (close > 0) {
+                const inside = text.slice(i + 1, close);
+                if (inside.includes("/") || inside.includes(".")) {
+                    if (i > cursor) {
+                        parts.push(React.createElement(Text, { key: `${key}-${k++}` }, text.slice(cursor, i)));
+                    }
+                    parts.push(React.createElement(Text, { key: `${key}-${k++}`, dimColor: true },
+                        "[",
+                        inside,
+                        "]"));
+                    i = close + 1;
+                    cursor = i;
+                    continue;
+                }
+            }
+        }
+        i++;
+    }
+    if (cursor < text.length) {
+        parts.push(React.createElement(Text, { key: `${key}-${k++}` }, text.slice(cursor)));
+    }
+    return React.createElement(React.Fragment, { key: key }, parts);
+}
+//# sourceMappingURL=PhaseRunner.js.map