parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/StatusBar.js

@@ -1,32 +1,70 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { compactEndByDisplayWidth, displayWidth } from "./display-width.js";
-const STATUS_BAR_BACKGROUND = "ansi256(236)";
-export function StatusBar({ text, terminalWidth = process.stdout.columns || 120, showTask = false }) {
+import { TUI_THEME } from "./theme.js";
+export function StatusBar({ text, terminalWidth: providedTerminalWidth, showTask = false, fillRail: providedFillRail }) {
+    const terminalWidth = providedTerminalWidth ?? process.stdout.columns ?? 120;
+    const fillRail = providedFillRail ?? (providedTerminalWidth !== undefined || typeof process.stdout.columns === "number");
+    const { segments: fittedSegments, compact } = resolveStatusBar(text, terminalWidth, showTask);
+    if (isIdleStatus(fittedSegments)) {
+        return _jsx(IdleStatusRail, { terminalWidth: terminalWidth, fill: fillRail });
+    }
+    const { leadingWidth, trailingWidth } = statusRailLayout(terminalWidth, statusSegmentsWidth(fittedSegments, compact), { fill: fillRail });
+    return (_jsxs(Box, { children: [leadingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.rail, children: " ".repeat(leadingWidth) }) : null, fittedSegments.map((segment, index) => (_jsx(StatusSegment, { segment: segment, compact: compact, isLast: index === fittedSegments.length - 1 }, `${segment.label}-${index}`))), trailingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.rail, children: " ".repeat(trailingWidth) }) : null] }));
+}
+export function statusBarDisplayText(text, terminalWidth, showTask = false) {
+    const resolved = resolveStatusBar(text, terminalWidth, showTask);
+    if (isIdleStatus(resolved.segments)) {
+        return "";
+    }
+    return resolved.segments.map((segment, index) => {
+        const display = statusSegmentDisplay(segment, resolved.compact);
+        return `${display.label}${display.separator}${display.value}${index < resolved.segments.length - 1 ? statusSegmentSeparator(resolved.compact) : ""}`;
+    }).join("");
+}
+function resolveStatusBar(text, terminalWidth, showTask) {
     const parsedSegments = parseStatusText(text, { hideTask: !showTask || terminalWidth < 40 });
     if (isIdleStatus(parsedSegments)) {
-        return (_jsx(Box, { children: _jsx(Text, { children: " " }) }));
+        return { segments: parsedSegments, compact: false };
     }
-    const segments = omitTinyCurrentSegment(parsedSegments, terminalWidth);
+    const baseSegments = omitTinyCurrentSegment(readableCompletedSegments(parsedSegments, terminalWidth), terminalWidth);
+    const segments = fitCompletedMainIdentityBesideRoute(baseSegments, terminalWidth);
     const compact = shouldUseCompactStatus(segments, terminalWidth);
     const fittedSegments = fitStatusSegments(segments, terminalWidth, compact);
-    if (isIdleStatus(fittedSegments)) {
-        return (_jsx(Box, { children: _jsx(Text, { children: " " }) }));
-    }
+    return { segments: fittedSegments, compact };
+}
+function IdleStatusRail({ terminalWidth, fill }) {
+    const { leadingWidth, trailingWidth } = statusRailLayout(terminalWidth, 0, { fill });
+    return (_jsx(Box, { children: _jsx(Text, { backgroundColor: TUI_THEME.rail, children: " ".repeat(leadingWidth + trailingWidth) }) }));
+}
+export function statusRailLayout(terminalWidth, contentWidth, options = {}) {
     const leadingWidth = terminalWidth > 1 ? 1 : 0;
+    if (options.fill === false) {
+        return { leadingWidth, trailingWidth: 0 };
+    }
     const renderWidth = typeof process.stdout.columns === "number"
         ? Math.max(1, Math.min(terminalWidth, process.stdout.columns))
-        : null;
-    const barWidth = renderWidth === null ? null : Math.max(1, renderWidth - 1);
-    const trailingWidth = barWidth === null
-        ? 0
-        : Math.max(0, barWidth - leadingWidth - statusSegmentsWidth(fittedSegments, compact));
-    return (_jsxs(Box, { children: [leadingWidth > 0 ? _jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, children: " ".repeat(leadingWidth) }) : null, fittedSegments.map((segment, index) => (_jsx(StatusSegment, { segment: segment, compact: compact, isLast: index === fittedSegments.length - 1 }, `${segment.label}-${index}`))), trailingWidth > 0 ? _jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, children: " ".repeat(trailingWidth) }) : null] }));
+        : Math.max(1, terminalWidth);
+    const barWidth = Math.max(1, renderWidth - 1);
+    return {
+        leadingWidth,
+        trailingWidth: Math.max(0, barWidth - leadingWidth - Math.max(0, contentWidth))
+    };
 }
 function omitTinyCurrentSegment(segments, terminalWidth) {
     if (terminalWidth >= 24 || segments.length <= 1) {
         return segments;
     }
+    const current = segments.find((segment) => segment.label.toLowerCase() === "current");
+    const currentRole = current ? workerIdentityStatus(current.value)?.role : undefined;
+    if (current
+        && (currentRole === "main"
+            || current.tone === "run"
+            || current.tone === "wait"
+            || current.tone === "fail"
+            || current.tone === "stop")) {
+        return segments;
+    }
     const compacted = segments.filter((segment) => segment.label.toLowerCase() !== "current");
     return compacted.length > 0 ? compacted : segments;
 }
