linersh 0.5.7 → 1.0.0

package/dist/screens/PhaseRunner.js

@@ -1,1203 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Box, Text, useApp as useInkApp, useInput, useStdout } 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 { MUTED, CURRENT, ERROR, HEADING, STRUCTURE, SUCCESS } from "../colors.js";
-import { useApp } from "../store.js";
-import { detectAgents, resolveSkillPathWithDiagnostics, } 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;
-const FINAL_RESPONSE_VIEWPORT = 7;
-const FINAL_RESPONSE_INSPECT_VIEWPORT = 3;
-export function PhaseRunner({ tape, folder, phaseId, }) {
-    const app = useApp();
-    const ink = useInkApp();
-    const { stdout } = useStdout();
-    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 skillResolution = useMemo(() => resolveSkillPathWithDiagnostics(), []);
-    const skillPath = skillResolution.path;
-    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 [finalScrollTop, setFinalScrollTop] = useState(0);
-    const handleRef = useRef(null);
-    const renderedFinalText = finalText || currentTextRef.current;
-    const finalLineCount = renderedFinalText ? renderedFinalText.split("\n").length : 0;
-    const finalViewportLines = finalResponseViewportLines(stdout?.rows ?? 24, inspectMode);
-    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("");
-        setFinalScrollTop(0);
-        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 }) => {
-            // Clear the screen as we flip running → done. The running view and the
-            // done view differ in height, and on terminals that keep scrollback in
-            // the alternate buffer the old running frames otherwise linger above
-            // the done view (stacked duplicate headers). Clearing once on the
-            // transition lands the done view on a fresh canvas.
-            if (process.stdout.isTTY)
-                process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
-            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 (input === "q") {
-                ink.exit();
-            }
-            else if (key.escape) {
-                app.navigate({ kind: "hub", tape, folder });
-            }
-            return;
-        }
-        if (stage.kind === "missing_agent" || stage.kind === "missing_skill") {
-            if (input === "q") {
-                ink.exit();
-            }
-            else 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 done mode: arrows/page keys scroll the final response. Normal
-            // terminal scrollback is unavailable in the alternate screen, and mouse
-            // wheels arrive as arrow keys in many terminals; make those inputs move
-            // the readable response instead of doing nothing.
-            if (key.upArrow || input === "k") {
-                setFinalScrollTop((s) => Math.max(0, Math.min(s, Math.max(0, finalLineCount - finalViewportLines)) - 1));
-                return;
-            }
-            if (key.downArrow || input === "j") {
-                setFinalScrollTop((s) => Math.min(Math.max(0, finalLineCount - finalViewportLines), Math.min(s, Math.max(0, finalLineCount - finalViewportLines)) + 1));
-                return;
-            }
-            if (key.pageUp) {
-                setFinalScrollTop((s) => Math.max(0, Math.min(s, Math.max(0, finalLineCount - finalViewportLines)) -
-                    finalViewportLines));
-                return;
-            }
-            if (key.pageDown) {
-                setFinalScrollTop((s) => Math.min(Math.max(0, finalLineCount - finalViewportLines), s + finalViewportLines));
-                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 (input === "q") {
-                ink.exit();
-            }
-            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, { resolution: skillResolution })) : 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: renderedFinalText, finalScrollTop: finalScrollTop, finalViewportLines: finalViewportLines, 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, { color: MUTED },
-                "  ",
-                a.bin))))),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { color: MUTED },
-                "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({ resolution, }) {
-    const checked = resolution.searched.slice(0, 5);
-    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, flexDirection: "column" },
-            React.createElement(Text, { color: MUTED },
-                "Set ",
-                React.createElement(Text, { color: STRUCTURE }, "LINER_SKILL_PATH"),
-                " to the directory containing SKILL.md."),
-            resolution.envPath ? (React.createElement(Text, { color: MUTED },
-                "Current ",
-                React.createElement(Text, { color: STRUCTURE }, "LINER_SKILL_PATH"),
-                ": ",
-                resolution.envPath)) : null,
-            checked.length > 0 ? (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Text, { color: MUTED }, "Checked:"),
-                checked.map((path) => (React.createElement(Text, { key: path, color: MUTED },
-                    "  - ",
-                    path))))) : null)));
-}
-/**
- * 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, { color: MUTED }, "   ·   running")),
-            React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: MUTED },
-                    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, { color: MUTED }, "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, { color: MUTED },
-                    "  ",
-                    previewify(latest.inputPreview, 60)))) : (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: MUTED }, "warming up\u2026"))))));
-}
-function DoneView({ agent, code, phaseId, phase, tape, folder, tools, finalText, finalScrollTop, finalViewportLines, 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, { color: MUTED },
-                "   ",
-                agent.name,
-                "  ·  ",
-                stats.events,
-                " events",
-                "  ·  ",
-                tools.length,
-                " tools",
-                "  ·  ",
-                formatTokens(totalTokens),
-                " tokens",
-                stats.durationMs ? `  ·  ${formatDuration(stats.durationMs)}` : "")),
-        finalText ? (React.createElement(Box, { marginBottom: 1 },
-            React.createElement(LabeledBox, { label: finalResponseLabel(finalText, finalScrollTop, finalViewportLines), color: code === 0 ? SUCCESS : ERROR },
-                React.createElement(MarkdownBody, { text: finalText, maxLines: finalViewportLines, scrollTop: finalScrollTop, color: code === 0 ? SUCCESS : ERROR })))) : 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, { color: MUTED }, `  ↑ ${hiddenAbove} earlier call${hiddenAbove === 1 ? "" : "s"} above`)) : (React.createElement(Text, { color: MUTED }, "  ")),
-                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, { color: MUTED }, `  ↓ ${hiddenBelow} more call${hiddenBelow === 1 ? "" : "s"} below`)) : (React.createElement(Text, { color: MUTED }, "  "))))) : null,
-        inspectMode ? (React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: CURRENT, bold: true }, "\u25B8 inspect mode  "),
-            React.createElement(Text, { color: MUTED }, "use "),
-            React.createElement(Text, { color: STRUCTURE }, "\u2191\u2193"),
-            React.createElement(Text, { color: MUTED }, " to move, "),
-            React.createElement(Text, { color: STRUCTURE }, "pgup/pgdn"),
-            React.createElement(Text, { color: MUTED }, " to jump, "),
-            React.createElement(Text, { color: STRUCTURE }, "t"),
-            React.createElement(Text, { color: MUTED }, " or "),
-            React.createElement(Text, { color: STRUCTURE }, "esc"),
-            React.createElement(Text, { color: MUTED }, " 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 },
-            React.createElement(Text, { color: HEADING }, code === 0
-                ? `next · ${nextLabel}${next ? "" : " — back to the hub"}`
-                : "next · enter resumes 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, { color: MUTED }, 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, { color: MUTED },
-                "  \u00B7  ",
-                call.status)),
-        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-            React.createElement(Text, { color: HEADING, bold: true },
-                "input",
-                inputTruncated ? (React.createElement(Text, { color: MUTED }, ` (showing first ${DETAIL_INPUT_LINES} of ${rawInputLines.length})`)) : null),
-            inputLines.map((line, i) => (React.createElement(Text, { key: `in-${i}`, color: MUTED }, "  " + (line || " "))))),
-        React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-            React.createElement(Text, { color: HEADING, bold: true },
-                "result",
-                resultTruncated ? (React.createElement(Text, { color: MUTED }, ` (showing first ${DETAIL_RESULT_LINES} of ${rawResultLines.length})`)) : null),
-            resultLines.map((line, i) => (React.createElement(Text, { key: `res-${i}`, color: MUTED }, "  " + (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" },
-            { key: "q", label: "quit" },
-        ];
-    }
-    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: "↑↓", label: "scroll response" },
-            { key: "pgup/pgdn", label: "jump" },
-            { key: "enter", label: failed ? "try again" : "continue" },
-            { key: "t", label: "inspect tool calls" },
-            { key: "b", label: "back to hub" },
-            { key: "q", label: "quit" },
-        ];
-    }
-    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;
-        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";
-        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 finalResponseViewportLines(termRows, inspectMode) {
-    if (inspectMode)
-        return FINAL_RESPONSE_INSPECT_VIEWPORT;
-    // Keep enough space for status, tool calls, next-action line, and key hints.
-    // The body lines still may wrap, so this is intentionally conservative.
-    return Math.max(3, Math.min(FINAL_RESPONSE_VIEWPORT, termRows - 34));
-}
-function finalResponseLabel(text, scrollTop, viewportLines) {
-    const total = text.split("\n").length;
-    const maxScroll = Math.max(0, total - viewportLines);
-    const start = Math.min(Math.max(0, scrollTop), maxScroll);
-    const end = Math.min(total, start + viewportLines);
-    return total > viewportLines
-        ? `final response  ·  lines ${start + 1}-${end} / ${total}`
-        : "final response";
-}
-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/me/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, scrollTop = 0, color, }) {
-    const lines = text.split("\n");
-    const maxScroll = Math.max(0, lines.length - maxLines);
-    const start = Math.min(Math.max(0, scrollTop), maxScroll);
-    const shown = lines.slice(start, start + maxLines);
-    const hiddenAbove = start;
-    const hiddenBelow = Math.max(0, lines.length - (start + shown.length));
-    return (React.createElement(Box, { flexDirection: "column" },
-        hiddenAbove > 0 ? (React.createElement(Text, { color: MUTED },
-            "\u2191 ",
-            hiddenAbove,
-            " earlier line",
-            hiddenAbove === 1 ? "" : "s")) : null,
-        shown.map((line, i) => (React.createElement(MarkdownLine, { key: start + i, line: line, color: color }))),
-        hiddenBelow > 0 ? (React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { color: MUTED },
-                "\u2193 ",
-                hiddenBelow,
-                " more line",
-                hiddenBelow === 1 ? "" : "s",
-                " \u00B7 use \u2191\u2193 or pgup/pgdn"))) : null));
-}
-function MarkdownLine({ line, color }) {
-    // Empty line → one-row spacer (keep paragraphs visible).
-    if (!line.trim()) {
-        return React.createElement(Text, null, " ");
-    }
-    // Bullet line: -  / *  prefix. The marker stays orange (STRUCTURE); the
-    // rest of the bullet text takes the body color.
-    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 ?? "", color: color })));
-    }
-    return (React.createElement(Box, null,
-        React.createElement(InlineSegments, { text: line, headingDetect: true, color: color })));
-}
-/**
- * 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, color, }) {
-    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, color))));
-}
-function renderSeg(seg, key, isHeading, color) {
-    if (seg.kind === "code") {
-        // Inline code keeps the structural orange regardless of body color.
-        return (React.createElement(Text, { key: key, color: STRUCTURE }, seg.text));
-    }
-    if (seg.kind === "bold") {
-        return (React.createElement(Text, { key: key, bold: true, color: color }, seg.text));
-    }
-    // Plain text — dim `[bracketed paths]` so they recede.
-    return renderPlainWithBrackets(seg.text, key, color);
-}
-/**
- * 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, color) {
-    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++}`, color: color }, text.slice(cursor, i)));
-                    }
-                    parts.push(React.createElement(Text, { key: `${key}-${k++}`, color: MUTED },
-                        "[",
-                        inside,
-                        "]"));
-                    i = close + 1;
-                    cursor = i;
-                    continue;
-                }
-            }
-        }
-        i++;
-    }
-    if (cursor < text.length) {
-        parts.push(React.createElement(Text, { key: `${key}-${k++}`, color: color }, text.slice(cursor)));
-    }
-    return React.createElement(React.Fragment, { key: key }, parts);
-}
-//# sourceMappingURL=PhaseRunner.js.map