parallel-codex-tui 0.2.8 → 0.2.10

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";
@@ -11,7 +13,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 +44,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 +185,99 @@ export class SessionManager {
         }
         return readJson(path, MainConversationStateSchema);
     }
+    async listMainConversations(limit = 100, options = {}) {
+        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) {
+            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;
+            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()]
+            .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);
+    }
     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 +286,198 @@ 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, { 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) {
+                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 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))) {
@@ -803,6 +1071,179 @@ 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));
+    }
+    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({
+            ...existing,
+            ...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 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(),
@@ -827,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}.`);
@@ -1375,6 +1830,96 @@ function nextConversationId(baseId, previousId) {
         ? `${baseId}-${suffix + 1}`
         : `${baseId}-2`;
 }
+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, "")
+        .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 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, "")
@@ -1486,6 +2031,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,14 @@ 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(),
+    title: z.string().min(1).max(160).optional(),
+    archived_at: z.string().datetime().optional()
+});
 export const ChatRecordSchema = z.object({
     time: z.string().datetime(),
     from: z.enum(["user", "system"]),