parallel-codex-tui 0.3.1 → 0.4.0

package/README.md

@@ -6,7 +6,15 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.3.1` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.3.1) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.3.1). `Ctrl+E` opens runtime role/model control for Main, Judge, Actor, and Critic. The complete matrix can apply once to the next request, persist for retries and follow-ups in the current Task, or become the default for future requests. Saving now validates every selected Provider before it writes configuration, and concurrent TUI instances atomically consume a one-shot matrix exactly once.
+`v0.4.0` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.4.0) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.4.0). Main and parallel executions now run in a detached, per-request Supervisor after the Router resolves in the foreground. `Ctrl+C` closes the outer TUI without stopping an attached run, reopening the same workspace restores its live events or terminal result, and `Esc` remains the explicit cancellation command. One TUI owns the control lease while additional TUIs observe the same run; an observer takes control automatically after the prior controller detaches or exits.
+
+Supervisor requests, state, events, commands, controller ownership, acknowledgements, and diagnostic output are retained under `.parallel-codex/supervisor/runs/<run-id>/`. The Supervisor writes the final chat result itself, so completion survives a closed terminal without duplicate history when the TUI is reopened. Unexpected Supervisor exit is converted into a durable failed state instead of leaving an indefinitely running UI.
+
+In the Task session center, `Ctrl+F` searches durable evidence across Tasks and Turns, Feature names, roles, Providers, models, Worker states, summaries, and native session ids. Filters such as `turn:"中文输入" role:actor provider:codex state:done` can be combined with ordinary Unicode text; live async results reject stale responses, Enter keeps the filter, Esc restores the previously applied query, and `X` clears it.
+
+Every Task export now includes human-readable `report.md` and structured `report.json` beside the complete raw `session/` snapshot. Reports preserve each Turn request and route, Judge requirements/plans/acceptance criteria, supervisor summaries, Feature assignments and latest review evidence, Wave verification results, Worker Provider/model/state, active native session metadata, completion contracts, and final acceptance evidence. Integrated changed paths are compared with the current workspace as `match`, `drift`, `missing`, `unexpected`, or `unavailable`; the newest integrated wave for each path is authoritative, deleted paths are represented correctly, and unsafe or symlink-traversing paths are never read.
+
+`Ctrl+E` opens runtime role/model control for Main, Judge, Actor, and Critic. The complete matrix can apply once to the next request, persist for retries and follow-ups in the current Task, or become the default for future requests. Saving validates every selected Provider before it writes configuration, and concurrent TUI instances atomically consume a one-shot matrix exactly once.
 
 Feature assignment now controls both Provider and model. From a retryable Feature, press `M`, use `A`/`C` to cycle the Actor/Critic Provider, and use `1`/`2` to edit the Actor/Critic model. A model change starts a distinct Worker identity, keeps all earlier logs and native sessions, and remains an explicit Feature override when Task defaults change. Status details show separate `actual`, `next`, and `future` role matrices alongside the selected historical Worker's persisted model.
 
@@ -29,7 +37,7 @@ Highlights:
 - Named Worker Providers support Codex-compatible, Claude-compatible, OpenAI-compatible, Anthropic-compatible, and custom generic commands with independent role, model, environment, permission, resume, and interactive settings.
 - Worker overview, Feature board, collaboration timeline, Task and Main conversation centers, status details, rendered Markdown/Diff/error logs, Unicode search, keyboard navigation, mouse scrolling, and configurable themes share one terminal UI system.
 
-Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. A clean `v0.2.5` task also ran Codex Judge and Actor, a buffered Claude Critic that independently executed `node --test` and `npm test`, atomic integration, and a resumed Codex Judge that independently passed all seven acceptance criteria. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and Claude automated sessions executed safe Bash tools with `auto` permissions. The semantic Router completed a live classification, and one TUI completed Main calls in two workspaces before restoring the first workspace without leaking chat state. PTY coverage runs in Apple Terminal, tmux, and Zellij profiles at narrow and wide sizes, including status/log equivalence, preserving the native output tail across status-detail round trips, and proving both inline and on-demand file memory after native-session rollover. The deterministic repository suite contains 1,338 tests across 136 files: 1,337 pass by default, while one quota-consuming real-Agent test is skipped and passes through `npm run test:real-agents`.
+Release acceptance includes a real three-Feature Tetris task with parallel Actor/Critic waves and final integration review. A clean `v0.2.5` task also ran Codex Judge and Actor, a buffered Claude Critic that independently executed `node --test` and `npm test`, atomic integration, and a resumed Codex Judge that independently passed all seven acceptance criteria. Real Codex and Claude probes both proved fresh and same-session resume calls; Codex fresh and resume runs executed workspace writes with root-level `-a never`, and Claude automated sessions executed safe Bash tools with `auto` permissions. The semantic Router completed a live classification, and one TUI completed Main calls in two workspaces before restoring the first workspace without leaking chat state. PTY coverage runs in Apple Terminal, tmux, and Zellij profiles at narrow and wide sizes, including status/log equivalence, preserving the native output tail across status-detail round trips, and proving both inline and on-demand file memory after native-session rollover. Supervisor PTY coverage proves detached Main and complex execution, restart recovery, controller/observer takeover, explicit cancellation, and process-owner crash recovery. The deterministic repository suite contains 1,357 tests across 141 files: 1,356 pass by default, while one quota-consuming real-Agent test is skipped and passes through `npm run test:real-agents`.
 
 Real Provider probes depend on valid local CLI credentials. In particular, authenticate the Claude CLI before selecting a Claude-compatible Worker, then run `parallel-codex-tui --doctor --probe-agents` to prove fresh and resumed calls on that machine.
 
@@ -246,7 +254,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - `Ctrl+N` leaves the active complex Task and all Worker logs intact on disk, clears only the live selection and retry state, starts a new Main `conversation_id`, and retires the old Main native session. It works from ordinary chat too, so the next request cannot inherit an unrelated native or file-backed conversation; the next complex request creates an independent Task from turn `0001`.
 - Single-feature follow-ups reuse the same Actor/Critic native sessions when available while moving them to the new turn's isolated workspace. File-backed prompt memory keeps the root Turn and the latest 19 previous Turn summaries within a 12,000-character ceiling; longer histories retain an inline count and path to every immutable Turn summary on disk. A failed follow-up retry reuses a complete saved Judge plan, or restores Judge first when the earlier Judge run never produced one.
 - Automated Judge, Actor, Critic, Wave Actor, and Wave Critic runs enforce process-level isolation: Codex is clamped to root-level `-a never` plus `workspace-write`, and Claude is clamped to non-interactive `auto`, even when private command arguments request manual approval or contain a broader bypass mode. Native attach remains an explicit interactive path.
-- Pressing `Esc` while a request is running stops the router or active worker and records an interrupted complex task as `cancelled`; exiting the outer TUI also terminates the active run.
+- Routing remains in the foreground so fallback choices stay interactive. After a route resolves, Main or parallel execution moves into a detached per-run Supervisor. Pressing `Esc` as the controller cancels the active run and records an interrupted complex task as `cancelled`; pressing `Ctrl+C` detaches and exits the outer TUI while execution continues. Reopening the workspace follows persisted events and restores the final result. A second TUI observes the run and automatically acquires the control lease after the previous controller detaches or exits.
 - Failed and cancelled tasks expose `Ctrl+R` retry. Retry keeps the same task and turn, reuses recorded native worker sessions, preserves prior output behind a retry separator, does not route the request again, and reuses the persisted feature dependency plan. A complete Judge snapshot and fully integrated waves are skipped; an unchanged in-progress wave reuses successful Actor and Critic checkpoints and runs only unfinished workers. If the live workspace no longer matches the saved baseline, the stale wave checkpoint is rejected and rebuilt from the current project before workers continue.
 - The shared Main chat holds its own `sessions/main/run-owner.json` lease across prompt initialization, native-session reuse, and Worker completion. A second TUI is rejected before it can clear or overwrite the active Main prompt, log, status, or native session, and startup native-session reconciliation skips a Main session owned by another live TUI. After a hard exit, startup atomically claims the stale Main lease, terminates every verifiable orphan process group, marks active Main Workers `cancelled`, preserves native session ids, and records recovery before exposing the runtime. An unverifiable or still-running Main process blocks startup without changing its status or checkpoints.
 - Task and Main runs use the same lease finalizer, so a successful run cannot report success until its lease is released. If both the run and lease release fail, the top-level error preserves both causes in an `AggregateError` instead of replacing the original Worker failure.
@@ -473,7 +481,7 @@ Keep `[router.codex]` on `read-only`; routing only classifies requests and does
 
 The process adapter sends each role prompt to stdin and records stdout/stderr in `output.log`. Worker success is separate from the operating-system exit code: a total, first-output, idle, or stdin watchdog failure remains failed even when the terminated CLI handles `SIGTERM` and exits with code `0`, so the next role never starts from a timed-out checkpoint. `firstOutputTimeoutMs` owns silent startup, `idleTimeoutMs` starts only after real stdout/stderr activity, and `timeoutMs` remains the hard ceiling; equal or longer secondary watchdogs do not race the total deadline. Claude `--print` with `text` or `json` emits only its final result, so those launches display `working · buffered` and use `timeoutMs` without arming a separate first-output watchdog. Claude `stream-json` remains streaming and retains the configured first-output deadline.
 
-In chat, scroll long conversation history with the mouse wheel or PageUp/PageDown; sending a new message returns to the latest reply. A single Up/Down recalls persisted request history, and Ctrl+Up/Down remains an alternative. The outer TUI never enables application mouse tracking, so ordinary left-drag selection and system copy work without Shift while alternate-scroll keeps the wheel active in chat and Worker logs. `Ctrl+Y` also copies the current visible chat, rendered Worker log, native Agent screen, or structured overview without changing terminal modes. macOS uses `pbcopy`; Linux uses `wl-copy`, `xclip`, or `xsel` when available and falls back to OSC 52. After a complex task completes, use the same controls to move through its structured result and press `Ctrl+D` to toggle details. Press `Ctrl+N` to preserve all history and start a fresh conversation, `Ctrl+E` to open runtime role/model control, `Ctrl+W` to open Worker logs, and `Tab` to cycle the selected Worker when Workers exist. `Ctrl+S` opens the same status detail view from chat, logs, Worker overview, or an embedded native session; it keeps the footer compact while exposing the complete route, reason, active Main/Judge/Actor/Critic Provider/model map, selected historical Provider/model, phase, activity timestamp, native session, and config effective/restart state. Press `Ctrl+S` or `Esc` to return without interrupting the underlying Worker. While a request is running, press `Esc` to stop it. After a failed or cancelled Task, press `Ctrl+R` to retry the same turn or `Ctrl+N` to start independently. In Worker-log views, scroll with the mouse wheel, Up/Down, or PageUp/PageDown, press `Tab` to cycle Workers, `Ctrl+N` to start a fresh conversation, and `Esc` to return to chat.
+In chat, scroll long conversation history with the mouse wheel or PageUp/PageDown; sending a new message returns to the latest reply. A single Up/Down recalls persisted request history, and Ctrl+Up/Down remains an alternative. The outer TUI never enables application mouse tracking, so ordinary left-drag selection and system copy work without Shift while alternate-scroll keeps the wheel active in chat and Worker logs. `Ctrl+Y` also copies the current visible chat, rendered Worker log, native Agent screen, or structured overview without changing terminal modes. macOS uses `pbcopy`; Linux uses `wl-copy`, `xclip`, or `xsel` when available and falls back to OSC 52. After a complex task completes, use the same controls to move through its structured result and press `Ctrl+D` to toggle details. Press `Ctrl+N` to preserve all history and start a fresh conversation, `Ctrl+E` to open runtime role/model control, `Ctrl+W` to open Worker logs, and `Tab` to cycle the selected Worker when Workers exist. `Ctrl+S` opens the same status detail view from chat, logs, Worker overview, or an embedded native session; it keeps the footer compact while exposing the complete route, reason, active Main/Judge/Actor/Critic Provider/model map, selected historical Provider/model, phase, activity timestamp, native session, and config effective/restart state. Press `Ctrl+S` or `Esc` to return without interrupting the underlying Worker. While a request is running, press `Esc` to cancel it or `Ctrl+C` to close the TUI and leave the Supervisor running. After a failed or cancelled Task, press `Ctrl+R` to retry the same turn or `Ctrl+N` to start independently. In Worker-log views, scroll with the mouse wheel, Up/Down, or PageUp/PageDown, press `Tab` to cycle Workers, `Ctrl+N` to start a fresh conversation, and `Esc` to return to chat.
 
 `Ctrl+B` opens a live Worker overview without replacing the `Ctrl+W` log shortcut. It summarizes every Judge, Actor, and Critic by turn, role, named Provider, persisted model, state, phase, latest summary, and native-session availability. The selected active worker gets a live activity line showing its first-output deadline while starting and its idle deadline after output begins. The line stays muted while healthy, changes to warning for the final 20% and danger once overdue. Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` changes the selected worker; Enter or `Ctrl+W` opens its rendered log, `Ctrl+O` attaches to its native session, and `Esc` returns to the originating chat or log view. Router diagnostics and the project picker also return to the overview when opened from there.
 
