parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/markdown-text.js

@@ -0,0 +1,14 @@
+export function decodeHtmlEntities(text) {
+    return text
+        .replace(/←/g, "←")
+        .replace(/→/g, "→")
+        .replace(/↑/g, "↑")
+        .replace(/↓/g, "↓")
+        .replace(/·/g, "·")
+        .replace(/ /g, " ")
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, "\"")
+        .replace(/&#39;/g, "'");
+}

package/dist/tui/raw-input-decoder.js

@@ -16,3 +16,6 @@ export function createRawInputDecoder() {
         }
     };
 }
+export function tokenizeRawInput(input) {
+    return Array.from(input.matchAll(/\x1b\[M[\s\S]{3}|\x1b\[[0-?]*[ -/]*[@-~]|\x1bO[\s\S]|\x1b[^\x00-\x1f\x7f]|[\s\S]/gu), (match) => match[0]);
+}

package/dist/tui/scrolling.js

@@ -12,7 +12,8 @@ export function selectViewportLines(text, height, offsetFromBottom) {
     };
 }
 export function nextScrollOffset(current, delta, maxOffset) {
-    return clamp(current + delta, 0, Math.max(0, maxOffset));
+    const next = Math.max(0, current + delta);
+    return maxOffset === null ? next : Math.min(next, Math.max(0, maxOffset));
 }
 function splitLines(text) {
     if (!text) {

package/dist/tui/status-line.js

@@ -1,15 +1,31 @@
+import { classifyRouterFailure } from "../core/router-audit.js";
+import { compactEndByDisplayWidth } from "./display-width.js";
+export function effectiveWorkerWatchdog(watchdogMs, totalTimeoutMs) {
+    if (!watchdogMs || watchdogMs <= 0) {
+        return undefined;
+    }
+    if (totalTimeoutMs && totalTimeoutMs > 0 && watchdogMs >= totalTimeoutMs) {
+        return undefined;
+    }
+    return watchdogMs;
+}
 export function formatStatusLine(state) {
     if (!state) {
         return "idle";
     }
     const parts = [compactTaskId(state.taskId)];
+    if (state.main) {
+        const mainIdentity = state.mainEngine ? `main/${state.mainEngine}` : "main";
+        parts.push(`${mainIdentity} ${formatMainStatus(state.main, state.mainProgress)}`);
+        return parts.join(" | ");
+    }
+    if (state.featureProgress) {
+        parts.push(formatFeatureProgress(state.featureProgress));
+    }
     if (state.workers?.length) {
         parts.push(formatWorkerSummary(state.workers));
         return parts.join(" | ");
     }
-    if (state.main) {
-        parts.push(`main ${compactStatus(state.main)}`);
-    }
     if (state.judge) {
         parts.push(`judge ${compactStatus(state.judge)}`);
     }
@@ -21,6 +37,254 @@ export function formatStatusLine(state) {
     }
     return parts.join(" | ");
 }
+function formatMainStatus(status, progress) {
+    const state = compactStatus(status);
+    if (!progress || state === "done" || state === "fail" || state === "stop") {
+        return state;
+    }
+    if (progress.phase === "initialized") {
+        return "starting";
+    }
+    if (progress.phase === "process-starting" || progress.phase === "native-resume-fallback") {
+        return formatMainWaitProgress("waiting output", progress.elapsedMs, progress.firstOutputTimeoutMs, "first");
+    }
+    if (progress.phase === "process-output") {
+        return formatMainWaitProgress("responding", progress.elapsedMs, progress.idleTimeoutMs, "idle");
+    }
+    if (progress.phase === "process-stopping") {
+        return "stopping";
+    }
+    return state;
+}
+function formatMainWaitProgress(label, elapsedMs, budgetMs, budgetLabel) {
+    if (!budgetMs || budgetMs <= 0) {
+        return label;
+    }
+    const elapsed = Math.min(Math.max(0, elapsedMs), budgetMs);
+    return `${label} · ${formatMainElapsed(elapsed)} / ${formatMainBudget(budgetMs)} ${budgetLabel}`;
+}
+function formatMainElapsed(durationMs) {
+    return `${Math.floor(durationMs / 1000)}s`;
+}
+function formatMainBudget(durationMs) {
+    if (durationMs >= 60_000 && durationMs % 60_000 === 0) {
+        return `${durationMs / 60_000}m`;
+    }
+    return formatRouteDuration(durationMs);
+}
+function formatFeatureProgress(progress) {
+    return `wave ${progress.wave}/${progress.waves} · ${progress.phase} ${progress.completed}/${progress.total}`;
+}
+export function formatRouteStatus(route) {
+    if (!route) {
+        return "";
+    }
+    const details = [route.mode];
+    if (route.source === "forced" || route.source === "fallback") {
+        details.push(route.source);
+    }
+    if (route.router_fallback_resolution === "main") {
+        details.push("user Main");
+    }
+    else if (route.router_fallback_resolution === "parallel") {
+        details.push("user Parallel");
+    }
+    else if (route.router_fallback_resolution === "cancelled") {
+        details.push("user cancelled");
+    }
+    else if (route.router_fallback_resolution === "retry") {
+        details.push("Router retry");
+    }
+    else if (route.router_fallback_resolution === "auto-retry") {
+        details.push("auto retry");
+    }
+    const recovery = routeRecoveryLabel(route);
+    if (recovery) {
+        details.push(recovery);
+    }
+    if (typeof route.router_attempt === "number" && route.router_attempt > 1) {
+        details.push(`try ${route.router_attempt}`);
+    }
+    if (route.source === "fallback") {
+        const cause = route.router_failure_kind && route.router_failure_kind !== "unknown"
+            ? route.router_failure_kind
+            : classifyRouterFailure(route.reason) ?? "unknown";
+        details.push(routeFailureKindLabel(cause, route));
+        const proxy = routeProxyStatus(route, cause);
+        if (proxy) {
+            details.push(proxy);
+        }
+    }
+    else if (route.proxy_configured && route.proxy_endpoint) {
+        details.push(`via ${route.proxy_endpoint}`);
+    }
+    if (typeof route.router_total_duration_ms === "number"
+        && typeof route.router_attempt === "number"
+        && route.router_attempt > 1) {
+        details.push(`${formatRouteDuration(route.router_total_duration_ms)} total`);
+    }
+    else if (typeof route.duration_ms === "number"
+        && (route.source !== "forced" || route.duration_ms > 0)) {
+        details.push(formatRouteDuration(route.duration_ms));
+    }
+    return `route ${details.join(" · ")}`;
+}
+function routeRecoveryLabel(route) {
+    if (!route.router_recovered_from) {
+        return null;
+    }
+    const prefix = route.router_recovered_via === "auto-retry" ? "auto recovered" : "recovered";
+    if (route.router_recovered_from !== "timeout") {
+        return `${prefix} ${route.router_recovered_from.replaceAll("-", " ")}`;
+    }
+    const timeout = route.router_recovered_timeout_kind === "first-output"
+        ? "first output timeout"
+        : route.router_recovered_timeout_kind === "idle"
+            ? "idle timeout"
+            : route.router_recovered_timeout_kind === "total"
+                ? "total timeout"
+                : "timeout";
+    return `${prefix} ${timeout}`;
+}
+export function formatRoutePendingStatus(state, elapsedMs) {
+    if (!state) {
+        return "";
+    }
+    if (state.mode !== "auto") {
+        return `route ${state.mode} · forced`;
+    }
+    const path = routePendingPathLabel(state);
+    if (state.phase === "retrying") {
+        const details = [
+            `retry ${state.attempt}/${state.maxAttempts}`,
+            ...(state.command && state.command !== "codex" ? [`runner ${state.command}`] : []),
+            ...(path ? [path] : []),
+            `${formatRouteDuration(state.retryDelayMs ?? 0)} backoff`
+        ];
+        return `route ${details.join(" · ")}`;
+    }
+    const label = routePendingPhaseLabel(state);
+    const details = [
+        label,
+        ...(state.attempt > 1 ? [`try ${state.attempt}`] : []),
+        ...(state.command && state.command !== "codex" ? [`runner ${state.command}`] : []),
+        ...(path ? [path] : [])
+    ];
+    details.push(...routePendingBudgetDetails(state, elapsedMs));
+    return `route ${details.join(" · ")}`;
+}
+function routePendingBudgetDetails(state, elapsedMs) {
+    const firstOutputActive = state.phase === "dispatching"
+        || state.phase === "starting"
+        || state.phase === "waiting-output";
+    const idleActive = state.phase === "receiving-stderr" || state.phase === "receiving-response";
+    const firstOutputIsSeparate = firstOutputActive
+        && typeof state.firstOutputTimeoutMs === "number"
+        && state.firstOutputTimeoutMs < state.timeoutMs;
+    const idleIsSeparate = idleActive
+        && typeof state.idleTimeoutMs === "number"
+        && state.idleTimeoutMs < state.timeoutMs;
+    if (typeof elapsedMs === "number") {
+        if (firstOutputIsSeparate) {
+            const boundedElapsedMs = Math.min(state.firstOutputTimeoutMs, Math.max(0, elapsedMs));
+            return [
+                `${formatRouteElapsed(boundedElapsedMs)} / ${formatRouteDuration(state.firstOutputTimeoutMs)} first`,
+                `${formatRouteDuration(state.timeoutMs)} total`
+            ];
+        }
+        const boundedElapsedMs = Math.min(state.timeoutMs, Math.max(0, elapsedMs));
+        if (idleIsSeparate) {
+            return [
+                `${formatRouteElapsed(boundedElapsedMs)} / ${formatRouteDuration(state.timeoutMs)} total`,
+                `${formatRouteDuration(state.idleTimeoutMs)} idle`
+            ];
+        }
+        return [`${formatRouteElapsed(boundedElapsedMs)} / ${formatRouteDuration(state.timeoutMs)}`];
+    }
+    if (firstOutputIsSeparate) {
+        return [
+            `${formatRouteDuration(state.firstOutputTimeoutMs)} first`,
+            `${formatRouteDuration(state.timeoutMs)} total`
+        ];
+    }
+    if (idleIsSeparate) {
+        return [
+            `${formatRouteDuration(state.timeoutMs)} total`,
+            `${formatRouteDuration(state.idleTimeoutMs)} idle`
+        ];
+    }
+    return [`${formatRouteDuration(state.timeoutMs)} max`];
+}
+function routeFailureKindLabel(kind, route) {
+    if (kind === "timeout") {
+        const stage = routeTimeoutStageSuffix(route);
+        if (route.router_timeout_kind === "first-output") {
+            return "first output timeout";
+        }
+        if (route.router_timeout_kind === "idle") {
+            return `idle timeout${stage}`;
+        }
+        if (route.router_timeout_kind === "total") {
+            return `total timeout${stage}`;
+        }
+        return `timeout${stage}`;
+    }
+    if (kind === "unknown") {
+        return "unknown failure";
+    }
+    return kind.replaceAll("-", " ");
+}
+function routeTimeoutStageSuffix(route) {
+    if (route.router_failure_stage === "waiting-output") {
+        return " waiting output";
+    }
+    if (route.router_failure_stage !== "streaming") {
+        return "";
+    }
+    if (route.router_stdout_bytes && route.router_stdout_bytes > 0) {
+        return " after stdout";
+    }
+    if (route.router_stderr_bytes && route.router_stderr_bytes > 0) {
+        return " after stderr";
+    }
+    return " after output";
+}
+function routeProxyStatus(route, cause) {
+    if (route.proxy_configured === true) {
+        return route.proxy_endpoint ? `via ${route.proxy_endpoint}` : "via proxy";
+    }
+    if (route.proxy_configured === false) {
+        return "direct";
+    }
+    return cause === "timeout" && /\bproxy\b|代理/i.test(route.reason) ? "proxy set" : null;
+}
+function routePendingPhaseLabel(state) {
+    if (state.phase === "dispatching" || state.phase === "starting") {
+        return "starting";
+    }
+    if (state.phase === "waiting-output") {
+        return "waiting output";
+    }
+    if (state.phase === "receiving-stderr") {
+        return "diagnostics";
+    }
+    if (state.phase === "receiving-response") {
+        return "receiving";
+    }
+    if (state.phase === "parsing") {
+        return "parsing";
+    }
+    if (state.phase === "stopping") {
+        return "stopping";
+    }
+    return state.scope === "follow-up" ? "follow-up" : "checking";
+}
+function routePendingPathLabel(state) {
+    if (state.proxyConfigured === true) {
+        return state.proxyEndpoint ? `via ${state.proxyEndpoint}` : "via proxy";
+    }
+    return state.proxyConfigured === false ? "direct" : null;
+}
 export function formatSelectedWorkerStatus(state, selectedIndex) {
     const worker = state?.workers?.[selectedIndex];
     if (!worker) {
@@ -28,30 +292,70 @@ export function formatSelectedWorkerStatus(state, selectedIndex) {
     }
     return `${compactWorkerLabel(worker.label)} ${compactStatus(worker.status)}`;
 }
+export function selectedWorkerStatusIsRedundant(state) {
+    const workers = state?.workers;
+    if (!workers?.length) {
+        return false;
+    }
+    const first = compactStatus(workers[0]?.status ?? "");
+    return workers.every((worker) => compactStatus(worker.status) === first);
+}
 export function formatWorkerRuntimeStatus(status) {
-    const native = status.native_session_id ? ` native:${compactNativeSessionId(status.native_session_id)}` : "";
-    const detail = `${status.state}/${status.phase}${native}: ${status.summary.trim() || "no summary"}`;
-    return detail.length > 96 ? `${detail.slice(0, 93)}...` : detail;
+    const detail = [
+        status.state.trim() || "idle",
+        humanizeWorkerPhase(status.phase),
+        status.native_session_id ? `session ${compactNativeSessionId(status.native_session_id)}` : "",
+        status.summary.trim() || "no summary"
+    ].filter(Boolean).join(" · ");
+    return compactEndByDisplayWidth(detail, 96);
 }
 export function formatFooterHelp(mode = "chat") {
     if (mode === "native") {
-        return "wheel/Pg · ^] detach";
+        return "scroll · ^] logs";
     }
     if (mode === "worker") {
-        return "wheel/Pg · Tab worker · ^O attach · Esc chat";
+        return "scroll · Tab · ^O attach · Esc chat";
     }
-    return "^W logs · Tab worker · ^O attach";
+    return "^W logs · Tab · ^O attach";
 }
 function compactNativeSessionId(sessionId) {
     return sessionId.length > 12 ? `${sessionId.slice(0, 8)}...` : sessionId;
 }
+function formatRouteDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${Math.round(durationMs)}ms`;
+    }
+    if (durationMs < 10000) {
+        return `${(durationMs / 1000).toFixed(1).replace(/\.0$/, "")}s`;
+    }
+    return `${Math.round(durationMs / 1000)}s`;
+}
+function formatRouteElapsed(durationMs) {
+    return `${Math.floor(durationMs / 1000)}s`;
+}
+function humanizeWorkerPhase(phase) {
+    const normalized = phase.trim().toLowerCase();
+    if (!normalized) {
+        return "";
+    }
+    if (normalized === "process-idle-timeout") {
+        return "idle timeout";
+    }
+    if (normalized === "process-exited") {
+        return "exited";
+    }
+    if (normalized === "native-resume-failed") {
+        return "resume failed";
+    }
+    return normalized.replace(/[-_]+/g, " ");
+}
 function formatWorkerSummary(workers) {
     const counts = new Map();
     for (const worker of workers) {
         const state = compactStatus(worker.status);
         counts.set(state, (counts.get(state) ?? 0) + 1);
     }
-    const priority = ["fail", "run", "wait", "done"];
+    const priority = ["fail", "stop", "run", "wait", "done"];
     const orderedStates = [
         ...priority.filter((state) => counts.has(state)),
         ...Array.from(counts.keys()).filter((state) => !priority.includes(state)).sort()
@@ -71,6 +375,9 @@ function compactStatus(status) {
     if (state === "failed" || state === "error") {
         return "fail";
     }
+    if (state === "cancelled" || state === "canceled") {
+        return "stop";
+    }
     if (state === "waiting" || state === "queued") {
         return "wait";
     }
@@ -82,7 +389,7 @@ function compactTaskId(taskId) {
     return dated?.[1] ?? withoutPrefix;
 }
 function compactWorkerLabel(label) {
-    const match = label.match(/^\s*([^(]+?)\s*\(([^)]+)\)\s*$/);
+    const match = label.match(/^\s*([^(]+?)\s*\(([^)]+)\)/);
     if (match) {
         return `${match[1].trim().toLowerCase()}/${match[2].trim().toLowerCase()}`;
     }

package/dist/tui/task-memory.js

@@ -1,3 +1,15 @@
+export function currentSubmitMemoryState(activeTaskId, activeMode) {
+    return {
+        activeTaskId,
+        activeMode: activeTaskId ? "complex" : activeMode
+    };
+}
+export function newTaskMemoryState() {
+    return {
+        activeTaskId: null,
+        activeMode: null
+    };
+}
 export function chooseSubmitTarget(state, route) {
     if (state.activeTaskId && state.activeMode === "complex") {
         if (route?.mode === "simple") {
@@ -25,5 +37,5 @@ export function nextSubmitMemoryState(current, target, result) {
     };
 }
 export function shouldClearWorkersForSubmit(target) {
-    return target.kind !== "task-question";
+    return target.kind === "new-request";
 }

package/dist/tui/task-result.js

@@ -0,0 +1,105 @@
+const RESULT_SECTIONS = [
+    { key: "requirements", heading: "Requirements:", redundantHeading: /^(?:requirements|scope)$/i },
+    { key: "implementation", heading: "Actor work:", redundantHeading: /^(?:actor work|worklog|implementation)$/i },
+    { key: "changes", heading: "Changed files:", redundantHeading: /^(?:changed files|changes)$/i },
+    { key: "review", heading: "Critic review:", redundantHeading: /^(?:critic review|review)$/i },
+    { key: "verification", heading: "Verification:", redundantHeading: /^(?:verification|checks)$/i },
+    { key: "findings", heading: "Critic findings:", redundantHeading: /^(?:critic findings|findings)$/i }
+];
+export function parseTaskResultSummary(text) {
+    const lines = text.split(/\r?\n/);
+    if (!/^Complex task completed\.$/i.test((lines[0] ?? "").trim())) {
+        return null;
+    }
+    const indexes = RESULT_SECTIONS.map((section) => (lines.findIndex((line) => line.trim().toLowerCase() === section.heading.toLowerCase())));
+    if (indexes.every((index) => index < 0)) {
+        return null;
+    }
+    const values = RESULT_SECTIONS.map((section, sectionIndex) => {
+        const start = indexes[sectionIndex] ?? -1;
+        if (start < 0) {
+            return "";
+        }
+        const end = indexes
+            .slice(sectionIndex + 1)
+            .filter((index) => index > start)
+            .reduce((minimum, index) => Math.min(minimum, index), lines.length);
+        return normalizeTaskResultSection(lines.slice(start + 1, end), section.redundantHeading);
+    });
+    const sections = {
+        requirements: values[0] ?? "",
+        implementation: values[1] ?? "",
+        changes: values[2] ?? "",
+        review: values[3] ?? "",
+        verification: values[4] ?? "",
+        findings: values[5] ?? ""
+    };
+    return {
+        outcome: taskResultOutcome(sections.review),
+        sections
+    };
+}
+export function latestTaskResultMessageIndex(messages, taskId) {
+    if (taskId) {
+        const scoped = findTaskResultMessageIndex(messages, (message) => message.taskId === taskId);
+        if (scoped >= 0) {
+            return scoped;
+        }
+        return findTaskResultMessageIndex(messages, (message) => message.taskId === undefined);
+    }
+    return findTaskResultMessageIndex(messages, () => true);
+}
+function findTaskResultMessageIndex(messages, matchesScope) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.from === "system"
+            && matchesScope(message)
+            && parseTaskResultSummary(message.text)) {
+            return index;
+        }
+    }
+    return -1;
+}
+function normalizeTaskResultSection(lines, redundantHeading) {
+    const normalized = lines
+        .map(sanitizeTaskResultLine)
+        .filter((line, index, all) => !isRedundantTaskResultHeading(line, redundantHeading, index, all));
+    while (normalized[0]?.trim() === "") {
+        normalized.shift();
+    }
+    while (normalized.at(-1)?.trim() === "") {
+        normalized.pop();
+    }
+    const value = normalized.join("\n").trim();
+    return /^\(empty\)$/i.test(value) ? "" : value;
+}
+function sanitizeTaskResultLine(line) {
+    return line
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .trimEnd();
+}
+function isRedundantTaskResultHeading(line, redundantHeading, index, all) {
+    const heading = line.trim().replace(/^#{1,6}\s+/, "").replace(/:$/, "");
+    if (!redundantHeading.test(heading)) {
+        return false;
+    }
+    return all.slice(0, index).every((previous) => previous.trim() === "");
+}
+function taskResultOutcome(review) {
+    for (const line of review.split(/\r?\n/)) {
+        const decision = line
+            .trim()
+            .replace(/^#{1,6}\s+/, "")
+            .replace(/^[-*]\s+/, "")
+            .replace(/^\*\*([^*]+)\*\*$/, "$1")
+            .trim();
+        if (/^(?:REVISION_REQUIRED|REJECTED|FAILED)\b/i.test(decision)) {
+            return "revision-required";
+        }
+        if (/^APPROVED\b/i.test(decision)) {
+            return "approved";
+        }
+    }
+    return "completed";
+}

package/dist/tui/terminal-screen.js

@@ -16,6 +16,15 @@ export class NativeTerminalScreen {
             this.terminal.write(chunk, resolve);
         });
     }
+    resize(cols, rows) {
+        this.terminal.resize(Math.max(1, Math.trunc(cols)), Math.max(1, Math.trunc(rows)));
+    }
+    dimensions() {
+        return {
+            cols: this.terminal.cols,
+            rows: this.terminal.rows
+        };
+    }
     snapshot() {
         return this.snapshotLines().join("\n");
     }
@@ -151,11 +160,14 @@ function sameStyle(left, right) {
 }
 function trimTrailingBlankTerminalLines(lines) {
     let end = lines.length;
-    while (end > 0 && terminalLineText(lines[end - 1]).trim() === "") {
+    while (end > 0 && isUnstyledBlankTerminalLine(lines[end - 1])) {
         end -= 1;
     }
     return lines.slice(0, end);
 }
+function isUnstyledBlankTerminalLine(line) {
+    return terminalLineText(line).trim() === "" && line.chunks.every((chunk) => Object.keys(chunk.style).length === 0);
+}
 function terminalLineText(line) {
     return line.chunks.map((chunk) => chunk.text).join("");
 }