parallel-codex-tui 0.3.0 → 0.3.2

package/README.md

@@ -6,7 +6,13 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.3.0` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.3.0) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.3.0). `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. Provider changes reset to that profile's configured model, `M` accepts a model override, every complex Turn records the exact consumed matrix, and historical Worker/native-session identity remains unchanged.
+`v0.3.2` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.3.2) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.3.2). In the Task session center, `Ctrl+F` now 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.
 
 `Ctrl+T`, then `C`, opens every persisted Main conversation and provides the same durable management lifecycle as Task sessions: rename, archive, unarchive, scoped export, and confirmed deletion. Restoring one switches the exact `conversation_id`, reloads only that conversation's file-backed history, and restores its archived native Codex or Claude session ids when they are available. `Ctrl+N` creates an explicit, durable Main conversation boundary without deleting chat, Tasks, or Worker logs.
 
@@ -14,7 +20,7 @@ A real Claude acceptance retires the first native session, inserts 16 newer reco
 
 Complex task memory now retains the root Turn plus the latest 19 previous Turn summaries within a 12,000-character budget. When a longer task omits intermediate summaries inline, the prompt points the Worker to the complete immutable Turn history on disk. Main chat still extracts only the final Codex answer while retaining the complete CLI transcript in `output.log`; legacy transcript-shaped chat records are cleaned when displayed without rewriting their file-backed evidence. Workspace integration ignores known host metadata such as `.DS_Store` and AppleDouble files while continuing to reject real concurrent project edits.
 
-The default role map is Main/Judge/Actor on Codex and Critic on Claude. Status details show the complete active role map separately from each historical Worker's persisted Provider/model. Config monitoring labels Router-only edits as active on the next request and marks role, Worker, model, permission, or UI changes as requiring restart. Claude text/JSON print runs are recognized as buffered work, use the total deadline instead of a false first-output deadline, and run safe isolated tools through non-interactive `auto` permissions. The `v0.2.4` non-interactive Codex permission placement remains included. The release keeps terminal scrolling and copying available at the same time without requiring Shift and preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
+The default role map is Main/Judge/Actor on Codex and Critic on Claude. Status details show the actual, next, and future role maps separately from each historical Worker's persisted Provider/model. Config monitoring labels Router-only edits as active on the next request and marks role, Worker, model, permission, or UI changes as requiring restart. Claude text/JSON print runs are recognized as buffered work, use the total deadline instead of a false first-output deadline, and run safe isolated tools through non-interactive `auto` permissions. The `v0.2.4` non-interactive Codex permission placement remains included. The release keeps terminal scrolling and copying available at the same time without requiring Shift and preserves the embedded native Agent scrollback across status-detail round trips and real PTY resizes.
 
 Highlights:
 
@@ -27,7 +33,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,334 tests across 136 files: 1,333 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. The deterministic repository suite contains 1,349 tests across 138 files: 1,348 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.
 
@@ -420,15 +426,15 @@ critic = "anthropic_compat"
 
 ## Runtime Role Control
 
-While the TUI is idle, press `Ctrl+E` to configure Main, Judge, Actor, and Critic without editing TOML or restarting. Up/Down selects a role, Left/Right (or `[`/`]`) cycles its configured Worker Provider, `M` edits the model name with a Unicode-safe cursor, and `Tab` changes the persistence scope. Press Enter to apply the complete matrix, `X` to clear the saved override and inherit its parent scope, `R` to discard unsaved edits, and `Esc` or `Ctrl+E` to return. `Ctrl+Y` copies the visible matrix. A Provider switch resets that role to the Provider's configured default model; a blank model edit also means the Provider default.
+While the TUI is idle, press `Ctrl+E` to configure Main, Judge, Actor, and Critic without editing TOML or restarting. Up/Down selects a role, Left/Right (or `[`/`]`) cycles its configured Worker Provider, `M` edits the model name with a Unicode-safe cursor, and `Tab` changes the persistence scope. Press Enter to validate every selected CLI, environment, capability contract, and proxy before saving the complete matrix. `X` clears the saved override and inherits its parent scope, `R` discards unsaved edits, and `Esc` or `Ctrl+E` returns. `Ctrl+Y` copies the visible matrix. A Provider switch resets that role to the Provider's configured default model; a blank model edit also means the Provider default.
 
 The three scopes are explicit:
 