@@ -483,7 +491,9 @@ For a failed, cancelled, or paused task, select an unfinished Feature and press
 
 From Worker overview, press `C` to open the file-backed Actor/Critic collaboration timeline. It merges `dialogue/actor-critic.jsonl`, feature status, Critic findings, Actor replies, finding resolution, and Wave events into one chronological view. The timeline follows new file evidence automatically and shows verified `fixed`/`open` counts when resolution evidence exists. Up/Down selects a collaboration event; `Enter` opens its complete event detail, including artifact paths from dialogue, status, Critic findings, Actor replies, and finding resolution; `U` filters to unresolved feature evidence; `Tab` cycles all features and each individual feature; `R` refreshes immediately; the mouse wheel or PageUp/PageDown scrolls history; and `Esc` returns to Worker overview.
 
-`Ctrl+T` opens the workspace's persisted Task sessions without exiting the outer TUI. The list shows status, creation time, turn and Worker counts, plus the number of distinct native sessions after deduplicating reused `engine + session_id` bindings; `>` marks the selected row and `*` marks the active Task. Use Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` to select, Enter to restore, `C` to open Main conversations, `I` to inspect the complete session hierarchy, `R` to rename with Unicode-safe cursor editing, `A` to archive or unarchive, `D` twice to confirm deletion, `E` to export, `H` to show or hide archived sessions, `Ctrl+N` to leave the active Task and start a fresh Main conversation, and `Esc` to return without losing the chat draft. Archived sessions are hidden by default, cannot be restored until unarchived, and are excluded from automatic startup selection. Archive, delete, and export require a terminal Task with no live task lease; the active Task cannot be archived or deleted. Exports are complete file-backed snapshots under `.parallel-codex/exports/<task>-<timestamp>/` with a versioned manifest and without transient lease files. Restoring a Task reloads its route, Workers, retry state, and recorded native session ids. The selected active Task is stored in `session-index.sqlite` and survives process and workspace switches; `Ctrl+N` persists an intentionally empty active-Task context instead of reopening an older Task on restart. SQLite schema changes run as ordered, transactional migrations. Existing catalogs receive a pre-migration snapshot, each successful startup/reindex refreshes a healthy backup, and an integrity failure restores that backup or rebuilds the catalog from authoritative Task files while preserving the corrupt copy for inspection. `meta.json` and the Worker files remain the rebuild authority.
+`Ctrl+T` opens the workspace's persisted Task sessions without exiting the outer TUI. The list shows status, creation time, turn and Worker counts, plus the number of distinct native sessions after deduplicating reused `engine + session_id` bindings; `>` marks the selected row and `*` marks the active Task. Use Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` to select, Enter to restore, `Ctrl+F` to search, `C` to open Main conversations, `I` to inspect the complete session hierarchy, `R` to rename with Unicode-safe cursor editing, `A` to archive or unarchive, `D` twice to confirm deletion, `E` to export, `H` to show or hide archived sessions, `Ctrl+N` to leave the active Task and start a fresh Main conversation, and `Esc` to return without losing the chat draft. Search accepts plain Unicode text plus `task:`, `turn:`, `feature:`, `role:`, `provider:`, `model:`, and `state:` filters; quote a value containing spaces. Search is an AND across terms and reads the rebuildable SQLite evidence index rather than scanning lifetime Worker logs. Archived sessions are hidden by default, cannot be restored until unarchived, and are excluded from automatic startup selection.
+
+Archive, delete, and export require a terminal Task with no live task lease; the active Task cannot be archived or deleted. Exports are complete file-backed snapshots under `.parallel-codex/exports/<task>-<timestamp>/` with a versioned manifest, `report.md`, `report.json`, the raw `session/`, and no transient lease files. The report compares every authoritative integrated path with the current workspace while blocking relative-path escape and parent-symlink traversal. Restoring a Task reloads its route, Workers, retry state, and recorded native session ids. The selected active Task is stored in `session-index.sqlite` and survives process and workspace switches; `Ctrl+N` persists an intentionally empty active-Task context instead of reopening an older Task on restart. SQLite schema changes run as ordered, transactional migrations. The current index stores bounded Turn request text and each Worker's Feature, role, Provider, model, state, and native session binding for structured search. Existing catalogs receive a pre-migration snapshot, each successful startup/reindex refreshes a healthy backup, and an integrity failure restores that backup or rebuilds the catalog from authoritative Task files while preserving the corrupt copy for inspection. `meta.json`, Turn files, and Worker files remain the rebuild authority.
 
 The Main conversation list shows each scoped title, message count, distinct native session count, last activity, current `*` marker, and selected `>` marker. Use the same Up/Down, PageUp/PageDown, mouse-wheel, or `Tab` navigation; Enter restores the selected conversation, `R` renames it with Unicode-safe cursor editing, `A` archives or unarchives it, `D` twice confirms deletion, `E` exports it, `H` shows or hides archived conversations, `N` starts a new one, `T` returns to Tasks, and `Esc` returns to chat. Archived conversations are hidden by default and cannot be restored until unarchived; the current Main conversation cannot be archived or deleted. A Main export is a versioned, conversation-scoped snapshot under `.parallel-codex/exports/<conversation>-<timestamp>/` containing only that conversation's chat rows and matching native sessions. Confirmed deletion streams the shared chat JSONL into an atomic replacement, preserves Task chat and malformed evidence, and restores the original chat and conversation archive if publication fails. Restoration preserves every Task and Worker log, switches `conversation.json`, and rebuilds Main history from records carrying only the selected `conversation_id` (or the pre-boundary legacy scope). Before switching, active Main native sessions are archived and retired; archived bindings for the selected conversation are then restored for best-effort native resume. A brand-new empty legacy scope is not added to the catalog.
 