@@ -37,36 +75,243 @@ function shouldUseCompactStatus(segments, terminalWidth) {
     const roomyDisplays = segments.map((segment) => statusSegmentDisplay(segment, false));
     return statusSegmentsDisplayWidth(roomyDisplays, false) > Math.max(1, terminalWidth - 2);
 }
+function readableCompletedSegments(segments, terminalWidth) {
+    const workersIndex = segments.findIndex((segment) => segment.label.toLowerCase() === "workers");
+    const doneIndex = segments.findIndex((segment) => (segment.label.toLowerCase() === "done" && segment.tone === "done"));
+    const routeIndex = segments.findIndex((segment) => (segment.label.toLowerCase() === "route"
+        && !segment.tone
+        && /^(?:simple|complex)(?:\s+·\s+|$)/i.test(segment.value)));
+    const completed = workersIndex >= 0
+        && doneIndex >= 0
+        && segments[workersIndex]?.value === segments[doneIndex]?.value;
+    if (!completed) {
+        return segments;
+    }
+    const readable = segments.map((segment, index) => (index === doneIndex
+        ? { ...segment, value: "done", hideLabel: true }
+        : index === routeIndex && terminalWidth < 56
+            ? { ...segment, hideLabel: true }
+            : segment));
+    return readable;
+}
+function fitCompletedMainIdentityBesideRoute(segments, terminalWidth) {
+    if (terminalWidth < 56 || segments.length !== 2) {
+        return segments;
+    }
+    const currentIndex = segments.findIndex((segment) => segment.label.toLowerCase() === "current");
+    const routeIndex = segments.findIndex((segment) => segment.label.toLowerCase() === "route");
+    if (currentIndex < 0 || routeIndex < 0 || statusSegmentsWidth(segments, false) <= terminalWidth - 2) {
+        return segments;
+    }
+    const current = segments[currentIndex];
+    const identity = current ? workerIdentityStatus(current.value) : null;
+    if (!current
+        || identity?.role !== "main"
+        || current.tone === "run"
+        || current.tone === "wait"
+        || current.tone === "fail") {
+        return segments;
+    }
+    const route = segments[routeIndex];
+    if (!route) {
+        return segments;
+    }
+    const contentWidth = Math.max(1, terminalWidth - 2);
+    const currentWidth = Math.max(1, contentWidth
+        - statusSegmentsWidth([route], false)
+        - displayWidth(statusSegmentSeparator(false)));
+    const fittedCurrent = fitCurrentStatusSegment(current, currentWidth, false);
+    if (!fittedCurrent) {
+        return segments;
+    }
+    const fitted = segments.map((segment, index) => (index === currentIndex ? fittedCurrent : segment));
+    return statusSegmentsWidth(fitted, false) <= contentWidth ? fitted : segments;
+}
 function isIdleStatus(segments) {
     return segments.length === 1 && segments[0]?.tone === "idle" && segments[0]?.value === "idle";
 }
 function StatusSegment({ segment, compact, isLast }) {
     const display = statusSegmentDisplay(segment, compact);
-    return (_jsxs(Box, { flexShrink: 0, children: [display.label ? (_jsxs(_Fragment, { children: [_jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, color: colorForTone(segment.tone), dimColor: segment.tone === undefined || segment.tone === "idle", children: display.label }), _jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, dimColor: true, children: display.separator })] })) : null, _jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, color: valueColorForTone(segment.tone), bold: segment.tone !== undefined && segment.tone !== "idle", wrap: "truncate-end", children: display.value }), !isLast ? _jsx(Text, { backgroundColor: STATUS_BAR_BACKGROUND, dimColor: true, children: statusSegmentSeparator(compact) }) : null] }));
+    return (_jsxs(Box, { flexShrink: 0, children: [display.label ? (_jsxs(_Fragment, { children: [_jsx(Text, { ...statusSegmentLabelTheme(segment.tone), children: display.label }), _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: display.separator })] })) : null, _jsx(Text, { ...statusSegmentValueTheme(segment.tone), wrap: "truncate-end", children: display.value }), !isLast ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: statusSegmentSeparator(compact) }) : null] }));
 }
 function fitStatusSegments(segments, terminalWidth, compact) {
     const contentWidth = Math.max(1, terminalWidth - 2);
-    if (statusSegmentsWidth(segments, compact) <= contentWidth) {
-        return segments;
+    const semanticSegments = segments.map((segment) => fitAtomicStatusSegment(segment, contentWidth, compact));
+    if (statusSegmentsWidth(semanticSegments, compact) <= contentWidth) {
+        return semanticSegments;
     }
-    const displays = segments.map((segment) => statusSegmentDisplay(segment, compact));
-    const totalWidth = statusSegmentsDisplayWidth(displays, compact);
-    const currentIndex = segments.map((segment) => segment.label.toLowerCase()).lastIndexOf("current");
+    const activeMainPair = fitActiveMainWithCompletedRoute(semanticSegments, contentWidth, compact);
+    if (activeMainPair) {
+        return activeMainPair;
+    }
+    const currentIndex = semanticSegments.map((segment) => segment.label.toLowerCase()).lastIndexOf("current");
     if (currentIndex >= 0) {
-        const currentDisplay = displays[currentIndex];
-        if (currentDisplay) {
-            const overflow = totalWidth - contentWidth;
-            const nextValueWidth = Math.max(1, displayWidth(currentDisplay.value) - overflow);
-            const fitted = segments.map((segment, index) => index === currentIndex
-                ? { ...segment, value: compactStatusTextEnd(segment.value, nextValueWidth) }
-                : segment);
-            if (statusSegmentsWidth(fitted, compact) <= contentWidth) {
-                return fitted;
+        const current = semanticSegments[currentIndex];
+        if (current) {
+            const others = semanticSegments.filter((_, index) => index !== currentIndex);
+            const besideWidth = contentWidth
+                - statusSegmentsWidth(others, compact)
+                - (others.length > 0 ? displayWidth(statusSegmentSeparator(compact)) : 0);
+            const fittedBeside = fitCurrentStatusSegment(current, besideWidth, compact, true);
+            if (fittedBeside) {
+                const fitted = semanticSegments.map((segment, index) => (index === currentIndex ? fittedBeside : segment));
+                if (statusSegmentsWidth(fitted, compact) <= contentWidth) {
+                    return fitted;
+                }
             }
+            const fittedCurrent = fitCurrentStatusSegment(current, contentWidth, compact);
+            const fitted = fittedCurrent
+                ? semanticSegments.map((segment, index) => index === currentIndex ? fittedCurrent : segment)
+                : semanticSegments.filter((_, index) => index !== currentIndex);
             return selectStatusSegmentsThatFit(fitted, contentWidth, compact);
         }
     }
-    return selectStatusSegmentsThatFit(segments, contentWidth, compact);
+    return selectStatusSegmentsThatFit(semanticSegments, contentWidth, compact);
+}
+function fitActiveMainWithCompletedRoute(segments, contentWidth, compact) {
+    if (segments.length !== 2) {
+        return null;
+    }
+    const currentIndex = segments.findIndex((segment) => segment.label.toLowerCase() === "current");
+    const routeIndex = segments.findIndex((segment) => segment.label.toLowerCase() === "route");
+    const current = segments[currentIndex];
+    const route = segments[routeIndex];
+    if (currentIndex < 0
+        || routeIndex < 0
+        || !current
+        || !route
+        || (current.tone !== "run" && current.tone !== "wait" && current.tone !== "fail")
+        || !/^(?:simple|complex)(?:\s+·\s+|$)/i.test(route.value)
+        || workerIdentityStatus(current.value)?.role !== "main") {
+        return null;
+    }
+    for (const value of currentStatusValueCandidates(current.value)) {
+        const fittedCurrent = { ...current, value };
+        if (!currentStatusDisplay(value, compact).value) {
+            continue;
+        }
+        const remaining = contentWidth
+            - statusSegmentsWidth([fittedCurrent], compact)
+            - displayWidth(statusSegmentSeparator(compact));
+        const fittedRoute = fitCompletedRouteSegment(route, remaining, compact);
+        if (!fittedRoute) {
+            continue;
+        }
+        const pair = segments.map((segment, index) => (index === currentIndex ? fittedCurrent : fittedRoute));
+        if (statusSegmentsWidth(pair, compact) <= contentWidth) {
+            return pair;
+        }
+    }
+    const fittedCurrent = fitCurrentStatusSegment(current, contentWidth, compact);
+    return fittedCurrent ? [fittedCurrent] : null;
+}
+function fitCompletedRouteSegment(segment, maxWidth, compact) {
+    if (maxWidth <= 0) {
+        return null;
+    }
+    const display = statusSegmentDisplay(segment, compact);
+    const valueWidth = maxWidth - displayWidth(`${display.label}${display.separator}`);
+    if (valueWidth < 1) {
+        return null;
+    }
+    const value = compactCompletedRouteStatusValue(segment.value, valueWidth);
+    return value ? { ...segment, value } : null;
+}
+function compactCompletedRouteStatusValue(value, maxWidth) {
+    const parts = value.split(/\s+·\s+/).map((part) => part.trim()).filter(Boolean);
+    const mode = /^(?:simple|complex)$/i.test(parts[0] ?? "") ? parts[0] : null;
+    const duration = parts.find((part) => /^\d+(?:\.\d+)?(?:ms|s|m)(?:\s+total)?$/i.test(part));
+    const compactFailure = compactRouteStatusValue(value, true);
+    const exceptional = /(?:^|\s·\s)(?:fallback|forced)(?:\s·\s|$)/i.test(value);
+    const candidates = [
+        value,
+        ...(mode && exceptional && compactFailure !== value
+            ? [`${mode} · ${compactFailure}${duration ? ` · ${duration}` : ""}`]
+            : []),
+        ...(mode && duration ? [`${mode} · ${duration}`] : []),
+        ...(mode ? [mode] : []),
+        ...(compactFailure !== value ? [compactFailure] : []),
+        ...(duration ? [duration] : [])
+    ];
+    return candidates.find((candidate) => displayWidth(candidate) <= maxWidth) ?? null;
+}
+function fitCurrentStatusSegment(segment, maxWidth, compact, requireDetail = false) {
+    if (maxWidth <= 0) {
+        return null;
+    }
+    for (const value of currentStatusValueCandidates(segment.value)) {
+        const candidate = { ...segment, value };
+        if (requireDetail && !currentStatusDisplay(value, compact).value) {
+            continue;
+        }
+        if (statusSegmentsWidth([candidate], compact) <= maxWidth) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function currentStatusValueCandidates(text) {
+    const identity = workerIdentityStatus(text);
+    const roleMatch = identity ? null : text.match(/^(main|judge|actor|critic)(?:\s+(.+))?$/i);
+    const role = identity?.role ?? roleMatch?.[1]?.toLowerCase();
+    if (!role) {
+        return [text];
+    }
+    const fullIdentity = identity ? `${identity.role}/${identity.engine}` : role;
+    const detail = identity
+        ? text.slice(fullIdentity.length).trim()
+        : roleMatch?.[2]?.trim() ?? "";
+    const compactDetail = compactCurrentStatusDetail(detail);
+    const compactState = compactDetail.split(/\s+/, 1)[0] ?? "";
+    return Array.from(new Set([
+        text,
+        ...(compactDetail ? [`${fullIdentity} ${compactDetail}`] : []),
+        ...(compactDetail ? [`${role} ${compactDetail}`] : []),
+        ...(compactState ? [`${fullIdentity} ${compactState}`] : []),
+        ...(compactState ? [`${role} ${compactState}`] : []),
+        fullIdentity,
+        role,
+        compactRoleStatusLabel(role)
+    ].filter(Boolean)));
+}
+function compactCurrentStatusDetail(detail) {
+    const progress = detail.match(/^(waiting output|responding)\s+·\s+(\d+(?:\.\d+)?s)\s*\/\s*(\d+(?:\.\d+)?(?:ms|s|m))\s+(?:first|idle)$/i);
+    if (progress) {
+        const state = progress[1]?.toLowerCase() === "responding" ? "reply" : "wait";
+        return `${state} ${progress[2]}/${progress[3]}`;
+    }
+    const state = detail.match(/^(starting|running|run|done|failed|fail|waiting|wait|queued|stopping|stop|idle|cancelled|canceled)\b/i)?.[1]?.toLowerCase();
+    if (state === "starting") {
+        return "start";
+    }
+    if (state === "running") {
+        return "run";
+    }
+    if (state === "failed") {
+        return "fail";
+    }
+    if (state === "waiting" || state === "queued") {
+        return "wait";
+    }
+    if (state === "stopping" || state === "cancelled" || state === "canceled") {
+        return "stop";
+    }
+    return state ?? "";
+}
+function fitAtomicStatusSegment(segment, contentWidth, compact) {
+    if (segment.label.toLowerCase() !== "route"
+        || (segment.tone !== "wait" && segment.tone !== "fail")) {
+        return segment;
+    }
+    const display = statusSegmentDisplay(segment, compact);
+    const valueWidth = Math.max(1, contentWidth - displayWidth(`${display.label}${display.separator}`));
+    if (displayWidth(display.value) <= valueWidth) {
+        return segment;
+    }
+    return {
+        ...segment,
+        value: compactRouteStatusValueToWidth(segment.value, valueWidth)
+    };
 }
 function statusSegmentsDisplayWidth(displays, compact) {
     const segmentWidths = displays.map((display) => displayWidth(`${display.label}${display.separator}${display.value}`));
@@ -93,32 +338,51 @@ function selectStatusSegmentsThatFit(segments, contentWidth, compact) {
 }
 function statusSegmentKeepPriority(segment) {
     const label = segment.label.toLowerCase();
+    if (label === "route" && segment.tone === "fail") {
+        return -1;
+    }
     if (segment.tone === "fail" || label === "fail") {
         return 0;
     }
-    if (segment.tone === "run" || label === "run") {
+    if (segment.tone === "stop" || label === "stop") {
         return 1;
     }
-    if (segment.tone === "wait" || label === "wait") {
+    if (segment.tone === "run" || label === "run") {
         return 2;
     }
-    if (label === "workers") {
+    if (segment.tone === "wait" || label === "wait") {
         return 3;
     }
-    if (segment.tone === "done" || label === "done") {
+    if (label === "workers") {
         return 4;
     }
-    if (label === "current") {
+    if (segment.tone === "done" || label === "done") {
         return 5;
     }
-    return 6;
+    if (label === "current") {
+        return 6;
+    }
+    if (label === "route") {
+        return 8;
+    }
+    return 7;
 }
 function compactSingleStatusSegment(segment, contentWidth, compact) {
     const display = statusSegmentDisplay(segment, compact);
     const labelWidth = displayWidth(`${display.label}${display.separator}`);
+    const valueWidth = Math.max(1, contentWidth - labelWidth);
+    if (segment.label.toLowerCase() === "route") {
+        return {
+            ...segment,
+            value: compactRouteStatusValueToWidth(segment.value, valueWidth)
+        };
+    }
+    if (segment.label.toLowerCase() === "current") {
+        return fitCurrentStatusSegment(segment, contentWidth, compact) ?? segment;
+    }
     return {
         ...segment,
-        value: compactStatusTextEnd(display.value, Math.max(1, contentWidth - labelWidth))
+        value: compactStatusTextEnd(display.value, valueWidth)
     };
 }
 function statusSegmentSeparator(compact) {
@@ -127,7 +391,20 @@ function statusSegmentSeparator(compact) {
 function compactStatusTextEnd(text, maxLength) {
     return compactEndByDisplayWidth(text, maxLength);
 }
+function workerIdentityStatus(text) {
+    const match = text.trim().match(/^(main|judge|actor|critic)\/([^\s]+)(?:\s+.*)?$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        role: (match[1] ?? "").toLowerCase(),
+        engine: match[2] ?? ""
+    };
+}
 function statusSegmentDisplay(segment, compact) {
+    if (segment.hideLabel) {
+        return { label: "", separator: "", value: segment.value };
+    }
     const label = segment.label.toLowerCase();
     if (label === "task") {
         return { label: "", separator: "", value: segment.value };
@@ -135,13 +412,33 @@ function statusSegmentDisplay(segment, compact) {
     if (isRoleStatusLabel(label)) {
         return {
             label: compact ? compactRoleStatusLabel(label) : displayRoleStatusLabel(label),
-            separator: compact ? ":" : " ",
+            separator: compact ? ":" : " · ",
             value: segment.value
         };
     }
+    if (label === "route") {
+        return {
+            label: compact ? "r" : "route",
+            separator: compact ? ":" : " ",
+            value: compactRouteStatusValue(segment.value, compact)
+        };
+    }
+    if (label === "wave") {
+        return {
+            label: "wave",
+            separator: " ",
+            value: compact ? compactWaveStatusValue(segment.value) : segment.value
+        };
+    }
     if (!compact) {
         if (label === "current") {
-            return { label: "@", separator: " ", value: segment.value };
+            return currentStatusDisplay(segment.value, false);
+        }
+        if (label === "workers") {
+            return { label: "workers", separator: " ", value: segment.value };
+        }
+        if (segment.tone && segment.tone !== "idle" && label === segment.tone) {
+            return { label: segment.tone, separator: " ", value: segment.value };
         }
         if (segment.tone && segment.tone !== "idle") {
             return { label: segment.tone, separator: " ", value: segment.value };
@@ -149,16 +446,177 @@ function statusSegmentDisplay(segment, compact) {
         return { label, separator: " ", value: segment.value };
     }
     if (label === "workers") {
-        return { label: "w", separator: "", value: segment.value };
+        return { label: "wk", separator: "", value: segment.value };
     }
     if (label === "current") {
-        return { label: "@", separator: " ", value: segment.value };
+        return currentStatusDisplay(segment.value, true);
     }
     if (segment.tone && segment.tone !== "idle") {
         return { label: compactToneLabel(segment.tone), separator: "", value: segment.value };
     }
     return { label, separator: " ", value: segment.value };
 }
+function currentStatusDisplay(text, compact) {
+    const identity = workerIdentityStatus(text);
+    if (identity) {
+        const fullIdentity = `${identity.role}/${identity.engine}`;
+        const detail = text.slice(fullIdentity.length).trim();
+        return {
+            label: fullIdentity,
+            separator: detail ? (compact ? ":" : " · ") : "",
+            value: detail
+        };
+    }
+    const role = text.match(/^(main|judge|actor|critic)(?:\s+(.+))?$/i);
+    if (role) {
+        const detail = role[2]?.trim() ?? "";
+        return {
+            label: displayRoleStatusLabel(role[1] ?? ""),
+            separator: detail ? (compact ? ":" : " · ") : "",
+            value: detail
+        };
+    }
+    return { label: text, separator: "", value: "" };
+}
+function compactRouteStatusValue(value, compact) {
+    if (compact && /(?:^|\s·\s)fallback(?:\s·\s|$)/i.test(value)) {
+        const cause = value
+            .split(/\s+·\s+/)
+            .find((part) => /^(?:(?:idle|total) timeout(?: waiting output| after (?:stdout|stderr|output))?|first output timeout|timeout(?: via proxy| waiting output| after (?:stdout|stderr|output))?|proxy|auth|rate limit|network|unavailable|invalid output|exit)$/i.test(part));
+        if (cause) {
+            return cause.toLowerCase() === "invalid output" ? "invalid" : cause.toLowerCase();
+        }
+        return "fallback";
+    }
+    return value;
+}
+function compactRouteStatusValueToWidth(value, maxWidth) {
+    const compact = compactRouteStatusValue(value, true);
+    const parts = value.split(/\s+·\s+/).map((part) => part.trim()).filter(Boolean);
+    const duration = parts.find((part) => /^\d+(?:\.\d+)?(?:ms|s|m)(?:\s+(?:max|total|first|idle))?$/i.test(part))
+        ?.replace(/\s+(?:max|total|first|idle)$/i, "");
+    const progress = parts
+        .map((part) => part.match(/^(\d+(?:\.\d+)?s)\s*\/\s*(\d+(?:\.\d+)?(?:ms|s|m))(?:\s+(first|total))?$/i))
+        .find((match) => match !== null);
+    const elapsed = progress?.[1];
+    const compactProgress = progress
+        ? `${elapsed?.replace(/s$/i, "")}/${progress[2]}`
+        : undefined;
+    const progressCandidates = compactProgress
+        ? [compactProgress, elapsed].filter((item) => Boolean(item))
+        : duration ? [duration] : [];
+    const first = parts[0]?.toLowerCase() ?? "";
+    const retry = first.match(/^retry\s+(\d+\/\d+)$/);
+    let candidates;
+    if (retry) {
+        candidates = [compact, `retry ${retry[1]}`, retry[1] ?? "retry", "retry"];
+    }
+    else if (first === "checking") {
+        candidates = [compact, progressCandidates[0] ? `check ${progressCandidates[0]}` : "check", ...progressCandidates, "wait"];
+    }
+    else if (first === "follow-up") {
+        candidates = [compact, progressCandidates[0] ? `follow ${progressCandidates[0]}` : "follow", ...progressCandidates, "wait"];
+    }
+    else if (routeProgressStatusAlias(first)) {
+        const alias = routeProgressStatusAlias(first);
+        const firstOutputProgress = progress?.[3]?.toLowerCase() === "first";
+        candidates = [
+            compact,
+            ...(compactProgress ? [`${alias} ${compactProgress}`] : []),
+            ...(firstOutputProgress && compactProgress ? [compactProgress] : []),
+            ...(elapsed ? [`${alias} ${elapsed}`] : []),
+            alias,
+            ...progressCandidates,
+            "wait"
+        ];
+    }
+    else if (/(?:^|\s·\s)fallback(?:\s·\s|$)/i.test(value)) {
+        candidates = [compact, ...compactRouteFailureAliases(compact), "wait"];
+    }
+    else {
+        candidates = [compact, first, "route"];
+    }
+    return candidates.find((candidate) => displayWidth(candidate) <= maxWidth)
+        ?? candidates.at(-1)
+        ?? "route";
+}
+function compactRouteFailureAliases(value) {
+    if (value === "timeout via proxy") {
+        return ["proxy", "p:to"];
+    }
+    if (value === "proxy") {
+        return ["pxy"];
+    }
+    if (value === "rate limit") {
+        return ["rate"];
+    }
+    if (value === "timeout") {
+        return ["time"];
+    }
+    if (value === "timeout waiting output") {
+        return ["wait:to", "w:to", "time"];
+    }
+    if (value === "timeout after stderr") {
+        return ["err:to", "e:to", "time"];
+    }
+    if (value === "timeout after stdout") {
+        return ["out:to", "o:to", "time"];
+    }
+    if (value === "timeout after output") {
+        return ["out:to", "o:to", "time"];
+    }
+    if (value === "first output timeout") {
+        return ["first:to", "f:to", "time"];
+    }
+    if (value.startsWith("idle timeout")) {
+        return ["idle:to", "i:to", "time"];
+    }
+    if (value.startsWith("total timeout")) {
+        return ["total:to", "t:to", "time"];
+    }
+    if (value === "network") {
+        return ["net"];
+    }
+    if (value === "unavailable") {
+        return ["down"];
+    }
+    if (value === "invalid") {
+        return ["bad"];
+    }
+    if (value === "fallback") {
+        return ["fall"];
+    }
+    return [value];
+}
+function routeProgressStatusAlias(value) {
+    if (value === "starting") {
+        return "start";
+    }
+    if (value === "waiting output") {
+        return "wait";
+    }
+    if (value === "diagnostics") {
+        return "diag";
+    }
+    if (value === "receiving") {
+        return "recv";
+    }
+    if (value === "parsing") {
+        return "parse";
+    }
+    if (value === "stopping") {
+        return "stop";
+    }
+    return null;
+}
+function compactWaveStatusValue(value) {
+    return value
+        .replace(/\s+·\s+actor\s+/i, " a")
+        .replace(/\s+·\s+critic\s+/i, " c")
+        .replace(/\s+·\s+revision\s+/i, " r")
+        .replace(/\s+·\s+integration\s+/i, " i")
+        .replace(/\s+·\s+verification\s+/i, " v");
+}
 function compactToneLabel(tone) {
     if (tone === "run") {
         return "r";
@@ -169,18 +627,18 @@ function compactToneLabel(tone) {
     if (tone === "fail") {
         return "f";
     }
+    if (tone === "stop") {
+        return "s";
+    }
     return "w";
 }
 function isRoleStatusLabel(label) {
     return label === "main" || label === "judge" || label === "actor" || label === "critic";
 }
 function displayRoleStatusLabel(label) {
-    return label === "main" ? "chat" : label;
+    return label;
 }
 function compactRoleStatusLabel(label) {
-    if (label === "main") {
-        return "chat";
-    }
     return label.slice(0, 1);
 }
 function parseStatusText(text, options = {}) {
@@ -201,11 +659,30 @@ function parseStatusText(text, options = {}) {
         segments.push({ label: "TASK", value: first, tone: first === "idle" ? "idle" : undefined });
     }
     for (const part of statusParts) {
+        const wave = parseWaveProgress(part);
+        if (wave) {
+            segments.push(wave);
+            continue;
+        }
         const workerMatch = part.match(/^workers\s+(\d+)$/i);
         if (workerMatch) {
             segments.push({ label: "WORKERS", value: workerMatch[1] ?? "0" });
             continue;
         }
+        const routeMatch = part.match(/^route\s+(.+)$/i);
+        if (routeMatch) {
+            const value = routeMatch[1]?.trim() || "unknown";
+            segments.push({
+                label: "ROUTE",
+                value,
+                tone: /(?:^|\s·\s)fallback(?:\s·\s|$)/i.test(value)
+                    ? "fail"
+                    : /^(?:checking|follow-up|starting|retry|waiting output|diagnostics|receiving|parsing|stopping)\b/i.test(value)
+                        ? "wait"
+                        : undefined
+            });
+            continue;
+        }
         const counts = parseStateCounts(part);
         if (counts.length > 0) {
             segments.push(...counts);
@@ -216,10 +693,26 @@ function parseStatusText(text, options = {}) {
     return segments.length > 0 ? segments : [{ label: "STATUS", value: "idle", tone: "idle" }];
 }
 function isStatusPart(part) {
-    return /^workers\s+\d+$/i.test(part) || parseStateCounts(part).length > 0;
+    return parseWaveProgress(part) !== null
+        || /^workers\s+\d+$/i.test(part)
+        || /^route\s+\S+/i.test(part)
+        || parseStateCounts(part).length > 0
+        || parseRoleStatus(part) !== null
+        || workerIdentityStatus(part) !== null;
+}
+function parseWaveProgress(part) {
+    const match = part.match(/^wave\s+(\d+\/\d+)\s+·\s+(actor|critic|revision|integration|verification)\s+(\d+\/\d+)$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        label: "WAVE",
+        value: `${match[1]} · ${(match[2] ?? "actor").toLowerCase()} ${match[3]}`,
+        tone: "run"
+    };
 }
 function parseStateCounts(part) {
-    const matches = Array.from(part.matchAll(/\b(run|done|fail|wait|idle)\s+(\d+)\b/gi));
+    const matches = Array.from(part.matchAll(/\b(run|done|fail|wait|stop|idle)\s+(\d+)\b/gi));
     if (matches.length === 0) {
         return [];
     }
@@ -233,12 +726,23 @@ function parseStateCounts(part) {
     });
 }
 function parseCurrentStatus(part) {
+    const mainEngineStatus = parseMainEngineStatus(part);
+    if (mainEngineStatus) {
+        return mainEngineStatus;
+    }
     const roleStatus = parseRoleStatus(part);
     if (roleStatus) {
         return roleStatus;
     }
-    const toneMatch = part.match(/\b(run|done|fail|wait|idle)\b/i);
+    const toneMatch = part.match(/\b(run|done|fail|wait|stop|idle)\b/i);
     const tone = toneMatch ? normalizeTone(toneMatch[1] ?? "idle") : undefined;
+    if (workerIdentityStatus(part)) {
+        return {
+            label: "CURRENT",
+            value: part,
+            tone
+        };
+    }
     const value = toneMatch ? part.replace(toneMatch[0], "").trim() || part : part;
     return {
         label: "CURRENT",
@@ -246,8 +750,41 @@ function parseCurrentStatus(part) {
         tone
     };
 }
+function parseMainEngineStatus(part) {
+    const match = part.match(/^main\/([^\s]+)\s+([^\s]+)\b/i);
+    if (!match) {
+        return null;
+    }
+    const status = (match[2] ?? "idle").toLowerCase();
+    return {
+        label: "CURRENT",
+        value: part,
+        tone: runtimeStatusTone(status)
+    };
+}
+function runtimeStatusTone(status) {
+    if (status === "run" || status === "running" || status === "starting" || status === "responding") {
+        return "run";
+    }
+    if (status === "done") {
+        return "done";
+    }
+    if (status === "fail" || status === "failed" || status === "error") {
+        return "fail";
+    }
+    if (status === "wait" || status === "waiting" || status === "queued" || status === "stopping") {
+        return "wait";
+    }
+    if (status === "stop" || status === "cancelled" || status === "canceled") {
+        return "stop";
+    }
+    if (status === "idle") {
+        return "idle";
+    }
+    return undefined;
+}
 function parseRoleStatus(part) {
-    const match = part.match(/^(main|judge|actor|critic)\s+(run|done|fail|wait|idle)\b/i);
+    const match = part.match(/^(main|judge|actor|critic)\s+(run|done|fail|wait|stop|idle)\b/i);
     if (!match) {
         return null;
     }
@@ -260,29 +797,45 @@ function parseRoleStatus(part) {
 }
 function normalizeTone(value) {
     const normalized = value.toLowerCase();
-    if (normalized === "run" || normalized === "done" || normalized === "fail" || normalized === "wait") {
+    if (normalized === "run" || normalized === "done" || normalized === "fail" || normalized === "wait" || normalized === "stop") {
         return normalized;
     }
     return "idle";
 }
+export function statusSegmentLabelTheme(_tone) {
+    return {
+        backgroundColor: TUI_THEME.rail,
+        color: TUI_THEME.muted
+    };
+}
+export function statusSegmentValueTheme(tone) {
+    return {
+        backgroundColor: TUI_THEME.rail,
+        color: valueColorForTone(tone),
+        ...(tone === "run" || tone === "fail" ? { bold: true } : {})
+    };
+}
 function colorForTone(tone) {
     if (tone === "run") {
-        return "cyan";
+        return TUI_THEME.accent;
     }
     if (tone === "done") {
-        return "green";
+        return TUI_THEME.success;
     }
     if (tone === "fail") {
-        return "red";
+        return TUI_THEME.danger;
     }
     if (tone === "wait") {
-        return "yellow";
+        return TUI_THEME.warning;
+    }
+    if (tone === "stop") {
+        return TUI_THEME.warning;
     }
-    return "gray";
+    return TUI_THEME.muted;
 }
 function valueColorForTone(tone) {
-    if (tone === "fail") {
-        return "red";
+    if (tone === "run" || tone === "done" || tone === "fail" || tone === "wait" || tone === "stop") {
+        return colorForTone(tone);
     }
-    return undefined;
+    return TUI_THEME.text;
 }