-- `next request` is stored in the current workspace at `.parallel-codex/role-configuration.next.json`, overrides every role once, and is removed only when a routed request consumes it.
-- `current task` is stored beside that Task's `meta.json`, applies to retries and same-Task follow-ups, and updates unfinished Feature assignments without deleting earlier Workers or logs.
+- `next request` is stored in the current workspace at `.parallel-codex/role-configuration.next.json`, overrides every role once, and is removed only when one routed request atomically claims it. Concurrent TUI instances cannot both consume it.
+- `current task` is stored beside that Task's `meta.json`, applies to retries and same-Task follow-ups, and updates inherited unfinished Feature assignments without deleting earlier Workers or logs. Explicit Feature overrides remain unchanged.
 - `future requests` is stored in the app root at `.parallel-codex/role-configuration.json` and becomes the default for new Main calls and Tasks across restarts.
 
-Every complex Turn writes the exact consumed matrix to `turns/<turn>/role-configuration.json`. Retries use that evidence instead of silently adopting a pending one-shot selection, native attach uses the selected Worker's persisted Provider/model, and status details show the active Turn matrix separately from historical Worker identity.
+Every complex Turn writes the exact consumed matrix to `turns/<turn>/role-configuration.json`. Retries use that evidence instead of silently adopting a pending one-shot selection, native attach uses the selected Worker's persisted Provider/model, and status details show the actual Turn, next-request, and future-default matrices separately from historical Worker identity.
 
 For a third-party command with its own syntax, inherit `generic` so parallel-codex-tui does not inject `--sandbox`, `--permission-mode`, or other built-in-only flags:
 
@@ -477,11 +483,13 @@ In chat, scroll long conversation history with the mouse wheel or PageUp/PageDow
 
 From Worker overview, press `F` to open the file-backed Feature board. It summarizes every planned feature by turn, state, blocked dependencies and open Critic findings while preserving descriptions and Actor replies from the same collaboration files. Use Up/Down, PageUp/PageDown, the mouse wheel, or `Tab` to select a feature; Enter opens the selected feature's collaboration timeline; `R` refreshes immediately; and `Esc` returns to Worker overview. When a timeline was opened from this board, `Esc` returns to the Feature board instead of skipping back to Workers. While the selected feature is running, press `P` twice to pause only its active Actor or Critic process, or press `X` twice to cancel it; the first press opens a confirmation and `Esc` keeps it running. A paused feature preserves completed peers and same-wave checkpoints; select it and press `Ctrl+R` to resume the same task, turn, and native Worker session. After cancellation, already-running peers finish, queued workers stop, and integration remains blocked, so a partial wave never reaches the live workspace. Once the task settles as cancelled, `Ctrl+R` retries the cancelled task with persisted worker sessions; completed peers are loaded from their same-wave checkpoints instead of running again. Checkpoint load, reuse, and recovery events appear in the collaboration timeline.
 
-For a failed, cancelled, or paused task, select an unfinished Feature and press `M` to edit its Provider assignment. `A` cycles that Feature's Actor through every `assignable` Worker Provider, `C` cycles its Critic, and `M` or `Esc` closes the assignment prompt. The choice is persisted in `features/<turn>-<feature>/assignment.json`, appears on the Feature board and collaboration artifacts, and takes effect on the next `Ctrl+R` retry. A changed role starts a new Provider-specific Worker while every previous Worker log and native-session record remains available. Assignment writes hold the same task lease as execution, so another live TUI cannot change a Feature while it is resuming.
+For a failed, cancelled, or paused task, select an unfinished Feature and press `M` to edit its assignment. `A` cycles that Feature's Actor through every `assignable` Worker Provider, `C` cycles its Critic, `1` edits the Actor model, `2` edits the Critic model, and `M` or `Esc` closes the prompt. The choice is persisted in `features/<turn>-<feature>/assignment.json`, appears on the Feature board and collaboration artifacts, and takes effect on the next `Ctrl+R` retry. A changed Provider or model starts a distinct Worker while every previous Worker log and native-session record remains available. Feature overrides survive later Task-default changes. Assignment writes hold the same task lease as execution, so another live TUI cannot change a Feature while it is resuming.
 
 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.
 
@@ -537,12 +545,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.0
+VERSION=0.3.2
 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.0` requires tag `v0.3.0`. 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.3.2` requires tag `v0.3.2`. Published tags such as `v0.2.10` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -128,7 +128,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;