@@ -491,7 +501,7 @@ The Task detail view reads authoritative task files and presents `Project -> Tas
 
 In a Worker log, `Ctrl+F` searches the final rendered Worker log rather than raw file offsets. Type Unicode text normally; Enter moves to the next match and Up/Down moves backward or forward. `Esc` closes search. The current match is marked with `>` without shifting Diff or source line-number columns. With search closed, press `E` to cycle rendered error lines or `D` to cycle Diff files and hunks.
 
-In chat or worker-log views, press `Ctrl+O` to attach to the selected worker's native session inside `parallel-codex-tui`. Native attach runs through a PTY, so full-screen CLIs such as `codex resume {sessionId}` receive a real terminal instead of pipe stdin. Native attach follows outer terminal resize, updating both the rendered screen and child PTY so Codex or Claude reflows at the current dimensions. Input is forwarded to the configured interactive command and output is shown in the native attach panel. When a Codex feature session needs its recorded worker, turn, or feature directories and the interactive command does not already choose a sandbox, native attach adds `--sandbox workspace-write` before its `--add-dir` arguments; an explicitly configured native sandbox remains unchanged. A non-zero native exit recognizes read-only sandbox/add-dir conflicts, untrusted directories, misplaced `--skip-git-repo-check`, missing PTY input, and host permission failures, then appends the exact configuration or terminal action before the exit line scrolls away. Overlapping attach preparations keep only the latest request. Press `Ctrl+]` to return to worker logs; this and closing the outer App terminate the active PTY. An attach preparation that finishes after App shutdown is discarded instead of starting a detached agent. `Ctrl+C` is forwarded to the native agent while attached. In chat and worker-log views, press `Ctrl+C` to exit the outer TUI. An operating-system SIGINT first asks the App to abort its Router or Worker and clean up any PTY; a second SIGINT restores terminal modes and forces exit.
+In chat or worker-log views, press `Ctrl+O` to attach to the selected worker's native session inside `parallel-codex-tui`. Native attach runs through a PTY, so full-screen CLIs such as `codex resume {sessionId}` receive a real terminal instead of pipe stdin. Native attach follows outer terminal resize, updating both the rendered screen and child PTY so Codex or Claude reflows at the current dimensions. Input is forwarded to the configured interactive command and output is shown in the native attach panel. When a Codex feature session needs its recorded worker, turn, or feature directories and the interactive command does not already choose a sandbox, native attach adds `--sandbox workspace-write` before its `--add-dir` arguments; an explicitly configured native sandbox remains unchanged. A non-zero native exit recognizes read-only sandbox/add-dir conflicts, untrusted directories, misplaced `--skip-git-repo-check`, missing PTY input, and host permission failures, then appends the exact configuration or terminal action before the exit line scrolls away. Overlapping attach preparations keep only the latest request. Press `Ctrl+]` to return to worker logs; this and closing the outer App terminate the active PTY. An attach preparation that finishes after App shutdown is discarded instead of starting a detached agent. `Ctrl+C` is forwarded to the native agent while attached. In chat and worker-log views, `Ctrl+C` detaches an active Supervisor run and exits the outer TUI; during foreground routing it cancels classification before exiting. A second operating-system SIGINT restores terminal modes and forces exit.
 
 If a native resume fails because the underlying CLI reports that its context window is full, configure `fallback = "new"` under `[workers.<engine>.nativeSession]`. The old native session is archived as `native-session.retired.json`, removed from active use, and the worker is retried once with the normal fresh-session command. A valid retirement tombstone is also a cross-turn inheritance barrier: a retry or later turn cannot resurrect the same session from an older worker copy, while a newer replacement session remains reusable. A `process-cleanup-error` or `process-ownership-error` always blocks native-session fallback, even when the CLI output also mentions a full context window, so a fresh Worker cannot overlap an untracked or still-running resume process.
 
@@ -539,12 +549,12 @@ The release job installs npm `^11.5.1`, runs on Node `24.15.x`, publishes the pr
 To publish a release, update `package.json` and `src/version.ts` to the same version, then push a matching tag:
 
 ```bash
