parallel-codex-tui 0.2.8 → 0.2.9

package/README.md

@@ -6,7 +6,7 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`v0.2.8` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.8) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.8). `Ctrl+N` now creates an explicit, durable Main conversation boundary even when no Task is active. It preserves the complete `chat.jsonl`, writes the current scope to `conversation.json`, retires the previous Main native session, and keeps legacy records readable until the first explicit boundary. New prompts and on-demand `conversation.jsonl` snapshots include only the exact current `conversation_id`, while Task chat remains isolated by `task_id`.
+`v0.2.9` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.9) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.9). `Ctrl+T`, then `C`, now opens every persisted Main conversation in the workspace. 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` still creates an explicit, durable Main conversation boundary without deleting chat, Tasks, or Worker logs.
 
 A real Claude acceptance retires the first native session, inserts 16 newer records so the secret is absent from the inline transcript, then proves a fresh Claude session can read the scoped snapshot and recover it. The same live TUI presses `Ctrl+N`, verifies the replacement session is retired, starts another native session whose prompt and archive exclude the secret, and then switches between two isolated workspaces. The bounded rollover fallback remains included: every Main call rebuilds recent context from canonical `chat.jsonl`, so a fresh Agent still receives the latest dialogue inside its current scope.
 
@@ -23,9 +23,9 @@ Highlights:
 - `--diagnostics` and `Ctrl+X` export bounded, redacted support evidence without prompts, role instructions, command arguments, source files, or environment-variable values.
 - Runtime preflight checks Codex, Claude, named third-party Providers, proxy reachability, workspace access, CLI capabilities, and native attach policy before work starts.
 - 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 center, status details, rendered Markdown/Diff/error logs, Unicode search, keyboard navigation, mouse scrolling, and configurable themes share one terminal UI system.
+- 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,294 tests across 127 files: 1,293 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,305 tests across 129 files: 1,304 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.
 
@@ -209,7 +209,7 @@ The doctor output includes `preview:` and `semantic:` ANSI swatch rows so you ca
 - Router classification only receives the user request; workspace selection and session files are kept out of the router prompt.
 - Simple requests stay in the main TUI flow and do not create Judge, Actor, or Critic workers.
 - Consecutive simple requests reuse the main worker's native session across app restarts when the CLI exposes a session id. Every Main call also rebuilds a bounded fallback transcript from the workspace `chat.jsonl`: the current ordinary conversation and each Task are isolated, the just-submitted request is removed, and at most 12 recent records or 6,000 characters are injected. A separate scoped `main-<provider>/conversation.jsonl` snapshot keeps up to 200 records for details outside that inline window; Main is told to read it only when needed and to treat it as context rather than instructions. This keeps multi-turn context available when native resume must roll over to a fresh Agent session without inflating every prompt.
-- The workspace chat transcript is appended to `.parallel-codex/sessions/main/chat.jsonl`; startup restores the latest 200 valid messages and skips isolated corrupt rows. Before the first explicit boundary, records without `conversation_id` remain the compatible legacy conversation. `Ctrl+N` writes `.parallel-codex/sessions/main/conversation.json`, tags later ordinary records with its id, retires every active Main native session, and leaves the complete transcript untouched. Main stores only the extracted final answer in new chat records while retaining the raw Codex/Claude process transcript in the Main Worker's `output.log`. Legacy Codex transcript records are reduced to their final answer at read time without changing the original JSONL. The shared tail reader reads JSONL backward in bounded chunks, so a long-running chat does not require loading its lifetime transcript and a partial or oversized final row cannot hide earlier valid messages.
+- The workspace chat transcript is appended to `.parallel-codex/sessions/main/chat.jsonl`; startup restores the latest 200 valid messages and skips isolated corrupt rows. Before the first explicit boundary, records without `conversation_id` remain the compatible legacy conversation. `Ctrl+N` writes `.parallel-codex/sessions/main/conversation.json`, tags later ordinary records with its id, retires every active Main native session, and leaves the complete transcript untouched. Conversation metadata and reusable native session records are archived under `.parallel-codex/sessions/main/conversations/<conversation>/`; selecting an older conversation intentionally removes its retirement barrier and restores those exact Main bindings. Main stores only the extracted final answer in new chat records while retaining the raw Codex/Claude process transcript in the Main Worker's `output.log`. Legacy Codex transcript records are reduced to their final answer at read time without changing the original JSONL. The shared tail reader reads JSONL backward in bounded chunks, so a long-running chat does not require loading its lifetime transcript and a partial or oversized final row cannot hide earlier valid messages.
 - Chat drafts support Unicode-safe Left/Right, Home/End, Backspace, and Delete editing. A single Up/Down recalls persisted user requests and returns to the exact unsent draft; Ctrl+Up/Down remains available, while repeated alternate-scroll arrow bursts continue to scroll chat. Long input stays on one row with the visible window centered around the logical cursor.
 - Bracketed multiline paste stays in one draft instead of submitting the first line; logical line breaks and tabs appear as `↵` and `⇥` in the single-row input until the complete request is submitted.
 - Complex requests create a session under `.parallel-codex/sessions/`.
@@ -467,7 +467,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, `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, `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.
+
+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, `N` starts a new one, `T` returns to Tasks, and `Esc` returns to chat. 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.
 
 The Task detail view reads authoritative task files and presents `Project -> Task -> Turn -> Worker -> Native session`, including each request, role, engine, configured model, Worker state, native session id, working directory, and last activity time. Historical Workers from earlier turns remain selectable after same-task follow-ups. Use Up/Down or `Tab` to select a Worker, Enter to open its retained log, `C` or `Ctrl+O` to continue the original native session, `B` to ask the native CLI to fork it, `R` to refresh, and `Esc` to return to the Task list. Continue and fork restore the selected Worker's recorded cwd and writable roots while the outer TUI stays open. Codex and Claude have built-in fork commands; a generic CLI exposes `B` only when `interactive.forkArgs` is configured. The child fork is owned and persisted by the native CLI; the indexed parent session remains unchanged.
 
@@ -521,12 +523,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.2.8
+VERSION=0.2.9
 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.2.8` requires tag `v0.2.8`. Published tags such as `v0.2.7` 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.2.9` requires tag `v0.2.9`. Published tags such as `v0.2.8` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -127,7 +127,11 @@ async function main() {
                     records,
                     policy: routerDiagnosticsPolicy(latestConfig.router)
                 };
-            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), loadTaskSessionDetails: (task) => loadPersistedTaskSessionDetails({
+            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), loadMainConversations: () => state.runtime.sessions.listMainConversations(100), activateMainConversation: async (conversationId) => {
+                const restored = await state.runtime.sessions.activateMainConversation(conversationId);
+                await state.runtime.index.setActiveTaskId(null);
+                return restored;
+            }, loadTaskSessionDetails: (task) => loadPersistedTaskSessionDetails({
                 task,
                 taskDir: state.runtime.sessions.taskFromId(task.id).dir,
                 modelNames: Object.fromEntries(Object.entries(state.runtime.config.workers).map(([id, worker]) => [id, worker.model.name]))

package/dist/core/session-manager.js

@@ -11,7 +11,7 @@ import { loadCollaborationTimeline } from "./collaboration-timeline.js";
 import { taskStateTransitionAllowed } from "./task-state-machine.js";
 import { processIsAlive, readProcessStartToken } from "./process-identity.js";
 import { claimTaskRunLease, inspectTaskRunLease, TaskRunLeaseConflictError, terminateOwnedWorkerProcess } from "./process-ownership.js";
-import { ChatRecordSchema, MainConversationStateSchema, EventRecordSchema, FeatureStatusSchema, NativeSessionSchema, RouteDecisionSchema, RetiredNativeSessionSchema, TaskMetaSchema, TaskIdSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
+import { ChatRecordSchema, ConversationIdSchema, MainConversationArchiveSchema, MainConversationStateSchema, EventRecordSchema, FeatureStatusSchema, NativeSessionSchema, RouteDecisionSchema, RetiredNativeSessionSchema, TaskMetaSchema, TaskIdSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
 export class InterruptedTaskRecoveryBlockedError extends Error {
     taskId;
     blocks;
@@ -42,6 +42,9 @@ const ACTIVE_FEATURE_STATES = new Set([
 ]);
 const PENDING_TURN_DIRECTORY = /^\.turn-(\d{4})-.+\.pending$/;
 const PENDING_TASK_CREATION_CLAIM = /^\.(task-.+)\.creating\.json$/;
+const MAIN_CONVERSATION_ARCHIVE_DIRECTORY = "conversations";
+const LEGACY_MAIN_CONVERSATION_DIRECTORY = "legacy";
+const SAFE_MAIN_WORKER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const CompletionContractSchema = z.object({
     version: z.literal(1),
     final_judge_required: z.literal(true)
@@ -180,24 +183,91 @@ export class SessionManager {
         }
         return readJson(path, MainConversationStateSchema);
     }
+    async listMainConversations(limit = 100) {
+        const boundedLimit = Number.isFinite(limit)
+            ? Math.min(500, Math.max(0, Math.trunc(limit)))
+            : 100;
+        if (boundedLimit === 0) {
+            return [];
+        }
+        const [current, records, archives] = await Promise.all([
+            this.readMainConversationState(),
+            readRecentJsonLines(join(this.mainSessionDir(), "chat.jsonl"), ChatRecordSchema, 10000, { filter: (record) => !record.task_id }),
+            this.readMainConversationArchives()
+        ]);
+        const currentId = current?.id ?? null;
+        const conversations = new Map();
+        const ensureConversation = (id, createdAt, lastActivityAt = createdAt) => {
+            const key = mainConversationScopeKey(id);
+            const existing = conversations.get(key);
+            if (existing) {
+                if (createdAt < existing.createdAt) {
+                    existing.createdAt = createdAt;
+                }
+                if (lastActivityAt > existing.lastActivityAt) {
+                    existing.lastActivityAt = lastActivityAt;
+                }
+                return existing;
+            }
+            const summary = {
+                id,
+                title: id ? "Untitled conversation" : "Legacy conversation",
+                createdAt,
+                lastActivityAt,
+                messageCount: 0,
+                userMessageCount: 0,
+                nativeSessionCount: 0,
+                current: id === currentId
+            };
+            conversations.set(key, summary);
+            return summary;
+        };
+        for (const archive of archives) {
+            ensureConversation(archive.id, archive.created_at, archive.last_activated_at);
+        }
+        for (const record of records) {
+            const id = record.conversation_id ?? null;
+            const conversation = ensureConversation(id, record.time, record.time);
+            conversation.messageCount += 1;
+            if (record.from === "user") {
+                conversation.userMessageCount += 1;
+                if (conversation.title === "Untitled conversation" || conversation.title === "Legacy conversation") {
+                    conversation.title = mainConversationTitle(record.text, id);
+                }
+            }
+        }
+        if (current) {
+            ensureConversation(current.id, current.created_at, current.created_at).current = true;
+        }
+        else if (!conversations.has(LEGACY_MAIN_CONVERSATION_DIRECTORY)) {
+            const createdAt = this.now().toISOString();
+            ensureConversation(null, createdAt, createdAt).current = true;
+        }
+        const activeNativeSessions = await this.activeMainNativeSessionIds();
+        await Promise.all([...conversations.values()].map(async (conversation) => {
+            const archived = await this.archivedMainNativeSessionIds(conversation.id);
+            if (conversation.current) {
+                for (const sessionId of activeNativeSessions) {
+                    archived.add(sessionId);
+                }
+            }
+            conversation.nativeSessionCount = archived.size;
+        }));
+        return [...conversations.values()]
+            .sort((left, right) => (Number(right.current) - Number(left.current)
+            || right.lastActivityAt.localeCompare(left.lastActivityAt)
+            || mainConversationScopeKey(right.id).localeCompare(mainConversationScopeKey(left.id))))
+            .slice(0, boundedLimit);
+    }
     async startNewMainConversation() {
         const main = this.taskFromId("main");
         await ensureDir(main.dir);
         const lease = await this.claimTaskRunLease(main.dir);
         return runWithLeaseFinalization("Main conversation reset", lease, async () => {
             const previous = await this.readMainConversationState();
-            const entries = await readdir(main.dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory()) {
-                    continue;
-                }
-                const worker = { dir: join(main.dir, entry.name) };
-                const nativeSession = await this.readNativeSession(worker);
-                if (nativeSession?.scope === "main") {
-                    await this.retireNativeSession(worker, "new Main conversation");
-                }
-            }
             const createdAt = this.now();
+            const currentSummary = (await this.listMainConversations(500)).find((conversation) => conversation.current);
+            await this.archiveAndRetireMainConversation(main, previous?.id ?? null, currentSummary?.createdAt ?? previous?.created_at ?? createdAt.toISOString(), "new Main conversation", Boolean(previous) || (currentSummary?.messageCount ?? 0) > 0 || (currentSummary?.nativeSessionCount ?? 0) > 0);
             const baseId = `conversation-${formatTaskTimestamp(createdAt)}-${this.randomId()}`;
             const state = MainConversationStateSchema.parse({
                 version: 1,
@@ -206,10 +276,61 @@ export class SessionManager {
                 ...(previous ? { previous_id: previous.id } : {})
             });
             await writeJson(join(main.dir, "conversation.json"), state);
+            await this.writeMainConversationArchive({
+                version: 1,
+                id: state.id,
+                created_at: state.created_at,
+                last_activated_at: state.created_at
+            });
             await this.appendEvent(main, "main.conversation_started", `Started ${state.id}`);
             return state;
         });
     }
+    async activateMainConversation(conversationId) {
+        const id = conversationId === null ? null : ConversationIdSchema.parse(conversationId);
+        const main = this.taskFromId("main");
+        await ensureDir(main.dir);
+        const lease = await this.claimTaskRunLease(main.dir);
+        return runWithLeaseFinalization("Main conversation restore", lease, async () => {
+            const conversations = await this.listMainConversations(500);
+            const target = conversations.find((conversation) => conversation.id === id);
+            if (!target) {
+                throw new Error(`Main conversation not found: ${id ?? "legacy"}`);
+            }
+            const current = await this.readMainConversationState();
+            const currentId = current?.id ?? null;
+            if (currentId === id) {
+                return { conversation: target, restoredNativeSessions: 0, changed: false };
+            }
+            const currentSummary = conversations.find((conversation) => conversation.current);
+            const activatedAt = this.now().toISOString();
+            await this.archiveAndRetireMainConversation(main, currentId, currentSummary?.createdAt ?? current?.created_at ?? activatedAt, "switch Main conversation", Boolean(current) || (currentSummary?.messageCount ?? 0) > 0 || (currentSummary?.nativeSessionCount ?? 0) > 0);
+            if (id) {
+                await writeJson(join(main.dir, "conversation.json"), MainConversationStateSchema.parse({
+                    version: 1,
+                    id,
+                    created_at: target.createdAt,
+                    ...(current?.id ? { previous_id: current.id } : {})
+                }));
+            }
+            else {
+                await removeIfExists(join(main.dir, "conversation.json"));
+            }
+            await this.writeMainConversationArchive({
+                version: 1,
+                id,
+                created_at: target.createdAt,
+                last_activated_at: activatedAt
+            });
+            const restoredNativeSessions = await this.restoreMainConversationNativeSessions(main, id);
+            await this.appendEvent(main, "main.conversation_restored", `Restored ${id ?? "legacy conversation"}; ${restoredNativeSessions} native session(s)`);
+            const restored = (await this.listMainConversations(500)).find((conversation) => conversation.id === id);
+            if (!restored) {
+                throw new Error(`Restored Main conversation disappeared from its catalog: ${id ?? "legacy"}`);
+            }
+            return { conversation: restored, restoredNativeSessions, changed: true };
+        });
+    }
     async reconcileInterruptedMainSession() {
         const main = this.taskFromId("main");
         if (!(await pathExists(main.dir))) {
@@ -803,6 +924,127 @@ export class SessionManager {
         await this.clearWorkerStatusNativeSession(worker);
         await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), record.worker_id);
     }
+    mainConversationArchiveDir(conversationId) {
+        return join(this.mainSessionDir(), MAIN_CONVERSATION_ARCHIVE_DIRECTORY, mainConversationScopeKey(conversationId));
+    }
+    async readMainConversationArchives() {
+        const root = join(this.mainSessionDir(), MAIN_CONVERSATION_ARCHIVE_DIRECTORY);
+        if (!(await pathExists(root))) {
+            return [];
+        }
+        const archives = [];
+        for (const entry of await readdir(root, { withFileTypes: true })) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const metadata = await readMainConversationArchiveIfValid(join(root, entry.name, "meta.json"));
+            if (metadata && mainConversationScopeKey(metadata.id) === entry.name) {
+                archives.push(metadata);
+            }
+        }
+        return archives;
+    }
+    async writeMainConversationArchive(metadata) {
+        const parsed = MainConversationArchiveSchema.parse(metadata);
+        const path = join(this.mainConversationArchiveDir(parsed.id), "meta.json");
+        const existing = await readMainConversationArchiveIfValid(path);
+        await writeJson(path, MainConversationArchiveSchema.parse({
+            ...parsed,
+            created_at: existing && existing.created_at < parsed.created_at
+                ? existing.created_at
+                : parsed.created_at
+        }));
+    }
+    async archiveAndRetireMainConversation(main, conversationId, createdAt, reason, persistEmpty = true) {
+        const activatedAt = this.now().toISOString();
+        const archiveDir = join(this.mainConversationArchiveDir(conversationId), "native-sessions");
+        const entries = await readdir(main.dir, { withFileTypes: true });
+        let archivedNativeSession = false;
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === MAIN_CONVERSATION_ARCHIVE_DIRECTORY) {
+                continue;
+            }
+            const worker = { dir: join(main.dir, entry.name) };
+            const nativeSession = await this.readNativeSession(worker);
+            if (nativeSession?.scope !== "main"
+                || nativeSession.role !== "main"
+                || !safeMainWorkerId(nativeSession.worker_id)) {
+                continue;
+            }
+            await writeJson(join(archiveDir, `${nativeSession.worker_id}.json`), nativeSession);
+            await this.retireNativeSession(worker, reason);
+            archivedNativeSession = true;
+        }
+        if (persistEmpty || archivedNativeSession) {
+            await this.writeMainConversationArchive({
+                version: 1,
+                id: conversationId,
+                created_at: createdAt,
+                last_activated_at: activatedAt
+            });
+        }
+    }
+    async restoreMainConversationNativeSessions(main, conversationId) {
+        const archiveDir = join(this.mainConversationArchiveDir(conversationId), "native-sessions");
+        if (!(await pathExists(archiveDir))) {
+            return 0;
+        }
+        let restored = 0;
+        for (const entry of await readdir(archiveDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".json")) {
+                continue;
+            }
+            const record = await readNativeSessionIfValid(join(archiveDir, entry.name));
+            if (!record
+                || record.scope !== "main"
+                || record.role !== "main"
+                || !safeMainWorkerId(record.worker_id)
+                || entry.name !== `${record.worker_id}.json`) {
+                continue;
+            }
+            const worker = { dir: join(main.dir, record.worker_id) };
+            await ensureDir(worker.dir);
+            await writeJson(join(worker.dir, "native-session.json"), record);
+            await removeIfExists(join(worker.dir, "native-session.retired.json"));
+            await this.syncNativeSessionProjection(worker, record);
+            restored += 1;
+        }
+        return restored;
+    }
+    async archivedMainNativeSessionIds(conversationId) {
+        const archiveDir = join(this.mainConversationArchiveDir(conversationId), "native-sessions");
+        const ids = new Set();
+        if (!(await pathExists(archiveDir))) {
+            return ids;
+        }
+        for (const entry of await readdir(archiveDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".json")) {
+                continue;
+            }
+            const record = await readNativeSessionIfValid(join(archiveDir, entry.name));
+            if (record?.scope === "main" && record.role === "main") {
+                ids.add(`${record.engine}\u0000${record.session_id}`);
+            }
+        }
+        return ids;
+    }
+    async activeMainNativeSessionIds() {
+        const ids = new Set();
+        const mainDir = this.mainSessionDir();
+        if (!(await pathExists(mainDir))) {
+            return ids;
+        }
+        for (const entry of await readdir(mainDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === MAIN_CONVERSATION_ARCHIVE_DIRECTORY) {
+                continue;
+            }
+            const record = await this.readNativeSession({ dir: join(mainDir, entry.name) });
+            if (record?.scope === "main" && record.role === "main") {
+                ids.add(`${record.engine}\u0000${record.session_id}`);
+            }
+        }
+        return ids;
+    }
     async appendEvent(task, type, message) {
         const event = {
             time: this.now().toISOString(),
@@ -1375,6 +1617,26 @@ function nextConversationId(baseId, previousId) {
         ? `${baseId}-${suffix + 1}`
         : `${baseId}-2`;
 }
+function mainConversationScopeKey(conversationId) {
+    return conversationId ?? LEGACY_MAIN_CONVERSATION_DIRECTORY;
+}
+function mainConversationTitle(text, conversationId) {
+    const sanitized = sanitizePersistedMainMessage("user", text)
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!sanitized) {
+        return conversationId ? "Untitled conversation" : "Legacy conversation";
+    }
+    const characters = Array.from(sanitized);
+    return characters.length > 80
+        ? `${characters.slice(0, 77).join("")}...`
+        : sanitized;
+}
+function safeMainWorkerId(workerId) {
+    return SAFE_MAIN_WORKER_ID.test(workerId) && workerId !== "." && workerId !== "..";
+}
 function normalizeTaskTitle(title) {
     const normalized = title
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
@@ -1486,6 +1748,17 @@ async function readRetiredNativeSessionIfValid(retiredSessionPath) {
         return null;
     }
 }
+async function readMainConversationArchiveIfValid(path) {
+    if (!(await pathExists(path))) {
+        return null;
+    }
+    try {
+        return await readJson(path, MainConversationArchiveSchema);
+    }
+    catch {
+        return null;
+    }
+}
 async function readWorkerStatusIfValid(statusPath) {
     if (!(await pathExists(statusPath))) {
         return null;

package/dist/domain/schemas.js

@@ -205,6 +205,12 @@ export const MainConversationStateSchema = z.object({
     created_at: z.string().datetime(),
     previous_id: ConversationIdSchema.optional()
 });
+export const MainConversationArchiveSchema = z.object({
+    version: z.literal(1),
+    id: ConversationIdSchema.nullable(),
+    created_at: z.string().datetime(),
+    last_activated_at: z.string().datetime()
+});
 export const ChatRecordSchema = z.object({
     time: z.string().datetime(),
     from: z.enum(["user", "system"]),

package/dist/tui/App.js

@@ -29,6 +29,7 @@ import { moveWorkerSelection, WorkerOverviewView } from "./WorkerOverviewView.js
 import { FeatureBoardView, moveFeatureBoardSelection } from "./FeatureBoardView.js";
 import { CollaborationTimelineView, collaborationSelectionScrollOffset, collaborationTimelineEvents, moveCollaborationEventSelection, nextCollaborationFeatureIndex } from "./CollaborationTimelineView.js";
 import { moveTaskSessionSelection, TaskSessionsView } from "./TaskSessionsView.js";
+import { MainConversationsView, moveMainConversationSelection } from "./MainConversationsView.js";
 import { moveTaskSessionDetailSelection, TaskSessionDetailView } from "./TaskSessionDetailView.js";
 import { latestTaskResultMessageIndex, parseTaskResultSummary } from "./task-result.js";
 import { buildNativeAttachLaunch, buildNativeForkLaunch, startNativeAttachProcess } from "../workers/native-attach.js";
@@ -49,7 +50,7 @@ const EMPTY_WORKER_NAVIGATION_TARGETS = {
     errorOffsets: [],
     diffOffsets: []
 };
-export function App({ config, orchestrator, cwd, initialTaskId = null, initialRoute = null, initialWorkers, initialCanRetryTask = false, initialMessages = [], persistChatMessage, reloadConfig, workspaceChoices = [], switchWorkspace, loadRouterDiagnostics, loadTaskSessions, loadTaskSessionDetails, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, exportDiagnostics, loadCollaborationTimeline, activateTaskSession, startMainConversation, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
+export function App({ config, orchestrator, cwd, initialTaskId = null, initialRoute = null, initialWorkers, initialCanRetryTask = false, initialMessages = [], persistChatMessage, reloadConfig, workspaceChoices = [], switchWorkspace, loadRouterDiagnostics, loadTaskSessions, loadMainConversations, activateMainConversation, loadTaskSessionDetails, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, exportDiagnostics, loadCollaborationTimeline, activateTaskSession, startMainConversation, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
     configureTuiTheme({
         theme: config.ui.theme,
         colors: config.ui.colors
@@ -97,6 +98,9 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const [routerMaxScrollOffset, setRouterMaxScrollOffset] = useState(0);
     const [taskSessions, setTaskSessions] = useState([]);
     const [selectedTaskSessionIndex, setSelectedTaskSessionIndex] = useState(0);
+    const [sessionCenterMode, setSessionCenterMode] = useState("tasks");
+    const [mainConversations, setMainConversations] = useState([]);
+    const [selectedMainConversationIndex, setSelectedMainConversationIndex] = useState(0);
     const [taskSessionsLoading, setTaskSessionsLoading] = useState(false);
     const [taskSessionsError, setTaskSessionsError] = useState(null);
     const [taskSessionsNotice, setTaskSessionsNotice] = useState(null);
@@ -149,6 +153,9 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const routerMaxScrollOffsetRef = useRef(routerMaxScrollOffset);
     const taskSessionsRef = useRef(taskSessions);
     const selectedTaskSessionIndexRef = useRef(selectedTaskSessionIndex);
+    const sessionCenterModeRef = useRef("tasks");
+    const mainConversationsRef = useRef(mainConversations);
+    const selectedMainConversationIndexRef = useRef(selectedMainConversationIndex);
     const taskSessionsLoadingRef = useRef(taskSessionsLoading);
     const taskSessionsIncludeArchivedRef = useRef(taskSessionsIncludeArchived);
     const taskSessionActionRef = useRef(taskSessionAction);
@@ -180,6 +187,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const refreshCollaborationTimelineRef = useRef(refreshCollaborationTimeline);
     const activateSelectedTaskSessionRef = useRef(activateSelectedTaskSession);
     const refreshTaskSessionsRef = useRef(refreshTaskSessions);
+    const openMainConversationsRef = useRef(openMainConversations);
+    const restoreSelectedMainConversationRef = useRef(restoreSelectedMainConversation);
     const renameSelectedTaskSessionRef = useRef(renameSelectedTaskSession);
     const archiveSelectedTaskSessionRef = useRef(archiveSelectedTaskSession);
     const deleteSelectedTaskSessionRef = useRef(deleteSelectedTaskSession);
@@ -334,6 +343,15 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     useEffect(() => {
         selectedTaskSessionIndexRef.current = selectedTaskSessionIndex;
     }, [selectedTaskSessionIndex]);
+    useEffect(() => {
+        sessionCenterModeRef.current = sessionCenterMode;
+    }, [sessionCenterMode]);
+    useEffect(() => {
+        mainConversationsRef.current = mainConversations;
+    }, [mainConversations]);
+    useEffect(() => {
+        selectedMainConversationIndexRef.current = selectedMainConversationIndex;
+    }, [selectedMainConversationIndex]);
     useEffect(() => {
         taskSessionsLoadingRef.current = taskSessionsLoading;
     }, [taskSessionsLoading]);
@@ -405,6 +423,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         refreshCollaborationTimelineRef.current = refreshCollaborationTimeline;
         activateSelectedTaskSessionRef.current = activateSelectedTaskSession;
         refreshTaskSessionsRef.current = refreshTaskSessions;
+        openMainConversationsRef.current = openMainConversations;
+        restoreSelectedMainConversationRef.current = restoreSelectedMainConversation;
         renameSelectedTaskSessionRef.current = renameSelectedTaskSession;
         archiveSelectedTaskSessionRef.current = archiveSelectedTaskSession;
         deleteSelectedTaskSessionRef.current = deleteSelectedTaskSession;
@@ -685,6 +705,13 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setTaskSessionsError(null);
             setSelectedTaskSessionIndex(nextIndex);
         };
+        const moveSelectedMainConversation = (delta, wrap = false) => {
+            const nextIndex = moveMainConversationSelection(selectedMainConversationIndexRef.current, delta, mainConversationsRef.current.length, wrap);
+            selectedMainConversationIndexRef.current = nextIndex;
+            setTaskSessionsError(null);
+            setTaskSessionsNotice(null);
+            setSelectedMainConversationIndex(nextIndex);
+        };
         const moveSelectedTaskSessionDetailWorker = (delta, wrap = false) => {
             const nextIndex = moveTaskSessionDetailSelection(taskSessionDetailSelectedWorkerIndexRef.current, delta, taskSessionDetailsRef.current?.workers.length ?? 0, wrap);
             taskSessionDetailSelectedWorkerIndexRef.current = nextIndex;
@@ -847,6 +874,49 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     }
                     return;
                 }
+                if (sessionCenterModeRef.current === "conversations") {
+                    if (isTaskSessionsShortcut(chunk, {}) || chunk === "\x1b") {
+                        setTaskSessionsError(null);
+                        setTaskSessionsNotice(null);
+                        viewRef.current = taskSessionsReturnViewRef.current;
+                        setView(taskSessionsReturnViewRef.current);
+                        return;
+                    }
+                    if (taskSessionsLoadingRef.current) {
+                        return;
+                    }
+                    if (isNewConversationShortcut(chunk, {}) || chunk === "n" || chunk === "N") {
+                        void newConversationRef.current();
+                        return;
+                    }
+                    if (chunk === "t" || chunk === "T") {
+                        sessionCenterModeRef.current = "tasks";
+                        setSessionCenterMode("tasks");
+                        setTaskSessionsError(null);
+                        setTaskSessionsNotice(null);
+                        void refreshTaskSessionsRef.current(activeTaskIdRef.current);
+                        return;
+                    }
+                    if (chunk === "c" || chunk === "C") {
+                        void openMainConversationsRef.current();
+                        return;
+                    }
+                    if (chunk === "\r" || chunk === "\n") {
+                        void restoreSelectedMainConversationRef.current();
+                        return;
+                    }
+                    if (chunk === "\t") {
+                        moveSelectedMainConversation(1, true);
+                        return;
+                    }
+                    const conversationSelectionDelta = -(rawHistoryDelta(chunk)
+                        + rawPageScrollDelta(chunk, Math.max(1, outputHeight - 2))
+                        + mouseScrollDelta(chunk, 1));
+                    if (conversationSelectionDelta !== 0) {
+                        moveSelectedMainConversation(conversationSelectionDelta);
+                    }
+                    return;
+                }
                 const sessionAction = taskSessionActionRef.current;
                 if (sessionAction) {
                     if (chunk === "\x1b") {
@@ -902,6 +972,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     void newConversationRef.current();
                     return;
                 }
+                if (chunk === "c" || chunk === "C") {
+                    void openMainConversationsRef.current();
+                    return;
+                }
                 const selectedSession = taskSessionsRef.current[selectedTaskSessionIndexRef.current];
                 if (chunk === "r" || chunk === "R") {
                     if (selectedSession) {
@@ -1682,7 +1756,15 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 label: "sessions",
                 text: details
                     ? details.workers.map((worker) => [worker.id, worker.role, worker.engine, worker.state].join(" · ")).join("\n")
-                    : taskSessionsRef.current.map((task) => [task.id, task.title, task.status].join(" · ")).join("\n")
+                    : sessionCenterModeRef.current === "conversations"
+                        ? mainConversationsRef.current.map((conversation) => [
+                            conversation.current ? "current" : "saved",
+                            conversation.id ?? "legacy",
+                            conversation.title,
+                            `${conversation.messageCount} messages`,
+                            `${conversation.nativeSessionCount} native`
+                        ].join(" · ")).join("\n")
+                        : taskSessionsRef.current.map((task) => [task.id, task.title, task.status].join(" · ")).join("\n")
             };
         }
         if (currentView === "router") {
@@ -2110,6 +2192,10 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setAttachError(error instanceof Error ? error.message : String(error));
             return;
         }
+        resetActiveTaskUiForMainConversation();
+        await appendVisibleMessage({ from: "system", text: "new conversation · ready" });
+    }
+    function resetActiveTaskUiForMainConversation() {
         const nextMemory = newTaskMemoryState();
         activeTaskIdRef.current = nextMemory.activeTaskId;
         setActiveTaskId(nextMemory.activeTaskId);
@@ -2134,7 +2220,6 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             offset: 0,
             draft: { value: inputRef.current, cursor: inputCursorRef.current }
         };
-        await appendVisibleMessage({ from: "system", text: "new conversation · ready" });
     }
     async function openRouterDiagnostics() {
         const currentView = viewRef.current;
@@ -2200,6 +2285,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         setTaskSessionDetailSelectedWorkerIndex(0);
         setTaskSessionDetailNotice(null);
         updateTaskSessionAction(null);
+        sessionCenterModeRef.current = "tasks";
+        setSessionCenterMode("tasks");
         await refreshTaskSessions(activeTaskIdRef.current);
     }
     async function refreshTaskSessions(preferredTaskId = null) {
@@ -2240,6 +2327,103 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             }
         }
     }
+    async function openMainConversations() {
+        const currentView = viewRef.current;
+        if (busyRef.current || currentView === "native" || currentView === "workspace") {
+            return;
+        }
+        if (currentView !== "sessions") {
+            taskSessionsReturnViewRef.current = currentView === "worker" || currentView === "workers" || currentView === "router"
+                ? currentView
+                : "chat";
+            viewRef.current = "sessions";
+            setView("sessions");
+        }
+        const previousId = sessionCenterModeRef.current === "conversations"
+            ? mainConversationsRef.current[selectedMainConversationIndexRef.current]?.id
+            : undefined;
+        sessionCenterModeRef.current = "conversations";
+        setSessionCenterMode("conversations");
+        taskSessionDetailsRef.current = null;
+        setTaskSessionDetails(null);
+        updateTaskSessionAction(null);
+        setTaskSessionsError(null);
+        setTaskSessionsNotice(null);
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        const sequence = taskSessionsLoadSequenceRef.current + 1;
+        taskSessionsLoadSequenceRef.current = sequence;
+        try {
+            if (!loadMainConversations) {
+                throw new Error("Main conversations are unavailable");
+            }
+            const conversations = await loadMainConversations();
+            if (taskSessionsLoadSequenceRef.current !== sequence) {
+                return;
+            }
+            mainConversationsRef.current = conversations;
+            setMainConversations(conversations);
+            const preservedIndex = previousId !== undefined
+                ? conversations.findIndex((conversation) => conversation.id === previousId)
+                : -1;
+            const currentIndex = conversations.findIndex((conversation) => conversation.current);
+            const selectedIndex = preservedIndex >= 0
+                ? preservedIndex
+                : currentIndex >= 0
+                    ? currentIndex
+                    : 0;
+            selectedMainConversationIndexRef.current = selectedIndex;
+            setSelectedMainConversationIndex(selectedIndex);
+        }
+        catch (error) {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                setTaskSessionsError(error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            if (taskSessionsLoadSequenceRef.current === sequence) {
+                taskSessionsLoadingRef.current = false;
+                setTaskSessionsLoading(false);
+            }
+        }
+    }
+    async function restoreSelectedMainConversation() {
+        if (busyRef.current || taskSessionsLoadingRef.current) {
+            return;
+        }
+        const selected = mainConversationsRef.current[selectedMainConversationIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        setTaskSessionsNotice(null);
+        try {
+            if (!activateMainConversation) {
+                throw new Error("Main conversation restore is unavailable");
+            }
+            const result = await activateMainConversation(selected.id);
+            if (!result.changed) {
+                await openMainConversations();
+                setTaskSessionsNotice(`Already current · ${result.conversation.title}`);
+                return;
+            }
+            await activateTaskSession?.(null);
+            resetActiveTaskUiForMainConversation();
+            await appendVisibleMessage({
+                from: "system",
+                text: `conversation restored · ${result.conversation.title} · ${result.restoredNativeSessions} native`
+            });
+        }
+        catch (error) {
+            setTaskSessionsError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            taskSessionsLoadingRef.current = false;
+            setTaskSessionsLoading(false);
+        }
+    }
     function updateTaskSessionAction(next) {
         taskSessionActionRef.current = next;
         setTaskSessionAction(next);
@@ -2727,11 +2911,11 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                 ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }
-                    : null, taskSessionsIncludeArchived: taskSessionsIncludeArchived, taskSessionDetail: Boolean(taskSessionDetails), taskSessionDetailHasNative: taskSessionDetailHasNative, taskSessionDetailCanFork: taskSessionDetailCanFork, canRetry: canRetryTask, hasWorkers: workers.length > 0, hasActiveTask: Boolean(activeTaskId), hasTaskResult: hasTaskResult, taskResultExpanded: taskResultExpanded, chatScrollOffset: chatScrollOffset, chatMaxScrollOffset: chatMaxScrollOffset, nativeClosed: view === "native" && nativeAttach?.closedCode !== null, searchMatchIndex: workerSearch.matchIndex, searchMatchCount: workerNavigationTargets.searchOffsets.length, clipboardNotice: clipboardNotice, value: workerSearch.open && view === "worker"
+                    : null, taskSessionsIncludeArchived: taskSessionsIncludeArchived, mainConversationSessions: sessionCenterMode === "conversations" && !taskSessionDetails, taskSessionDetail: Boolean(taskSessionDetails), taskSessionDetailHasNative: taskSessionDetailHasNative, taskSessionDetailCanFork: taskSessionDetailCanFork, canRetry: canRetryTask, hasWorkers: workers.length > 0, hasActiveTask: Boolean(activeTaskId), hasTaskResult: hasTaskResult, taskResultExpanded: taskResultExpanded, chatScrollOffset: chatScrollOffset, chatMaxScrollOffset: chatMaxScrollOffset, nativeClosed: view === "native" && nativeAttach?.closedCode !== null, searchMatchIndex: workerSearch.matchIndex, searchMatchCount: workerNavigationTargets.searchOffsets.length, clipboardNotice: clipboardNotice, value: workerSearch.open && view === "worker"
                 ? workerSearch.query
                 : view === "native" || view === "router" || view === "workers" || view === "features" || view === "sessions" || view === "collaboration" || view === "status" ? "" : input, cursor: workerSearch.open && view === "worker"
                 ? workerSearch.cursor
-                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, pairing: config.pairing, configStatus: configChange?.detail, configRestartRequired: configChange?.kind === "restart", workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : (_jsx(TaskSessionsView, { tasks: taskSessions, activeTaskId: activeTaskId, selectedIndex: selectedTaskSessionIndex, includeArchived: taskSessionsIncludeArchived, notice: taskSessionsNotice, action: taskSessionAction?.type === "rename"
+                : view === "chat" ? inputCursor : undefined, terminalWidth: terminalWidth, onChange: view === "native" ? setNativeInput : setInput, onSubmit: view === "native" ? undefined : submit }), error: attachError, children: view === "status" ? (_jsx(StatusDetailView, { cwd: cwd, taskId: activeTaskId, mode: activeMode, busy: busy, canRetry: canRetryTask, taskStatus: visibleTaskStatus, routeStatus: visibleRouteStatus, routeReason: routePending ? undefined : lastRoute?.reason, pairing: config.pairing, configStatus: configChange?.detail, configRestartRequired: configChange?.kind === "restart", workers: workers, selectedWorkerIndex: selectedWorkerIndex, height: contentHeight, terminalWidth: terminalWidth })) : view === "native" ? (_jsx(NativeAttachView, { attach: nativeAttach, viewportHeight: contentHeight })) : view === "sessions" ? (taskSessionDetails ? (_jsx(TaskSessionDetailView, { details: taskSessionDetails, selectedWorkerIndex: taskSessionDetailSelectedWorkerIndex, loading: taskSessionsLoading, error: taskSessionsError, notice: taskSessionDetailNotice, height: contentHeight, terminalWidth: terminalWidth })) : sessionCenterMode === "conversations" ? (_jsx(MainConversationsView, { conversations: mainConversations, selectedIndex: selectedMainConversationIndex, notice: taskSessionsNotice, loading: taskSessionsLoading, error: taskSessionsError, height: contentHeight, terminalWidth: terminalWidth })) : (_jsx(TaskSessionsView, { tasks: taskSessions, activeTaskId: activeTaskId, selectedIndex: selectedTaskSessionIndex, includeArchived: taskSessionsIncludeArchived, notice: taskSessionsNotice, action: taskSessionAction?.type === "rename"
                 ? { type: "rename", title: taskSessionAction.title }
                 : taskSessionAction?.type === "delete"
                     ? { type: "delete", title: taskSessionAction.title }

package/dist/tui/InputBar.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text } from "ink";
 import { compactEndByDisplayWidth, compactTailByDisplayWidth, displayWidth } from "./display-width.js";
 import { TUI_THEME } from "./theme.js";
-export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, taskSessionAction = null, taskSessionsIncludeArchived = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, clipboardNotice = null, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
+export function InputBar({ mode, ready = true, busy = false, routeFallback = false, collaborationDetail = false, collaborationUnresolved = false, collaborationBack = "workers", featureCanCancel = false, featureCanPause = false, featureCanReassign = false, featureCancelConfirm = false, featurePauseConfirm = false, featureAssignment = false, taskSessionAction = null, taskSessionsIncludeArchived = false, mainConversationSessions = false, taskSessionDetail = false, taskSessionDetailHasNative = false, taskSessionDetailCanFork = false, canRetry = false, hasWorkers = false, hasActiveTask = false, hasTaskResult = false, taskResultExpanded = false, chatScrollOffset = 0, chatMaxScrollOffset = 0, nativeClosed = false, searchMatchIndex = 0, searchMatchCount = 0, clipboardNotice = null, value, cursor, terminalWidth: providedTerminalWidth, onChange, onSubmit }) {
     const terminalWidth = providedTerminalWidth ?? process.stdout.columns ?? 120;
     const fillRail = providedTerminalWidth !== undefined || typeof process.stdout.columns === "number";
     if (clipboardNotice) {
@@ -39,6 +39,10 @@ export function InputBar({ mode, ready = true, busy = false, routeFallback = fal
             const hints = taskSessionDetailInputHints(terminalWidth, taskSessionDetailHasNative, taskSessionDetailCanFork);
             return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(`${hints.label}${hints.detail}`), fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: hints.label }), hints.detail ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: hints.detail }) : null] }));
         }
+        if (mainConversationSessions) {
+            const hints = mainConversationSessionsInputHints(terminalWidth);
+            return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(`${hints.label}${hints.detail}`), fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: hints.label }), hints.detail ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: hints.detail }) : null] }));
+        }
         const hints = taskSessionsInputHints(terminalWidth, taskSessionsIncludeArchived);
         return (_jsxs(InputRail, { terminalWidth: terminalWidth, textWidth: displayWidth(`${hints.label}${hints.detail}`), fill: fillRail, children: [_jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent, bold: true, children: hints.label }), hints.detail ? _jsx(Text, { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted, children: hints.detail }) : null] }));
     }
@@ -564,9 +568,13 @@ function collaborationDetailInputHints(width) {
 function taskSessionsInputHints(width, includeArchived) {
     const archivedAction = includeArchived ? "H hide archived" : "H archived";
     return selectInputHints(width, [
-        { label: "sessions", detail: ` · Up/Dn select · Enter restore · I inspect · R rename · A archive · D delete · E export · ${archivedAction} · Esc back` },
-        { label: "sessions", detail: " · Up/Dn select · Enter restore · I inspect · R rename · A archive · D delete · E export · Esc back" },
-        { label: "sessions", detail: " · Up/Dn select · Enter restore · I inspect · R rename · A archive · D delete · Esc back" },
+        { label: "sessions", detail: ` · Up/Dn select · Enter restore · C conversations · I inspect · R rename · A archive · D delete · E export · ${archivedAction} · Esc back` },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C conversations · I inspect · R rename · A archive · D delete · E export · Esc back" },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C chats · I inspect · R rename · A archive · D delete · Esc back" },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C chats · I inspect · R rename · A archive · Esc back" },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C chats · I inspect · R rename · Esc back" },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C chats · R rename · Esc back" },
+        { label: "sessions", detail: " · Up/Dn select · Enter restore · C chats · Esc back" },
         { label: "sessions", detail: " · Up/Dn select · Enter restore · I inspect · R rename · A archive · Esc back" },
         { label: "sessions", detail: " · Up/Dn select · Enter restore · I inspect · R rename · Esc back" },
         { label: "sessions", detail: " · Up/Dn select · Enter restore · R rename · Esc back" },
@@ -580,6 +588,18 @@ function taskSessionsInputHints(width, includeArchived) {
         { label: "s", detail: "" }
     ]);
 }
+function mainConversationSessionsInputHints(width) {
+    return selectInputHints(width, [
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · N new · T tasks · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · T tasks · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Esc back" },
+        { label: "conversations", detail: " · Esc back" },
+        { label: "Esc back", detail: "" },
+        { label: "chats", detail: "" },
+        { label: "c", detail: "" }
+    ]);
+}
 function taskSessionDetailInputHints(width, hasNative, canFork) {
     const nativeActions = hasNative
         ? `${canFork ? "C continue · B branch" : "C continue"} · `

package/dist/tui/MainConversationsView.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { compactEndByDisplayWidth, displayWidth } from "./display-width.js";
+import { TUI_THEME } from "./theme.js";
+export function MainConversationsView({ conversations, selectedIndex, notice = null, loading = false, error = null, height = 20, terminalWidth = process.stdout.columns || 120 }) {
+    const viewportHeight = Math.max(1, height);
+    const width = mainConversationsContentWidth(terminalWidth);
+    const lines = mainConversationsDisplayLines(conversations, selectedIndex, viewportHeight, terminalWidth, { notice, loading, error });
+    const blankRows = Math.max(0, viewportHeight - lines.length);
+    return (_jsxs(Box, { flexDirection: "column", height: viewportHeight, children: [lines.map((line, index) => (_jsx(MainConversationRow, { line: line, width: width }, `${line.conversationIndex ?? line.tone}-${index}`))), Array.from({ length: blankRows }, (_, index) => (_jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(width) }, `main-conversation-fill-${index}`)))] }));
+}
+export function mainConversationsDisplayLines(conversations, selectedIndex, height, terminalWidth, state = {}) {
+    const viewportHeight = Math.max(1, Math.trunc(height));
+    const width = mainConversationsContentWidth(terminalWidth);
+    const lines = [{
+            text: fitMainConversationCandidates(["Main conversations", "Conversations", "Chats", "C"], width),
+            tone: "heading"
+        }];
+    if (viewportHeight >= 3) {
+        const messages = conversations.reduce((sum, conversation) => sum + conversation.messageCount, 0);
+        const nativeSessions = conversations.reduce((sum, conversation) => sum + conversation.nativeSessionCount, 0);
+        lines.push({
+            text: fitMainConversationCandidates([
+                `${conversations.length} ${conversations.length === 1 ? "conversation" : "conversations"} · ${messages} messages · ${nativeSessions} native`,
+                `${conversations.length} conversations · ${messages} messages`,
+                `${conversations.length} conversations`,
+                `${conversations.length} chats`
+            ], width),
+            tone: "muted"
+        });
+    }
+    if (viewportHeight >= 4 && state.notice) {
+        lines.push({ text: fitMainConversationText(state.notice, width), tone: "success" });
+    }
+    const slots = Math.max(0, viewportHeight - lines.length);
+    if (state.loading) {
+        if (slots > 0) {
+            lines.push({ text: fitMainConversationText("loading Main conversations", width), tone: "muted" });
+        }
+        return lines;
+    }
+    if (state.error) {
+        if (slots > 0) {
+            lines.push({ text: fitMainConversationText(`error · ${safeMainConversationText(state.error)}`, width), tone: "danger" });
+        }
+        return lines;
+    }
+    if (conversations.length === 0) {
+        if (slots > 0) {
+            lines.push({ text: fitMainConversationText("No saved Main conversations", width), tone: "muted" });
+        }
+        return lines;
+    }
+    const selected = clampMainConversationIndex(selectedIndex, conversations.length);
+    const visibleCount = Math.min(slots, conversations.length);
+    const start = mainConversationWindowStart(selected, conversations.length, visibleCount);
+    for (let index = start; index < start + visibleCount; index += 1) {
+        const conversation = conversations[index];
+        if (!conversation) {
+            continue;
+        }
+        lines.push({
+            text: mainConversationRowText(conversation, index === selected, width),
+            tone: conversation.current ? "success" : index === selected ? "active" : "muted",
+            conversationIndex: index
+        });
+    }
+    return lines;
+}
+export function moveMainConversationSelection(current, delta, conversationCount, wrap = false) {
+    if (conversationCount <= 0) {
+        return 0;
+    }
+    const normalizedCurrent = clampMainConversationIndex(current, conversationCount);
+    const next = normalizedCurrent + Math.trunc(delta);
+    if (wrap) {
+        return ((next % conversationCount) + conversationCount) % conversationCount;
+    }
+    return Math.min(conversationCount - 1, Math.max(0, next));
+}
+function MainConversationRow({ line, width }) {
+    const trailingWidth = Math.max(0, width - displayWidth(line.text));
+    const theme = mainConversationLineTheme(line.tone);
+    return (_jsxs(Text, { children: [_jsx(Text, { ...theme, children: line.text }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.surface, children: " ".repeat(trailingWidth) }) : null] }));
+}
+function mainConversationRowText(conversation, selected, width) {
+    const marker = `${selected ? ">" : " "} ${conversation.current ? "*" : " "} `;
+    const title = safeMainConversationText(conversation.title);
+    const messages = `${conversation.messageCount} ${conversation.messageCount === 1 ? "message" : "messages"}`;
+    const native = `${conversation.nativeSessionCount} native`;
+    const date = conversation.lastActivityAt.slice(5, 16).replace("T", " ");
+    const scope = conversation.id
+        ? `#${conversation.id.replace(/^conversation-/, "")}`
+        : "legacy";
+    return fitMainConversationCandidates([
+        [marker + title, messages, native, date].join(" · "),
+        [marker + title, messages, native].join(" · "),
+        [marker + title, messages].join(" · "),
+        [marker + title, date].join(" · "),
+        [marker + scope, messages].join(" · "),
+        marker.trimEnd()
+    ], width);
+}
+function mainConversationWindowStart(selected, count, visibleCount) {
+    if (visibleCount <= 0 || count <= visibleCount) {
+        return 0;
+    }
+    return Math.min(count - visibleCount, Math.max(0, selected - Math.floor(visibleCount / 2)));
+}
+function clampMainConversationIndex(index, count) {
+    return Math.min(Math.max(0, count - 1), Math.max(0, Math.trunc(index)));
+}
+function fitMainConversationCandidates(candidates, width) {
+    return candidates.find((candidate) => displayWidth(candidate) <= width)
+        ?? fitMainConversationText(candidates.at(-1) ?? "", width);
+}
+function fitMainConversationText(text, width) {
+    return compactEndByDisplayWidth(text, Math.max(1, width));
+}
+function safeMainConversationText(text) {
+    return text
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function mainConversationLineTheme(tone) {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        color: tone === "heading" || tone === "active"
+            ? TUI_THEME.accent
+            : tone === "success"
+                ? TUI_THEME.success
+                : tone === "danger"
+                    ? TUI_THEME.danger
+                    : TUI_THEME.muted,
+        ...(tone === "heading" || tone === "danger" ? { bold: true } : {})
+    };
+}
+function mainConversationsContentWidth(terminalWidth) {
+    return Math.max(1, terminalWidth - 2);
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.2.8";
+export const version = "0.2.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parallel-codex-tui",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "A TypeScript TUI wrapper for routed parallel coding with Codex and Claude workers.",
   "license": "MIT",
   "type": "module",