package/dist/core/collaboration-timeline.js

@@ -133,7 +133,9 @@ async function readCollaborationFeatures(taskDir) {
             updatedAt: status.updated_at,
             ...(assignment ? {
                 actorEngine: assignment.actor_engine,
-                criticEngine: assignment.critic_engine
+                criticEngine: assignment.critic_engine,
+                actorModel: assignment.actor_model,
+                criticModel: assignment.critic_model
             } : {}),
             findings: findingEvidence.count,
             replies: replyEvidence.count,

package/dist/core/role-configuration.js

@@ -2,11 +2,12 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { pathExists, readJson, removeIfExists, writeJson } from "./file-store.js";
-import { EngineNameSchema } from "../domain/schemas.js";
+import { claimTaskRunLease, TaskRunLeaseConflictError } from "./process-ownership.js";
+import { EngineNameSchema, WorkerModelNameSchema } from "../domain/schemas.js";
 export const CONFIGURABLE_ROLES = ["main", "judge", "actor", "critic"];
 const RoleExecutionTargetSchema = z.object({
     engine: EngineNameSchema,
-    model: z.string().max(200)
+    model: WorkerModelNameSchema
 }).strict();
 const RoleExecutionSelectionSchema = z.object({
     main: RoleExecutionTargetSchema,
@@ -67,7 +68,7 @@ export class RoleConfigurationManager {
             return;
         }
         if (scope === "next") {
-            await writeRoleConfiguration(this.nextPath(), parsed);
+            await this.withNextConfigurationLease(() => writeRoleConfiguration(this.nextPath(), parsed));
             return;
         }
         if (!taskDir) {
@@ -83,7 +84,7 @@ export class RoleConfigurationManager {
             return;
         }
         if (scope === "next") {
-            await removeIfExists(this.nextPath());
+            await this.withNextConfigurationLease(() => removeIfExists(this.nextPath()));
             return;
         }
         if (!taskDir) {
@@ -93,12 +94,14 @@ export class RoleConfigurationManager {
     }
     async selectionForRequest(taskDir) {
         const taskSelection = await this.selectionForTask(taskDir);
-        const next = await readRoleConfigurationIfValid(this.nextPath(), this.config);
-        if (next) {
+        return this.withNextConfigurationLease(async () => {
+            const next = await readRoleConfigurationIfValid(this.nextPath(), this.config);
+            if (!next) {
+                return taskSelection;
+            }
             await removeIfExists(this.nextPath());
             return next;
-        }
-        return taskSelection;
+        });
     }
     async selectionForTask(taskDir) {
         const taskSelection = taskDir
@@ -126,12 +129,45 @@ export class RoleConfigurationManager {
     baselineRoles() {
         return cloneRoleSelection(this.baselineSelection);
     }
+    validate(roles) {
+        return parseRoleSelection(roles, this.config);
+    }
+    workspaceRootPath() {
+        return this.workspaceRoot;
+    }
     futurePath() {
         return roleFutureConfigurationPath(this.appRoot, this.config.dataDir);
     }
     nextPath() {
         return roleNextConfigurationPath(this.workspaceRoot, this.config.dataDir);
     }
+    nextLeaseDir() {
+        return join(this.workspaceRoot, this.config.dataDir, ".role-configuration-next-lock");
+    }
+    async withNextConfigurationLease(run) {
+        let lease = null;
+        for (let attempt = 0; attempt < 80; attempt += 1) {
+            try {
+                lease = await claimTaskRunLease(this.nextLeaseDir());
+                break;
+            }
+            catch (error) {
+                if (!(error instanceof TaskRunLeaseConflictError) || attempt === 79) {
+                    throw error;
+                }
+                await delay(25);
+            }
+        }
+        if (!lease) {
+            throw new Error("Timed out waiting to update the next-request role configuration.");
+        }
+        try {
+            return await run();
+        }
+        finally {
+            await lease.release();
+        }
+    }
     async readLatestTurnSelection(taskDir) {
         const turnsDir = join(taskDir, "turns");
         if (!(await pathExists(turnsDir))) {
@@ -236,3 +272,6 @@ function applyRoleEngines(config, roles) {
         config.pairing[role] = roles[role].engine;
     }
 }
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

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;
     }