-VERSION=0.3.1
+VERSION=0.4.0
 git tag "v$VERSION"
 git push origin "v$VERSION"
 ```
 
-You can also run the Release workflow manually and enter the same tag value. The release tag must match `package.json`; for example, package version `0.3.1` requires tag `v0.3.1`. Published tags such as `v0.2.10` are immutable and must not be moved or reused.
+You can also run the Release workflow manually and enter the same tag value. The release tag must match `package.json`; for example, package version `0.4.0` requires tag `v0.4.0`. Published tags such as `v0.2.10` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 
@@ -552,6 +562,7 @@ You can also run the Release workflow manually and enter the same tag value. The
 - `.parallel-codex/role-configuration.json` and `.parallel-codex/role-configuration.next.json` are local runtime role/model selections and are ignored.
 - `.parallel-codex/last-workspace` and `.parallel-codex/workspaces.json` are local workspace-selection state and are ignored.
 - `.parallel-codex/router/` contains local request classification audit records and is ignored.
+- `.parallel-codex/supervisor/` contains detached-run requests, lifecycle state, control commands, event streams, controller leases, acknowledgements, and Supervisor diagnostics; it is local evidence and is ignored.
 - `.parallel-codex/sessions/` contains the workspace chat transcript, task prompts, logs, native session ids, isolated feature workspaces, and conflict evidence; never commit it.
 - `.parallel-codex/diagnostics/` contains redacted support bundles and is ignored; review a bundle before sharing it.
 - `.parallel-codex/probes/` contains failed live Agent probe evidence and is ignored.

package/dist/cli.js

@@ -27,6 +27,8 @@ import { formatTuiThemeCatalog } from "./tui/theme-preview.js";
 import { configureTuiTheme } from "./tui/theme.js";
 import { routerDiagnosticsPolicy } from "./tui/RouterDiagnosticsView.js";
 import { version } from "./version.js";
+import { SupervisorOrchestrator } from "./supervisor/client.js";
+import { runSupervisorJob } from "./supervisor/runner.js";
 main().catch((error) => {
     if (error instanceof WorkspaceSelectionCancelledError) {
         return;
@@ -35,6 +37,12 @@ main().catch((error) => {
     process.exit(1);
 });
 async function main() {
+    const supervisorRunDir = process.env.PCT_SUPERVISOR_RUN_DIR;
+    if (supervisorRunDir) {
+        delete process.env.PCT_SUPERVISOR_RUN_DIR;
+        await runSupervisorJob(supervisorRunDir);
+        return;
+    }
     const rawArgs = process.argv.slice(2);
     const cliArgErrors = validateCliArgs(rawArgs);
     if (cliArgErrors.length > 0) {
@@ -119,7 +127,7 @@ async function main() {
         let instance = null;
         const shutdownController = new AbortController();
         const deferredWorkspaceClosures = new Set();
-        const appElement = (state) => (_jsx(App, { config: withUiThemeOverride(state.runtime.config, cliArgs.theme), orchestrator: state.runtime.orchestrator, cwd: state.runtime.workspaceRoot, initialTaskId: state.initialTaskId, initialRoute: state.initialRoute, initialWorkers: state.initialWorkers, initialCanRetryTask: state.initialCanRetryTask, initialMessages: state.initialMessages, workspaceChoices: state.workspaceChoices, shutdownSignal: shutdownController.signal, loadRouterDiagnostics: async () => {
+        const appElement = (state) => (_jsx(App, { config: withUiThemeOverride(state.runtime.config, cliArgs.theme), orchestrator: state.supervisor, cwd: state.runtime.workspaceRoot, initialTaskId: state.initialTaskId, initialRoute: state.initialRoute, initialWorkers: state.initialWorkers, initialCanRetryTask: state.initialCanRetryTask, initialMessages: state.initialMessages, workspaceChoices: state.workspaceChoices, shutdownSignal: shutdownController.signal, loadRouterDiagnostics: async () => {
                 const [records, latestConfig] = await Promise.all([
                     readRouterAudit(join(state.runtime.routerCwd, "routes.jsonl"), 100),
                     loadConfig(cliArgs.appRoot)
@@ -128,7 +136,9 @@ async function main() {
                     records,
                     policy: routerDiagnosticsPolicy(latestConfig.router)
                 };
-            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), loadMainConversations: (options) => state.runtime.sessions.listMainConversations(100, options), activateMainConversation: async (conversationId) => {
+            }, loadTaskSessions: (options) => options?.query?.trim()
+                ? state.runtime.index.searchTasks(options.query, 100, options)
+                : state.runtime.index.listTasks(100, options), loadMainConversations: (options) => state.runtime.sessions.listMainConversations(100, options), activateMainConversation: async (conversationId) => {
                 const restored = await state.runtime.sessions.activateMainConversation(conversationId);
                 await state.runtime.index.setActiveTaskId(null);
                 return restored;
@@ -210,6 +220,7 @@ async function main() {
         finally {
             removeSigintHandler();
             restoreInteractiveTerminal();
+            closeInteractiveWorkspace(current);
             retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
         }
     }
@@ -217,6 +228,13 @@ async function main() {
 async function loadInteractiveWorkspace(appRoot, workspaceRoot, requestedTaskId) {
     const runtime = await createRuntime(appRoot, workspaceRoot);
     try {
+        const supervisor = await SupervisorOrchestrator.open({
+            delegate: runtime.orchestrator,
+            sessions: runtime.sessions,
+            appRoot,
+            workspaceRoot: runtime.workspaceRoot,
+            dataDir: runtime.config.dataDir
+        });
         const preflightPromise = runRuntimePreflight(runtime.config, runtime.workspaceRoot, process.env).catch((error) => ({
             ok: false,
             lines: [`preflight: failed (${error instanceof Error ? error.message : String(error)})`]
@@ -269,6 +287,7 @@ async function loadInteractiveWorkspace(appRoot, workspaceRoot, requestedTaskId)
         const recoveryMessages = startupRecoveryMessages(runtime.recoveredTasks, initialTaskId, runtime.pendingTaskCreations, runtime.index.recovery);
         return {
             runtime,
+            supervisor,
             initialTaskId,
             initialRoute,
             initialWorkers,
@@ -291,6 +310,7 @@ async function loadInteractiveWorkspace(appRoot, workspaceRoot, requestedTaskId)
     }
 }
 function closeInteractiveWorkspace(state) {
+    state.supervisor.detachBackgroundRuns();
     state.runtime.index.close();
 }
 function retryDeferredWorkspaceClosures(states) {

package/dist/core/session-index.js

@@ -3,7 +3,8 @@ import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { NativeSessionSchema, RetiredNativeSessionSchema, RouteDecisionSchema, TaskIdSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
 import { ensureDir, pathExists, readJson, readTextIfExists } from "./file-store.js";
-const SESSION_INDEX_SCHEMA_VERSION = 2;
+import { matchTaskSearchDocument, parseTaskSearchQuery } from "./task-search.js";
+const SESSION_INDEX_SCHEMA_VERSION = 3;
 const SESSION_INDEX_FILENAME = "session-index.sqlite";
 export class SessionIndex {
     db;
@@ -86,24 +87,33 @@ export class SessionIndex {
            archived_at=excluded.archived_at`)
             .run(task.id, task.title, task.created_at, task.cwd, task.mode, task.status, task.archived_at ?? null);
     }
