parallel-codex-tui 0.3.1 → 0.3.2

package/README.md

@@ -6,7 +6,11 @@ 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.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.
 
@@ -29,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,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. 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.
 
@@ -483,7 +487,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.
 
@@ -539,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.1
+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.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.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/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;
     }