parallel-codex-tui 0.2.9 → 0.2.10

package/README.md

@@ -6,7 +6,7 @@ Built with Codex-assisted development.
 
 ## Current Release
 
-`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.
+`v0.2.10` is available from [npm](https://www.npmjs.com/package/parallel-codex-tui/v/0.2.10) and as a [GitHub Release](https://github.com/allendred/parallel-codex-tui/releases/tag/v0.2.10). `Ctrl+T`, then `C`, opens every persisted Main conversation and now provides the same durable management lifecycle as Task sessions: rename, archive, unarchive, scoped export, and confirmed deletion. Restoring one switches the exact `conversation_id`, reloads only that conversation's file-backed history, and restores its archived native Codex or Claude session ids when they are available. `Ctrl+N` 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.
 
@@ -25,7 +25,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,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`.
+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,311 tests across 130 files: 1,310 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.
 
@@ -469,7 +469,7 @@ From Worker overview, press `C` to open the file-backed Actor/Critic collaborati
 
 `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 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.
 
 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.
 
@@ -523,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.9
+VERSION=0.2.10
 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.9` requires tag `v0.2.9`. Published tags such as `v0.2.8` 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.10` requires tag `v0.2.10`. Published tags such as `v0.2.9` are immutable and must not be moved or reused.
 
 ## Publishing Hygiene
 

package/dist/cli.js

@@ -127,11 +127,17 @@ async function main() {
                     records,
                     policy: routerDiagnosticsPolicy(latestConfig.router)
                 };
-            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), loadMainConversations: () => state.runtime.sessions.listMainConversations(100), activateMainConversation: async (conversationId) => {
+            }, loadTaskSessions: (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;
-            }, loadTaskSessionDetails: (task) => loadPersistedTaskSessionDetails({
+            }, renameMainConversation: async (conversationId, title) => {
+                await state.runtime.sessions.renameMainConversation(conversationId, title);
+            }, setMainConversationArchived: async (conversationId, archived) => {
+                await state.runtime.sessions.setMainConversationArchived(conversationId, archived);
+            }, deleteMainConversation: async (conversationId) => {
+                await state.runtime.sessions.deleteMainConversation(conversationId);
+            }, exportMainConversation: async (conversationId) => (await state.runtime.sessions.exportMainConversation(conversationId)).path, 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

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { cp, mkdir, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { cp, mkdir, mkdtemp, open, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { createInterface } from "node:readline";
 import { z } from "zod";
 import { appendJsonLine, appendText, ensureDir, pathExists, readJson, readRecentJsonLines, readTextIfExists, removeIfExists, writeJson, writeText } from "./file-store.js";
 import { runWithLeaseFinalization } from "./lease-finalization.js";
@@ -183,7 +185,7 @@ export class SessionManager {
         }
         return readJson(path, MainConversationStateSchema);
     }
-    async listMainConversations(limit = 100) {
+    async listMainConversations(limit = 100, options = {}) {
         const boundedLimit = Number.isFinite(limit)
             ? Math.min(500, Math.max(0, Math.trunc(limit)))
             : 100;
@@ -223,7 +225,13 @@ export class SessionManager {
             return summary;
         };
         for (const archive of archives) {
-            ensureConversation(archive.id, archive.created_at, archive.last_activated_at);
+            const conversation = ensureConversation(archive.id, archive.created_at, archive.last_activated_at);
+            if (archive.title) {
+                conversation.title = archive.title;
+            }
+            if (archive.archived_at) {
+                conversation.archivedAt = archive.archived_at;
+            }
         }
         for (const record of records) {
             const id = record.conversation_id ?? null;
@@ -254,7 +262,9 @@ export class SessionManager {
             conversation.nativeSessionCount = archived.size;
         }));
         return [...conversations.values()]
+            .filter((conversation) => options.includeArchived || !conversation.archivedAt || conversation.current)
             .sort((left, right) => (Number(right.current) - Number(left.current)
+            || Number(Boolean(left.archivedAt)) - Number(Boolean(right.archivedAt))
             || right.lastActivityAt.localeCompare(left.lastActivityAt)
             || mainConversationScopeKey(right.id).localeCompare(mainConversationScopeKey(left.id))))
             .slice(0, boundedLimit);
@@ -292,11 +302,14 @@ export class SessionManager {
         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 conversations = await this.listMainConversations(500, { includeArchived: true });
             const target = conversations.find((conversation) => conversation.id === id);
             if (!target) {
                 throw new Error(`Main conversation not found: ${id ?? "legacy"}`);
             }
+            if (target.archivedAt) {
+                throw new Error(`Cannot restore archived Main conversation ${id ?? "legacy"}. Unarchive it first.`);
+            }
             const current = await this.readMainConversationState();
             const currentId = current?.id ?? null;
             if (currentId === id) {
@@ -331,6 +344,140 @@ export class SessionManager {
             return { conversation: restored, restoredNativeSessions, changed: true };
         });
     }
+    async renameMainConversation(conversationId, title) {
+        const normalizedTitle = normalizeMainConversationTitle(title);
+        return this.withMainConversationManagementLease(conversationId, "rename", async (main, conversation) => {
+            const metadata = await this.mainConversationArchiveMetadata(conversation);
+            await this.writeMainConversationArchive({ ...metadata, title: normalizedTitle });
+            await this.appendEvent(main, "main.conversation_renamed", `Renamed ${conversation.id ?? "legacy conversation"} to ${normalizedTitle}`);
+            return this.requireMainConversationSummary(conversation.id);
+        });
+    }
+    async setMainConversationArchived(conversationId, archived) {
+        return this.withMainConversationManagementLease(conversationId, archived ? "archive" : "unarchive", async (main, conversation) => {
+            if (archived && conversation.current) {
+                throw new Error("Cannot archive the current Main conversation. Restore another conversation first.");
+            }
+            if (Boolean(conversation.archivedAt) === archived) {
+                return conversation;
+            }
+            const metadata = await this.mainConversationArchiveMetadata(conversation);
+            const next = archived
+                ? MainConversationArchiveSchema.parse({
+                    ...metadata,
+                    archived_at: this.now().toISOString()
+                })
+                : withoutMainConversationArchiveTime(metadata);
+            await writeJson(join(this.mainConversationArchiveDir(conversation.id), "meta.json"), next);
+            await this.appendEvent(main, archived ? "main.conversation_archived" : "main.conversation_unarchived", archived
+                ? `Archived ${conversation.id ?? "legacy conversation"}`
+                : `Unarchived ${conversation.id ?? "legacy conversation"}`);
+            return this.requireMainConversationSummary(conversation.id);
+        });
+    }
+    async deleteMainConversation(conversationId) {
+        await this.withMainConversationManagementLease(conversationId, "delete", async (main, conversation) => {
+            if (conversation.current) {
+                throw new Error("Cannot delete the current Main conversation. Restore another conversation first.");
+            }
+            const staging = await mkdtemp(join(main.dir, ".conversation-delete-"));
+            const chatPath = join(main.dir, "chat.jsonl");
+            const replacementPath = join(staging, "chat.next.jsonl");
+            const originalPath = join(staging, "chat.original.jsonl");
+            const archivePath = this.mainConversationArchiveDir(conversation.id);
+            const stagedArchivePath = join(staging, "archive");
+            let archiveMoved = false;
+            let originalMoved = false;
+            let replacementInstalled = false;
+            try {
+                await writeConversationChatFile(chatPath, replacementPath, conversation.id, "exclude");
+                if (await pathExists(archivePath)) {
+                    await rename(archivePath, stagedArchivePath);
+                    archiveMoved = true;
+                }
+                if (await pathExists(chatPath)) {
+                    await rename(chatPath, originalPath);
+                    originalMoved = true;
+                }
+                await rename(replacementPath, chatPath);
+                replacementInstalled = true;
+                await this.appendEvent(main, "main.conversation_deleted", `Deleted ${conversation.id ?? "legacy conversation"}`);
+            }
+            catch (error) {
+                const rollbackErrors = [];
+                if (replacementInstalled) {
+                    try {
+                        await removeIfExists(chatPath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                if (originalMoved) {
+                    try {
+                        await rename(originalPath, chatPath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                if (archiveMoved) {
+                    try {
+                        await rename(stagedArchivePath, archivePath);
+                    }
+                    catch (rollbackError) {
+                        rollbackErrors.push(rollbackError);
+                    }
+                }
+                await rm(staging, { force: true, recursive: true }).catch(() => undefined);
+                if (rollbackErrors.length > 0) {
+                    throw new Error(`Main conversation deletion failed and rollback also failed: ${errorMessage(error)}`, { cause: new AggregateError([error, ...rollbackErrors]) });
+                }
+                throw error;
+            }
+            await rm(staging, { force: true, recursive: true }).catch(() => undefined);
+        });
+    }
+    async exportMainConversation(conversationId) {
+        return this.withMainConversationManagementLease(conversationId, "export", async (main, conversation) => {
+            const createdAt = this.now().toISOString();
+            const exportsRoot = join(this.projectRoot, this.dataDir, "exports");
+            await ensureDir(exportsRoot);
+            const scope = conversation.id ?? "main-legacy";
+            const staging = await mkdtemp(join(exportsRoot, `.${scope}-`));
+            const suffix = basename(staging).slice(-6);
+            const stamp = createdAt.replace(/[^0-9]/g, "").slice(0, 14);
+            const destination = join(exportsRoot, `${scope}-${stamp}-${suffix}`);
+            try {
+                const messageCount = await writeConversationChatFile(join(main.dir, "chat.jsonl"), join(staging, "chat.jsonl"), conversation.id, "include");
+                const nativeSessions = await this.mainConversationNativeSessions(conversation.id, conversation.current);
+                for (const session of nativeSessions) {
+                    await writeJson(join(staging, "native-sessions", `${session.worker_id}.json`), session);
+                }
+                await writeJson(join(staging, "manifest.json"), {
+                    format: "parallel-codex-main-conversation-export-v1",
+                    exported_at: createdAt,
+                    source_workspace: this.projectRoot,
+                    conversation: {
+                        id: conversation.id,
+                        title: conversation.title,
+                        created_at: conversation.createdAt,
+                        last_activity_at: conversation.lastActivityAt,
+                        ...(conversation.archivedAt ? { archived_at: conversation.archivedAt } : {})
+                    },
+                    message_count: messageCount,
+                    native_session_count: nativeSessions.length
+                });
+                await this.appendEvent(main, "main.conversation_exported", `Exported ${conversation.id ?? "legacy conversation"}`);
+                await rename(staging, destination);
+            }
+            catch (error) {
+                await rm(staging, { force: true, recursive: true });
+                throw error;
+            }
+            return { conversationId: conversation.id, path: destination, createdAt };
+        });
+    }
     async reconcileInterruptedMainSession() {
         const main = this.taskFromId("main");
         if (!(await pathExists(main.dir))) {
@@ -924,6 +1071,24 @@ export class SessionManager {
         await this.clearWorkerStatusNativeSession(worker);
         await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), record.worker_id);
     }
+    async mainConversationArchiveMetadata(conversation) {
+        const existing = await readMainConversationArchiveIfValid(join(this.mainConversationArchiveDir(conversation.id), "meta.json"));
+        return MainConversationArchiveSchema.parse({
+            ...existing,
+            version: 1,
+            id: conversation.id,
+            created_at: existing?.created_at ?? conversation.createdAt,
+            last_activated_at: existing?.last_activated_at ?? conversation.lastActivityAt
+        });
+    }
+    async requireMainConversationSummary(conversationId) {
+        const conversation = (await this.listMainConversations(500, { includeArchived: true }))
+            .find((entry) => entry.id === conversationId);
+        if (!conversation) {
+            throw new Error(`Main conversation disappeared from its catalog: ${conversationId ?? "legacy"}`);
+        }
+        return conversation;
+    }
     mainConversationArchiveDir(conversationId) {
         return join(this.mainSessionDir(), MAIN_CONVERSATION_ARCHIVE_DIRECTORY, mainConversationScopeKey(conversationId));
     }
@@ -949,6 +1114,7 @@ export class SessionManager {
         const path = join(this.mainConversationArchiveDir(parsed.id), "meta.json");
         const existing = await readMainConversationArchiveIfValid(path);
         await writeJson(path, MainConversationArchiveSchema.parse({
+            ...existing,
             ...parsed,
             created_at: existing && existing.created_at < parsed.created_at
                 ? existing.created_at
@@ -1045,6 +1211,39 @@ export class SessionManager {
         }
         return ids;
     }
+    async mainConversationNativeSessions(conversationId, includeActive) {
+        const sessions = new Map();
+        const archiveDir = join(this.mainConversationArchiveDir(conversationId), "native-sessions");
+        if (await pathExists(archiveDir)) {
+            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"
+                    && safeMainWorkerId(record.worker_id)
+                    && entry.name === `${record.worker_id}.json`) {
+                    sessions.set(record.worker_id, record);
+                }
+            }
+        }
+        if (includeActive) {
+            const mainDir = this.mainSessionDir();
+            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"
+                    && safeMainWorkerId(record.worker_id)) {
+                    sessions.set(record.worker_id, record);
+                }
+            }
+        }
+        return [...sessions.values()].sort((left, right) => left.worker_id.localeCompare(right.worker_id));
+    }
     async appendEvent(task, type, message) {
         const event = {
             time: this.now().toISOString(),
@@ -1069,6 +1268,20 @@ export class SessionManager {
             return run(task, meta);
         });
     }
+    async withMainConversationManagementLease(conversationId, operation, run) {
+        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 ${operation}`, lease, async () => {
+            const conversation = (await this.listMainConversations(500, { includeArchived: true }))
+                .find((entry) => entry.id === id);
+            if (!conversation) {
+                throw new Error(`Main conversation not found: ${id ?? "legacy"}`);
+            }
+            return run(main, conversation);
+        });
+    }
     assertTerminalTask(meta, operation) {
         if (!TERMINAL_TASK_STATES.has(meta.status)) {
             throw new Error(`Cannot ${operation} task ${meta.id} while it is ${meta.status}.`);
@@ -1620,6 +1833,10 @@ function nextConversationId(baseId, previousId) {
 function mainConversationScopeKey(conversationId) {
     return conversationId ?? LEGACY_MAIN_CONVERSATION_DIRECTORY;
 }
+function withoutMainConversationArchiveTime(metadata) {
+    const { archived_at: _archivedAt, ...active } = metadata;
+    return MainConversationArchiveSchema.parse(active);
+}
 function mainConversationTitle(text, conversationId) {
     const sanitized = sanitizePersistedMainMessage("user", text)
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
@@ -1634,9 +1851,75 @@ function mainConversationTitle(text, conversationId) {
         ? `${characters.slice(0, 77).join("")}...`
         : sanitized;
 }
+function normalizeMainConversationTitle(title) {
+    const normalized = title
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized) {
+        throw new Error("Main conversation title cannot be empty.");
+    }
+    if (Array.from(normalized).length > 160) {
+        throw new Error("Main conversation title cannot exceed 160 characters.");
+    }
+    return normalized;
+}
 function safeMainWorkerId(workerId) {
     return SAFE_MAIN_WORKER_ID.test(workerId) && workerId !== "." && workerId !== "..";
 }
+async function writeConversationChatFile(sourcePath, destinationPath, conversationId, mode) {
+    await ensureDir(dirname(destinationPath));
+    const output = await open(destinationPath, "wx");
+    let matched = 0;
+    let buffer = "";
+    try {
+        if (!(await pathExists(sourcePath))) {
+            await output.close();
+            return 0;
+        }
+        const input = createReadStream(sourcePath, { encoding: "utf8" });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        for await (const line of lines) {
+            const belongs = chatLineBelongsToMainConversation(line, conversationId);
+            if (belongs) {
+                matched += 1;
+            }
+            if ((mode === "include") !== belongs) {
+                continue;
+            }
+            buffer += `${line}\n`;
+            if (Buffer.byteLength(buffer, "utf8") >= 64 * 1024) {
+                await output.write(buffer);
+                buffer = "";
+            }
+        }
+        if (buffer) {
+            await output.write(buffer);
+        }
+        await output.close();
+        return matched;
+    }
+    catch (error) {
+        await output.close().catch(() => undefined);
+        await removeIfExists(destinationPath).catch(() => undefined);
+        throw error;
+    }
+}
+function chatLineBelongsToMainConversation(line, conversationId) {
+    try {
+        const parsed = ChatRecordSchema.safeParse(JSON.parse(line));
+        if (!parsed.success || parsed.data.task_id) {
+            return false;
+        }
+        return conversationId
+            ? parsed.data.conversation_id === conversationId
+            : !parsed.data.conversation_id;
+    }
+    catch {
+        return false;
+    }
+}
 function normalizeTaskTitle(title) {
     const normalized = title
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")

package/dist/domain/schemas.js

@@ -209,7 +209,9 @@ export const MainConversationArchiveSchema = z.object({
     version: z.literal(1),
     id: ConversationIdSchema.nullable(),
     created_at: z.string().datetime(),
-    last_activated_at: z.string().datetime()
+    last_activated_at: z.string().datetime(),
+    title: z.string().min(1).max(160).optional(),
+    archived_at: z.string().datetime().optional()
 });
 export const ChatRecordSchema = z.object({
     time: z.string().datetime(),

package/dist/tui/App.js

@@ -50,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, loadMainConversations, activateMainConversation, 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, renameMainConversation, setMainConversationArchived, deleteMainConversation, exportMainConversation, loadTaskSessionDetails, renameTaskSession, setTaskSessionArchived, deleteTaskSession, exportTaskSession, exportDiagnostics, loadCollaborationTimeline, activateTaskSession, startMainConversation, prepareNativeAttach, prepareNativeFork, startNativeAttach, copyToClipboard = copyTextToClipboard, shutdownSignal }) {
     configureTuiTheme({
         theme: config.ui.theme,
         colors: config.ui.colors
@@ -101,6 +101,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const [sessionCenterMode, setSessionCenterMode] = useState("tasks");
     const [mainConversations, setMainConversations] = useState([]);
     const [selectedMainConversationIndex, setSelectedMainConversationIndex] = useState(0);
+    const [mainConversationsIncludeArchived, setMainConversationsIncludeArchived] = useState(false);
+    const [mainConversationAction, setMainConversationAction] = useState(null);
     const [taskSessionsLoading, setTaskSessionsLoading] = useState(false);
     const [taskSessionsError, setTaskSessionsError] = useState(null);
     const [taskSessionsNotice, setTaskSessionsNotice] = useState(null);
@@ -156,6 +158,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const sessionCenterModeRef = useRef("tasks");
     const mainConversationsRef = useRef(mainConversations);
     const selectedMainConversationIndexRef = useRef(selectedMainConversationIndex);
+    const mainConversationsIncludeArchivedRef = useRef(mainConversationsIncludeArchived);
+    const mainConversationActionRef = useRef(mainConversationAction);
     const taskSessionsLoadingRef = useRef(taskSessionsLoading);
     const taskSessionsIncludeArchivedRef = useRef(taskSessionsIncludeArchived);
     const taskSessionActionRef = useRef(taskSessionAction);
@@ -188,7 +192,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     const activateSelectedTaskSessionRef = useRef(activateSelectedTaskSession);
     const refreshTaskSessionsRef = useRef(refreshTaskSessions);
     const openMainConversationsRef = useRef(openMainConversations);
+    const refreshMainConversationsRef = useRef(refreshMainConversations);
     const restoreSelectedMainConversationRef = useRef(restoreSelectedMainConversation);
+    const renameSelectedMainConversationRef = useRef(renameSelectedMainConversation);
+    const archiveSelectedMainConversationRef = useRef(archiveSelectedMainConversation);
+    const deleteSelectedMainConversationRef = useRef(deleteSelectedMainConversation);
+    const exportSelectedMainConversationRef = useRef(exportSelectedMainConversation);
     const renameSelectedTaskSessionRef = useRef(renameSelectedTaskSession);
     const archiveSelectedTaskSessionRef = useRef(archiveSelectedTaskSession);
     const deleteSelectedTaskSessionRef = useRef(deleteSelectedTaskSession);
@@ -352,6 +361,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     useEffect(() => {
         selectedMainConversationIndexRef.current = selectedMainConversationIndex;
     }, [selectedMainConversationIndex]);
+    useEffect(() => {
+        mainConversationsIncludeArchivedRef.current = mainConversationsIncludeArchived;
+    }, [mainConversationsIncludeArchived]);
+    useEffect(() => {
+        mainConversationActionRef.current = mainConversationAction;
+    }, [mainConversationAction]);
     useEffect(() => {
         taskSessionsLoadingRef.current = taskSessionsLoading;
     }, [taskSessionsLoading]);
@@ -424,7 +439,12 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         activateSelectedTaskSessionRef.current = activateSelectedTaskSession;
         refreshTaskSessionsRef.current = refreshTaskSessions;
         openMainConversationsRef.current = openMainConversations;
+        refreshMainConversationsRef.current = refreshMainConversations;
         restoreSelectedMainConversationRef.current = restoreSelectedMainConversation;
+        renameSelectedMainConversationRef.current = renameSelectedMainConversation;
+        archiveSelectedMainConversationRef.current = archiveSelectedMainConversation;
+        deleteSelectedMainConversationRef.current = deleteSelectedMainConversation;
+        exportSelectedMainConversationRef.current = exportSelectedMainConversation;
         renameSelectedTaskSessionRef.current = renameSelectedTaskSession;
         archiveSelectedTaskSessionRef.current = archiveSelectedTaskSession;
         deleteSelectedTaskSessionRef.current = deleteSelectedTaskSession;
@@ -875,7 +895,41 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                     return;
                 }
                 if (sessionCenterModeRef.current === "conversations") {
+                    const conversationAction = mainConversationActionRef.current;
+                    if (conversationAction) {
+                        if (chunk === "\x1b") {
+                            updateMainConversationAction(null);
+                            setTaskSessionsError(null);
+                            return;
+                        }
+                        if (taskSessionsLoadingRef.current) {
+                            return;
+                        }
+                        if (conversationAction.type === "rename") {
+                            const update = applyChatInputChunk(conversationAction.value, chunk, conversationAction.cursor);
+                            if (update.submit !== null) {
+                                void renameSelectedMainConversationRef.current({
+                                    ...conversationAction,
+                                    value: update.submit,
+                                    cursor: Array.from(update.submit).length
+                                });
+                            }
+                            else {
+                                updateMainConversationAction({
+                                    ...conversationAction,
+                                    value: update.value,
+                                    cursor: update.cursor
+                                });
+                            }
+                            return;
+                        }
+                        if (chunk === "d" || chunk === "D") {
+                            void deleteSelectedMainConversationRef.current(conversationAction);
+                        }
+                        return;
+                    }
                     if (isTaskSessionsShortcut(chunk, {}) || chunk === "\x1b") {
+                        updateMainConversationAction(null);
                         setTaskSessionsError(null);
                         setTaskSessionsNotice(null);
                         viewRef.current = taskSessionsReturnViewRef.current;
@@ -890,6 +944,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                         return;
                     }
                     if (chunk === "t" || chunk === "T") {
+                        updateMainConversationAction(null);
                         sessionCenterModeRef.current = "tasks";
                         setSessionCenterMode("tasks");
                         setTaskSessionsError(null);
@@ -901,6 +956,63 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
                         void openMainConversationsRef.current();
                         return;
                     }
+                    const selectedConversation = mainConversationsRef.current[selectedMainConversationIndexRef.current];
+                    if (chunk === "r" || chunk === "R") {
+                        if (selectedConversation) {
+                            updateMainConversationAction({
+                                type: "rename",
+                                conversationId: selectedConversation.id,
+                                title: selectedConversation.title,
+                                value: selectedConversation.title,
+                                cursor: Array.from(selectedConversation.title).length
+                            });
+                            setTaskSessionsError(null);
+                            setTaskSessionsNotice(null);
+                        }
+                        return;
+                    }
+                    if (chunk === "a" || chunk === "A") {
+                        void archiveSelectedMainConversationRef.current();
+                        return;
+                    }
+                    if (chunk === "d" || chunk === "D") {
+                        if (selectedConversation) {
+                            if (selectedConversation.current) {
+                                setTaskSessionsError("Restore another Main conversation before deleting the current one");
+                            }
+                            else {
+                                updateMainConversationAction({
+                                    type: "delete",
+                                    conversationId: selectedConversation.id,
+                                    title: selectedConversation.title
+                                });
+                                setTaskSessionsError(null);
+                                setTaskSessionsNotice(null);
+                            }
+                        }
+                        return;
+                    }
+                    if (chunk === "e" || chunk === "E") {
+                        void exportSelectedMainConversationRef.current();
+                        return;
+                    }
+                    if (chunk === "h" || chunk === "H") {
+                        const includeArchived = !mainConversationsIncludeArchivedRef.current;
+                        mainConversationsIncludeArchivedRef.current = includeArchived;
+                        setMainConversationsIncludeArchived(includeArchived);
+                        setTaskSessionsError(null);
+                        setTaskSessionsNotice(null);
+                        void (async () => {
+                            await refreshMainConversationsRef.current(selectedConversation?.id);
+                            if (sessionCenterModeRef.current === "conversations"
+                                && mainConversationsIncludeArchivedRef.current === includeArchived) {
+                                setTaskSessionsNotice(includeArchived
+                                    ? "Archived conversations shown"
+                                    : "Archived conversations hidden");
+                            }
+                        })();
+                        return;
+                    }
                     if (chunk === "\r" || chunk === "\n") {
                         void restoreSelectedMainConversationRef.current();
                         return;
@@ -2285,6 +2397,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         setTaskSessionDetailSelectedWorkerIndex(0);
         setTaskSessionDetailNotice(null);
         updateTaskSessionAction(null);
+        updateMainConversationAction(null);
         sessionCenterModeRef.current = "tasks";
         setSessionCenterMode("tasks");
         await refreshTaskSessions(activeTaskIdRef.current);
@@ -2347,24 +2460,32 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
         taskSessionDetailsRef.current = null;
         setTaskSessionDetails(null);
         updateTaskSessionAction(null);
+        updateMainConversationAction(null);
         setTaskSessionsError(null);
         setTaskSessionsNotice(null);
-        taskSessionsLoadingRef.current = true;
-        setTaskSessionsLoading(true);
+        await refreshMainConversations(previousId);
+    }
+    async function refreshMainConversations(preferredConversationId, manageLoading = true) {
+        if (manageLoading) {
+            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();
+            const conversations = await loadMainConversations({
+                includeArchived: mainConversationsIncludeArchivedRef.current
+            });
             if (taskSessionsLoadSequenceRef.current !== sequence) {
                 return;
             }
             mainConversationsRef.current = conversations;
             setMainConversations(conversations);
-            const preservedIndex = previousId !== undefined
-                ? conversations.findIndex((conversation) => conversation.id === previousId)
+            const preservedIndex = preferredConversationId !== undefined
+                ? conversations.findIndex((conversation) => conversation.id === preferredConversationId)
                 : -1;
             const currentIndex = conversations.findIndex((conversation) => conversation.current);
             const selectedIndex = preservedIndex >= 0
@@ -2381,7 +2502,7 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             }
         }
         finally {
-            if (taskSessionsLoadSequenceRef.current === sequence) {
+            if (manageLoading && taskSessionsLoadSequenceRef.current === sequence) {
                 taskSessionsLoadingRef.current = false;
                 setTaskSessionsLoading(false);
             }
@@ -2405,8 +2526,8 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             }
             const result = await activateMainConversation(selected.id);
             if (!result.changed) {
-                await openMainConversations();
                 setTaskSessionsNotice(`Already current · ${result.conversation.title}`);
+                await refreshMainConversations(result.conversation.id, false);
                 return;
             }
             await activateTaskSession?.(null);
@@ -2424,6 +2545,79 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
             setTaskSessionsLoading(false);
         }
     }
+    function updateMainConversationAction(next) {
+        mainConversationActionRef.current = next;
+        setMainConversationAction(next);
+    }
+    async function runMainConversationOperation(run, notice, preferredConversationId) {
+        if (taskSessionsLoadingRef.current) {
+            return;
+        }
+        taskSessionsLoadingRef.current = true;
+        setTaskSessionsLoading(true);
+        setTaskSessionsError(null);
+        setTaskSessionsNotice(null);
+        try {
+            const result = await run();
+            updateMainConversationAction(null);
+            await refreshMainConversations(preferredConversationId, false);
+            taskSessionsLoadingRef.current = false;
+            setTaskSessionsLoading(false);
+            setTaskSessionsNotice(typeof notice === "function" ? notice(result) : notice);
+        }
+        catch (error) {
+            taskSessionsLoadingRef.current = false;
+            setTaskSessionsLoading(false);
+            setTaskSessionsError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            taskSessionsLoadingRef.current = false;
+            setTaskSessionsLoading(false);
+        }
+    }
+    async function renameSelectedMainConversation(action) {
+        await runMainConversationOperation(async () => {
+            if (!renameMainConversation) {
+                throw new Error("Main conversation rename is unavailable");
+            }
+            const title = action.value.trim();
+            await renameMainConversation(action.conversationId, title);
+            return title;
+        }, (title) => `Renamed · ${title}`, action.conversationId);
+    }
+    async function archiveSelectedMainConversation() {
+        const selected = mainConversationsRef.current[selectedMainConversationIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        const archived = !selected.archivedAt;
+        await runMainConversationOperation(async () => {
+            if (!setMainConversationArchived) {
+                throw new Error("Main conversation archive is unavailable");
+            }
+            await setMainConversationArchived(selected.id, archived);
+        }, archived ? `Archived · ${selected.title}` : `Unarchived · ${selected.title}`, selected.id);
+    }
+    async function deleteSelectedMainConversation(action) {
+        await runMainConversationOperation(async () => {
+            if (!deleteMainConversation) {
+                throw new Error("Main conversation deletion is unavailable");
+            }
+            await deleteMainConversation(action.conversationId);
+        }, `Deleted · ${action.title}`);
+    }
+    async function exportSelectedMainConversation() {
+        const selected = mainConversationsRef.current[selectedMainConversationIndexRef.current];
+        if (!selected) {
+            return;
+        }
+        await runMainConversationOperation(async () => {
+            if (!exportMainConversation) {
+                throw new Error("Main conversation export is unavailable");
+            }
+            return exportMainConversation(selected.id);
+        }, (path) => `Exported · ${path}`, selected.id);
+    }
     function updateTaskSessionAction(next) {
         taskSessionActionRef.current = next;
         setTaskSessionAction(next);
@@ -2907,15 +3101,27 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, initialRo
     if (view === "workspace") {
         return (_jsx(Box, { flexDirection: "column", height: terminalSize.rows, children: _jsx(WorkspacePicker, { cwd: cwd, choices: workspaceChoices, terminalHeight: terminalSize.rows, terminalWidth: terminalWidth, onCancel: closeWorkspacePicker, onSelect: (workspace) => void selectWorkspace(workspace) }) }));
     }
-    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary, configChange?.compact].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), taskSessionAction: taskSessionAction?.type === "rename"
-                ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
-                : taskSessionAction?.type === "delete"
-                    ? { type: "delete", title: taskSessionAction.title }
-                    : 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"
+    return (_jsx(AppShell, { view: view, cwd: cwd, taskId: activeTaskId, statusText: [visibleTaskStatus, visibleRouteSummary, configChange?.compact].filter(Boolean).join(" | "), contentHeight: contentHeight, showStatusBar: config.ui.showStatusBar, input: _jsx(InputBar, { mode: view === "worker" && workerSearch.open ? "worker-search" : view, ready: inputReady, busy: busy, routeFallback: Boolean(routeFallbackPrompt), collaborationDetail: collaborationDetailOpen, collaborationUnresolved: collaborationUnresolvedOnly, collaborationBack: collaborationReturnViewRef.current, featureCanCancel: featureCanCancel, featureCanPause: featureCanCancel, featureCanReassign: featureCanReassign, featureCancelConfirm: featureCancelPrompt?.action === "cancel", featurePauseConfirm: featureCancelPrompt?.action === "pause", featureAssignment: Boolean(featureAssignmentPrompt), taskSessionAction: sessionCenterMode === "conversations"
+                ? mainConversationAction?.type === "rename"
+                    ? { type: "rename", value: mainConversationAction.value, cursor: mainConversationAction.cursor }
+                    : mainConversationAction?.type === "delete"
+                        ? { type: "delete", title: mainConversationAction.title }
+                        : null
+                : taskSessionAction?.type === "rename"
+                    ? { type: "rename", value: taskSessionAction.value, cursor: taskSessionAction.cursor }
+                    : taskSessionAction?.type === "delete"
+                        ? { type: "delete", title: taskSessionAction.title }
+                        : null, taskSessionsIncludeArchived: sessionCenterMode === "conversations"
+                ? mainConversationsIncludeArchived
+                : 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 })) : 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"
+                : 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, includeArchived: mainConversationsIncludeArchived, notice: taskSessionsNotice, action: mainConversationAction?.type === "rename"
+                ? { type: "rename", title: mainConversationAction.title }
+                : mainConversationAction?.type === "delete"
+                    ? { type: "delete", title: mainConversationAction.title }
+                    : null, 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

@@ -40,7 +40,7 @@ export function InputBar({ mode, ready = true, busy = false, routeFallback = fal
             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);
+            const hints = mainConversationSessionsInputHints(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] }));
         }
         const hints = taskSessionsInputHints(terminalWidth, taskSessionsIncludeArchived);
@@ -588,8 +588,14 @@ function taskSessionsInputHints(width, includeArchived) {
         { label: "s", detail: "" }
     ]);
 }
-function mainConversationSessionsInputHints(width) {
+export function mainConversationSessionsInputHints(width, includeArchived) {
+    const archivedAction = includeArchived ? "H hide archived" : "H archived";
     return selectInputHints(width, [
+        { label: "conversations", detail: ` · Up/Dn select · Enter restore · R rename · A archive · D delete · E export · ${archivedAction} · N new · T tasks · Esc back` },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · R rename · A archive · D delete · E export · N new · T tasks · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · R rename · A archive · D delete · N new · T tasks · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · R rename · A archive · N new · T tasks · Esc back" },
+        { label: "conversations", detail: " · Up/Dn select · Enter restore · R rename · N new · T tasks · Esc back" },
         { 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" },

package/dist/tui/MainConversationsView.js

@@ -2,10 +2,10 @@ 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 }) {
+export function MainConversationsView({ conversations, selectedIndex, includeArchived = false, notice = null, action = 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 lines = mainConversationsDisplayLines(conversations, selectedIndex, viewportHeight, terminalWidth, { includeArchived, notice, action, 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}`)))] }));
 }
@@ -13,15 +13,26 @@ export function mainConversationsDisplayLines(conversations, selectedIndex, heig
     const viewportHeight = Math.max(1, Math.trunc(height));
     const width = mainConversationsContentWidth(terminalWidth);
     const lines = [{
-            text: fitMainConversationCandidates(["Main conversations", "Conversations", "Chats", "C"], width),
+            text: fitMainConversationCandidates([
+                state.includeArchived ? "Main conversations · archived shown" : "Main conversations",
+                state.includeArchived ? "Conversations · all" : "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);
+        const archived = conversations.filter((conversation) => conversation.archivedAt).length;
         lines.push({
             text: fitMainConversationCandidates([
-                `${conversations.length} ${conversations.length === 1 ? "conversation" : "conversations"} · ${messages} messages · ${nativeSessions} native`,
+                [
+                    `${conversations.length} ${conversations.length === 1 ? "conversation" : "conversations"}`,
+                    `${messages} messages`,
+                    `${nativeSessions} native`,
+                    ...(archived > 0 ? [`${archived} archived`] : [])
+                ].join(" · "),
                 `${conversations.length} conversations · ${messages} messages`,
                 `${conversations.length} conversations`,
                 `${conversations.length} chats`
@@ -29,7 +40,15 @@ export function mainConversationsDisplayLines(conversations, selectedIndex, heig
             tone: "muted"
         });
     }
-    if (viewportHeight >= 4 && state.notice) {
+    if (viewportHeight >= 4 && state.action) {
+        lines.push({
+            text: fitMainConversationText(state.action.type === "rename"
+                ? `rename · ${safeMainConversationText(state.action.title)} · Enter save · Esc cancel`
+                : `delete · ${safeMainConversationText(state.action.title)} · press D again · Esc cancel`, width),
+            tone: state.action.type === "delete" ? "danger" : "active"
+        });
+    }
+    else if (viewportHeight >= 4 && state.notice) {
         lines.push({ text: fitMainConversationText(state.notice, width), tone: "success" });
     }
     const slots = Math.max(0, viewportHeight - lines.length);
@@ -88,14 +107,15 @@ function mainConversationRowText(conversation, selected, width) {
     const title = safeMainConversationText(conversation.title);
     const messages = `${conversation.messageCount} ${conversation.messageCount === 1 ? "message" : "messages"}`;
     const native = `${conversation.nativeSessionCount} native`;
+    const status = conversation.archivedAt ? "archived" : null;
     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, status, messages, native, date].filter(Boolean).join(" · "),
+        [marker + title, status, messages, native].filter(Boolean).join(" · "),
+        [marker + title, status, messages].filter(Boolean).join(" · "),
         [marker + title, date].join(" · "),
         [marker + scope, messages].join(" · "),
         marker.trimEnd()

package/dist/version.js

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

package/package.json

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