-    async upsertTurn(taskId, turn) {
+    async upsertTurn(taskId, turn, request = "") {
         this.db
-            .prepare(`INSERT INTO turns (task_id, turn_id, created_at, request_path)
-         VALUES (?, ?, ?, ?)
+            .prepare(`INSERT INTO turns (task_id, turn_id, created_at, request_path, request_text)
+         VALUES (?, ?, ?, ?, ?)
          ON CONFLICT(task_id, turn_id) DO UPDATE SET
            created_at=excluded.created_at,
-           request_path=excluded.request_path`)
-            .run(taskId, turn.turn_id, turn.created_at, turn.request_path);
+           request_path=excluded.request_path,
+           request_text=CASE
+             WHEN excluded.request_text <> '' THEN excluded.request_text
+             ELSE turns.request_text
+           END`)
+            .run(taskId, turn.turn_id, turn.created_at, turn.request_path, indexedRequestText(request));
     }
     async upsertWorker(taskId, status, paths) {
         this.db
             .prepare(`INSERT INTO workers (
-          task_id, worker_id, role, engine, state, phase, summary, status_path, output_log_path, dir, native_session_id
+          task_id, worker_id, feature_id, feature_title, role, engine, model_name, model_provider,
+          state, phase, summary, status_path, output_log_path, dir, native_session_id
         )
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(task_id, worker_id) DO UPDATE SET
+           feature_id=excluded.feature_id,
+           feature_title=excluded.feature_title,
            role=excluded.role,
            engine=excluded.engine,
+           model_name=excluded.model_name,
+           model_provider=excluded.model_provider,
            state=excluded.state,
            phase=excluded.phase,
            summary=excluded.summary,
@@ -111,7 +121,7 @@ export class SessionIndex {
            output_log_path=excluded.output_log_path,
            dir=excluded.dir,
            native_session_id=excluded.native_session_id`)
-            .run(taskId, status.worker_id, status.role, status.engine, status.state, status.phase, status.summary, paths.statusPath, paths.outputLogPath, paths.dir, status.native_session_id ?? null);
+            .run(taskId, status.worker_id, status.feature_id ?? null, status.feature_title ?? null, status.role, status.engine, status.model_name ?? null, status.model_provider ?? null, status.state, status.phase, status.summary, paths.statusPath, paths.outputLogPath, paths.dir, status.native_session_id ?? null);
     }
     async upsertNativeSession(taskId, record) {
         this.db
@@ -198,6 +208,89 @@ export class SessionIndex {
                 }];
         });
     }
+    async searchTasks(query, limit = 100, options = {}) {
+        const boundedLimit = Number.isFinite(limit)
+            ? Math.min(500, Math.max(0, Math.trunc(limit)))
+            : 100;
+        if (boundedLimit === 0) {
+            return [];
+        }
+        const terms = parseTaskSearchQuery(query);
+        const tasks = await this.listTasks(500, options);
+        if (terms.length === 0) {
+            return tasks.slice(0, boundedLimit).map((task) => ({
+                ...task,
+                searchMatch: { fields: [], summary: "" }
+            }));
+        }
+        const documents = new Map(tasks.map((task) => [task.id, {
+                task: {
+                    id: task.id,
+                    title: task.title,
+                    cwd: task.cwd,
+                    mode: task.mode,
+                    state: task.status
+                },
+                turns: [],
+                workers: [],
+                nativeSessions: []
+            }]));
+        const archivedFilter = options.includeArchived ? "" : "WHERE tasks.archived_at IS NULL";
+        const turns = this.db.prepare(`SELECT turns.task_id, turns.turn_id, turns.request_text
+       FROM turns
+       INNER JOIN tasks ON tasks.id = turns.task_id
+       ${archivedFilter}`).all();
+        for (const turn of turns) {
+            documents.get(turn.task_id)?.turns.push({
+                turnId: turn.turn_id,
+                request: turn.request_text
+            });
+        }
+        const workers = this.db.prepare(`SELECT
+         workers.task_id,
+         workers.worker_id,
+         workers.feature_id,
+         workers.feature_title,
+         workers.role,
+         workers.engine,
+         workers.model_name,
+         workers.model_provider,
+         workers.state,
+         workers.phase,
+         workers.summary
+       FROM workers
+       INNER JOIN tasks ON tasks.id = workers.task_id
+       ${archivedFilter}`).all();
+        for (const worker of workers) {
+            documents.get(worker.task_id)?.workers.push({
+                id: worker.worker_id,
+                featureId: worker.feature_id ?? "",
+                featureTitle: worker.feature_title ?? "",
+                role: worker.role,
+                provider: worker.engine,
+                model: worker.model_name ?? "",
+                modelProvider: worker.model_provider ?? "",
+                state: worker.state,
+                phase: worker.phase,
+                summary: worker.summary
+            });
+        }
+        const nativeSessions = this.db.prepare(`SELECT native_sessions.task_id, native_sessions.session_id, native_sessions.engine
+       FROM native_sessions
+       INNER JOIN tasks ON tasks.id = native_sessions.task_id
+       ${archivedFilter}`).all();
+        for (const session of nativeSessions) {
+            documents.get(session.task_id)?.nativeSessions.push({
+                sessionId: session.session_id,
+                provider: session.engine
+            });
+        }
+        return tasks.flatMap((task) => {
+            const document = documents.get(task.id);
+            const searchMatch = document ? matchTaskSearchDocument(terms, document) : null;
+            return searchMatch ? [{ ...task, searchMatch }] : [];
+        }).slice(0, boundedLimit);
+    }
     async activeTaskId() {
         const row = this.db
             .prepare("SELECT value FROM workspace_state WHERE key = 'active_task_id'")
@@ -293,14 +386,19 @@ export class SessionIndex {
           turn_id TEXT NOT NULL,
           created_at TEXT NOT NULL,
           request_path TEXT NOT NULL,
+          request_text TEXT NOT NULL DEFAULT '',
           PRIMARY KEY (task_id, turn_id)
         );
 
         CREATE TABLE IF NOT EXISTS workers (
           task_id TEXT NOT NULL,
           worker_id TEXT NOT NULL,
+          feature_id TEXT,
+          feature_title TEXT,
           role TEXT NOT NULL,
           engine TEXT NOT NULL,
+          model_name TEXT,
+          model_provider TEXT,
           state TEXT NOT NULL,
           phase TEXT NOT NULL,
           summary TEXT NOT NULL,
@@ -335,6 +433,14 @@ export class SessionIndex {
             this.ensureColumn("tasks", "archived_at", "TEXT");
             return;
         }
+        if (targetVersion === 3) {
+            this.ensureColumn("turns", "request_text", "TEXT NOT NULL DEFAULT ''");
+            this.ensureColumn("workers", "feature_id", "TEXT");
+            this.ensureColumn("workers", "feature_title", "TEXT");
+            this.ensureColumn("workers", "model_name", "TEXT");
+            this.ensureColumn("workers", "model_provider", "TEXT");
+            return;
+        }
         throw new Error(`Missing session index migration for schema v${targetVersion}`);
     }
     async writeBackup(targetPath) {
@@ -380,7 +486,7 @@ export class SessionIndex {
                     && turn.task_id === taskId
                     && turn.turn_id === turnEntry.name
                     && turn.request_path === `turns/${turnEntry.name}/user.md`) {
-                    await this.upsertTurn(taskId, turn);
+                    await this.upsertTurn(taskId, turn, request);
                 }
             }
         }
@@ -535,6 +641,13 @@ async function replaceFile(source, target) {
         await rename(source, target);
     }
 }
+function indexedRequestText(request) {
+    const clean = request
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+        .trim();
+    const points = Array.from(clean);
+    return points.length > 32768 ? points.slice(0, 32768).join("") : clean;
+}
 async function readJsonIfValid(path, schema) {
     if (!(await pathExists(path))) {
         return null;

package/dist/core/session-manager.js

@@ -11,6 +11,7 @@ import { formatTaskTimestamp, taskDir, taskSessionIdIsValid } from "./paths.js";
 import { sessionsRoot } from "./paths.js";
 import { loadCollaborationTimeline } from "./collaboration-timeline.js";
 import { taskStateTransitionAllowed } from "./task-state-machine.js";
+import { buildTaskReport } from "./task-report.js";
 import { processIsAlive, readProcessStartToken } from "./process-identity.js";
 import { claimTaskRunLease, inspectTaskRunLease, TaskRunLeaseConflictError, terminateOwnedWorkerProcess } from "./process-ownership.js";
 import { ChatRecordSchema, ConversationIdSchema, MainConversationArchiveSchema, MainConversationStateSchema, EventRecordSchema, FeatureStatusSchema, NativeSessionSchema, RouteDecisionSchema, RetiredNativeSessionSchema, TaskMetaSchema, TaskIdSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
@@ -113,7 +114,7 @@ export class SessionManager {
             await rename(stagingDir, finalDir);
             published = true;
             await this.updateTaskStatus(task, "routed");
-            await this.index?.upsertTurn(task.id, await readJson(join(task.dir, "turns", turn.turnId, "turn.json"), TurnMetaSchema));
+            await this.index?.upsertTurn(task.id, await readJson(join(task.dir, "turns", turn.turnId, "turn.json"), TurnMetaSchema), input.request);
             await this.index?.setActiveTaskId(id);
             if (!options.retainCreationClaim) {
                 await removeIfExists(creation.claimPath);
@@ -633,11 +634,21 @@ export class SessionManager {
             const destination = join(exportsRoot, `${taskId}-${stamp}-${suffix}`);
             try {
                 await this.appendEvent(task, "task.exported", "Task session exported");
+                const taskReport = await buildTaskReport({
+                    task: meta,
+                    taskDir: task.dir,
+                    workspaceRoot: this.projectRoot,
+                    generatedAt: createdAt
+                });
+                await writeJson(join(staging, "report.json"), taskReport.report);
+                await writeText(join(staging, "report.md"), taskReport.markdown);
                 await writeJson(join(staging, "manifest.json"), {
                     format: "parallel-codex-task-export-v1",
                     exported_at: createdAt,
                     source_workspace: this.projectRoot,
                     session_path: "session",
+                    report_path: "report.md",
+                    report_json_path: "report.json",
                     task: await this.readMeta(task)
                 });
                 await cp(task.dir, join(staging, "session"), {
@@ -1583,7 +1594,7 @@ export class SessionManager {
         await this.index.upsertTask(meta);
         const snapshot = await this.readCompleteTaskCreation(this.taskFromId(taskId).dir, taskId);
         if (snapshot) {
-            await this.index.upsertTurn(taskId, snapshot.turn);
+            await this.index.upsertTurn(taskId, snapshot.turn, await readTextIfExists(join(this.taskFromId(taskId).dir, snapshot.turn.request_path)));
         }
     }
     async quarantinePendingTaskCreation(pending) {
@@ -1637,7 +1648,7 @@ export class SessionManager {
                 && pendingMeta.request_path === `turns/${pending.turnId}/user.md`);
             if (request && pendingRoute && pendingMeta && metaMatches) {
                 await rename(pending.dir, files.dir);
-                await this.index?.upsertTurn(task.id, pendingMeta);
+                await this.index?.upsertTurn(task.id, pendingMeta, request);
                 await this.appendEvent(task, "turn.recovered_after_restart", `Published complete pending turn ${pending.turnId} after restart`);
                 summary.published += 1;
                 continue;
@@ -1716,7 +1727,7 @@ export class SessionManager {
             }
         }
         if (projectIndex) {
-            await this.index?.upsertTurn(task.id, turnMeta);
+            await this.index?.upsertTurn(task.id, turnMeta, request);
         }
         return files;
     }