parallel-codex-tui 0.1.0 → 0.1.3

package/dist/core/session-index.js

@@ -121,10 +121,19 @@ export class SessionIndex {
            source=excluded.source`)
             .run(taskId, record.worker_id, record.engine, record.role, record.session_id, record.cwd, record.created_at, record.last_used_at, record.source);
     }
+    async deleteNativeSession(taskId, workerId) {
+        this.db.prepare("DELETE FROM native_sessions WHERE task_id = ? AND worker_id = ?").run(taskId, workerId);
+    }
     async countRows(table) {
         const row = this.db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get();
         return row.count;
     }
+    async workerNativeSessionId(taskId, workerId) {
+        const row = this.db
+            .prepare("SELECT native_session_id FROM workers WHERE task_id = ? AND worker_id = ?")
+            .get(taskId, workerId);
+        return row?.native_session_id ?? null;
+    }
     async rebuildFromFiles() {
         this.db.exec("DELETE FROM native_sessions; DELETE FROM workers; DELETE FROM turns; DELETE FROM tasks;");
         const sessions = join(this.projectRoot, this.dataDir, "sessions");
@@ -145,7 +154,10 @@ export class SessionIndex {
     async rebuildTask(taskDir, taskId) {
         const metaPath = join(taskDir, "meta.json");
         if (await pathExists(metaPath)) {
-            await this.upsertTask(await readJson(metaPath, TaskMetaSchema));
+            const meta = await readJsonIfValid(metaPath, TaskMetaSchema);
+            if (meta) {
+                await this.upsertTask(meta);
+            }
         }
         const turnsDir = join(taskDir, "turns");
         if (await pathExists(turnsDir)) {
@@ -153,7 +165,10 @@ export class SessionIndex {
             for (const turnEntry of turnEntries) {
                 const turnPath = join(turnsDir, turnEntry.name, "turn.json");
                 if (turnEntry.isDirectory() && (await pathExists(turnPath))) {
-                    await this.upsertTurn(taskId, await readJson(turnPath, TurnMetaSchema));
+                    const turn = await readJsonIfValid(turnPath, TurnMetaSchema);
+                    if (turn) {
+                        await this.upsertTurn(taskId, turn);
+                    }
                 }
             }
         }
@@ -164,17 +179,46 @@ export class SessionIndex {
             }
             const workerDir = join(taskDir, entry.name);
             const statusPath = join(workerDir, "status.json");
+            const nativePath = join(workerDir, "native-session.json");
             if (await pathExists(statusPath)) {
-                await this.upsertWorker(taskId, await readJson(statusPath, WorkerStatusSchema), {
-                    dir: workerDir,
-                    statusPath,
-                    outputLogPath: join(workerDir, "output.log")
-                });
+                const status = await this.readRebuildWorkerStatus(statusPath, nativePath);
+                if (status) {
+                    await this.upsertWorker(taskId, status, {
+                        dir: workerDir,
+                        statusPath,
+                        outputLogPath: join(workerDir, "output.log")
+                    });
+                }
             }
-            const nativePath = join(workerDir, "native-session.json");
             if (await pathExists(nativePath)) {
-                await this.upsertNativeSession(taskId, await readJson(nativePath, NativeSessionSchema));
+                const nativeSession = await readJsonIfValid(nativePath, NativeSessionSchema);
+                if (nativeSession) {
+                    await this.upsertNativeSession(taskId, nativeSession);
+                }
             }
         }
     }
+    async readRebuildWorkerStatus(statusPath, nativePath) {
+        const status = await readJsonIfValid(statusPath, WorkerStatusSchema);
+        if (!status) {
+            return null;
+        }
+        if (status.native_session_id && !(await readJsonIfValid(nativePath, NativeSessionSchema))) {
+            const nextStatus = { ...status };
+            delete nextStatus.native_session_id;
+            return WorkerStatusSchema.parse(nextStatus);
+        }
+        return status;
+    }
+}
+async function readJsonIfValid(path, schema) {
+    if (!(await pathExists(path))) {
+        return null;
+    }
+    try {
+        return await readJson(path, schema);
+    }
+    catch {
+        return null;
+    }
 }

package/dist/core/session-manager.js

@@ -3,7 +3,7 @@ import { basename, dirname, join } from "node:path";
 import { appendJsonLine, ensureDir, pathExists, readJson, readTextIfExists, removeIfExists, writeJson, writeText } from "./file-store.js";
 import { formatTaskTimestamp, taskDir } from "./paths.js";
 import { sessionsRoot } from "./paths.js";
-import { NativeSessionSchema, RouteDecisionSchema, TaskMetaSchema, TurnMetaSchema } from "../domain/schemas.js";
+import { NativeSessionSchema, RouteDecisionSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
 export class SessionManager {
     projectRoot;
     dataDir;
@@ -57,6 +57,10 @@ export class SessionManager {
             eventsPath: join(dir, "events.jsonl")
         };
     }
+    async hasTask(taskId) {
+        const task = this.taskFromId(taskId);
+        return Boolean(await readTaskMetaIfValid(task.metaPath));
+    }
     async latestTask() {
         const root = sessionsRoot(this.projectRoot, this.dataDir);
         if (!(await pathExists(root))) {
@@ -70,7 +74,10 @@ export class SessionManager {
             }
             const metaPath = join(root, entry.name, "meta.json");
             if (await pathExists(metaPath)) {
-                const meta = await readJson(metaPath, TaskMetaSchema);
+                const meta = await readTaskMetaIfValid(metaPath);
+                if (!meta) {
+                    continue;
+                }
                 if (meta.mode === "complex") {
                     tasks.push(meta);
                 }
@@ -159,7 +166,15 @@ export class SessionManager {
         if (!(await pathExists(path))) {
             return null;
         }
-        return readJson(path, NativeSessionSchema);
+        try {
+            return await readJson(path, NativeSessionSchema);
+        }
+        catch {
+            await removeIfExists(path);
+            await this.clearWorkerStatusNativeSession(worker);
+            await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), this.workerIdFromWorkerDir(worker.dir));
+            return null;
+        }
     }
     async writeNativeSession(worker, record) {
         await writeJson(join(worker.dir, "native-session.json"), NativeSessionSchema.parse(record));
@@ -170,13 +185,21 @@ export class SessionManager {
         if (!(await pathExists(nativeSessionPath))) {
             return;
         }
-        const record = await readJson(nativeSessionPath, NativeSessionSchema);
+        const record = await readNativeSessionIfValid(nativeSessionPath);
+        if (!record) {
+            await removeIfExists(nativeSessionPath);
+            await this.clearWorkerStatusNativeSession(worker);
+            await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), this.workerIdFromWorkerDir(worker.dir));
+            return;
+        }
         await writeJson(join(worker.dir, "native-session.retired.json"), {
             ...record,
             retired_at: this.now().toISOString(),
             retired_reason: reason
         });
         await removeIfExists(nativeSessionPath);
+        await this.clearWorkerStatusNativeSession(worker);
+        await this.index?.deleteNativeSession(this.taskIdFromWorkerDir(worker.dir), record.worker_id);
     }
     async appendEvent(task, type, message) {
         const event = {
@@ -198,7 +221,10 @@ export class SessionManager {
         if (!this.index || !(await pathExists(task.metaPath))) {
             return;
         }
-        await this.index.upsertTask(await readJson(task.metaPath, TaskMetaSchema));
+        const meta = await readTaskMetaIfValid(task.metaPath);
+        if (meta) {
+            await this.index.upsertTask(meta);
+        }
     }
     async backfillInitialTurn(task, fallbackRoute) {
         const firstTurn = this.turnFiles(task, "0001");
@@ -213,10 +239,8 @@ export class SessionManager {
         if (!request) {
             return;
         }
-        const route = (await pathExists(task.routePath))
-            ? await readJson(task.routePath, RouteDecisionSchema)
-            : fallbackRoute;
-        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
+        const route = (await readRouteDecisionIfValid(task.routePath)) ?? fallbackRoute;
+        const meta = await readTaskMetaIfValid(task.metaPath);
         await this.writeTurn(task, "0001", request, route, meta ? new Date(meta.created_at) : this.now());
     }
     async writeTurn(task, turnId, request, route, createdAt) {
@@ -247,6 +271,30 @@ export class SessionManager {
     taskIdFromWorkerDir(workerDir) {
         return basename(dirname(workerDir));
     }
+    workerIdFromWorkerDir(workerDir) {
+        return basename(workerDir);
+    }
+    async clearWorkerStatusNativeSession(worker) {
+        const statusPath = join(worker.dir, "status.json");
+        if (!(await pathExists(statusPath))) {
+            return;
+        }
+        const status = await readWorkerStatusIfValid(statusPath);
+        if (!status) {
+            return;
+        }
+        if (!status.native_session_id) {
+            return;
+        }
+        const nextStatus = { ...status };
+        delete nextStatus.native_session_id;
+        await writeJson(statusPath, WorkerStatusSchema.parse(nextStatus));
+        await this.index?.upsertWorker(this.taskIdFromWorkerDir(worker.dir), nextStatus, {
+            dir: worker.dir,
+            statusPath,
+            outputLogPath: join(worker.dir, "output.log")
+        });
+    }
     async clearWorkerArtifacts(dir, role) {
         const files = role === "actor"
             ? ["worklog.md", "patch.diff"]
@@ -262,3 +310,47 @@ function titleFromRequest(request) {
     const firstLine = request.trim().split("\n")[0] ?? "Untitled task";
     return firstLine.length > 80 ? `${firstLine.slice(0, 77)}...` : firstLine;
 }
+async function readTaskMetaIfValid(metaPath) {
+    if (!(await pathExists(metaPath))) {
+        return null;
+    }
+    try {
+        return await readJson(metaPath, TaskMetaSchema);
+    }
+    catch {
+        return null;
+    }
+}
+async function readRouteDecisionIfValid(routePath) {
+    if (!(await pathExists(routePath))) {
+        return null;
+    }
+    try {
+        return await readJson(routePath, RouteDecisionSchema);
+    }
+    catch {
+        return null;
+    }
+}
+async function readNativeSessionIfValid(nativeSessionPath) {
+    if (!(await pathExists(nativeSessionPath))) {
+        return null;
+    }
+    try {
+        return await readJson(nativeSessionPath, NativeSessionSchema);
+    }
+    catch {
+        return null;
+    }
+}
+async function readWorkerStatusIfValid(statusPath) {
+    if (!(await pathExists(statusPath))) {
+        return null;
+    }
+    try {
+        return await readJson(statusPath, WorkerStatusSchema);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/workspace.js

@@ -0,0 +1,118 @@
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { ensureDir, pathExists, pathIsDirectory, readJson, readTextIfExists, writeJson, writeText } from "./file-store.js";
+const lastWorkspaceFile = "last-workspace";
+const workspacesFile = "workspaces.json";
+const maxRememberedWorkspaces = 20;
+const WorkspaceRegistrySchema = z.object({
+    version: z.literal(1).default(1),
+    workspaces: z
+        .array(z.object({
+        path: z.string().min(1),
+        last_used_at: z.string().min(1)
+    }))
+        .default([])
+});
+export async function resolveWorkspaceSelection(input) {
+    if (input.explicitWorkspace?.trim()) {
+        return resolveWorkspacePath(input.cwd, input.explicitWorkspace);
+    }
+    const [latest] = await listWorkspaceChoices(input.appRoot);
+    return latest ? latest.path : input.cwd;
+}
+export async function prepareWorkspace(appRoot, workspaceRoot) {
+    const resolved = resolveWorkspacePath(process.cwd(), workspaceRoot);
+    if ((await pathExists(resolved)) && !(await pathIsDirectory(resolved))) {
+        throw new Error(`Workspace path exists but is not a directory: ${resolved}`);
+    }
+    await ensureDir(resolved);
+    await ensureDir(join(resolved, ".parallel-codex"));
+    await rememberWorkspace(appRoot, resolved);
+    return resolved;
+}
+export async function hasSavedWorkspace(appRoot) {
+    return (await listWorkspaceChoices(appRoot)).length > 0;
+}
+export async function listWorkspaceChoices(appRoot) {
+    const entries = await readWorkspaceEntries(appRoot);
+    const legacy = (await readTextIfExists(lastWorkspacePath(appRoot))).trim();
+    if (legacy) {
+        entries.push({ path: legacy, last_used_at: "" });
+    }
+    const seen = new Set();
+    const unique = entries
+        .map((entry, index) => ({
+        path: resolveStoredWorkspacePath(appRoot, entry.path),
+        lastUsedAt: entry.last_used_at || null,
+        order: index
+    }))
+        .filter((entry) => {
+        if (seen.has(entry.path)) {
+            return false;
+        }
+        seen.add(entry.path);
+        return true;
+    })
+        .sort((left, right) => {
+        const byDate = (right.lastUsedAt ?? "").localeCompare(left.lastUsedAt ?? "");
+        return byDate === 0 ? left.order - right.order : byDate;
+    });
+    const choices = await Promise.all(unique.map(async (entry) => {
+        const exists = await pathExists(entry.path);
+        const isDirectory = exists && (await pathIsDirectory(entry.path));
+        return {
+            path: entry.path,
+            exists: isDirectory,
+            lastUsedAt: entry.lastUsedAt,
+            selectable: !exists || isDirectory
+        };
+    }));
+    return choices
+        .filter((choice) => choice.selectable)
+        .map(({ selectable: _selectable, ...choice }) => choice);
+}
+async function rememberWorkspace(appRoot, workspaceRoot) {
+    const now = new Date().toISOString();
+    const resolved = resolveWorkspacePath(process.cwd(), workspaceRoot);
+    const current = await readWorkspaceEntries(appRoot);
+    const next = {
+        version: 1,
+        workspaces: [
+            { path: resolved, last_used_at: now },
+            ...current.filter((entry) => resolveStoredWorkspacePath(appRoot, entry.path) !== resolved)
+        ].slice(0, maxRememberedWorkspaces)
+    };
+    await writeText(lastWorkspacePath(appRoot), `${resolved}\n`);
+    await writeJson(workspacesPath(appRoot), WorkspaceRegistrySchema.parse(next));
+}
+async function readWorkspaceEntries(appRoot) {
+    const file = workspacesPath(appRoot);
+    if (!(await pathExists(file))) {
+        return [];
+    }
+    try {
+        return (await readJson(file, WorkspaceRegistrySchema)).workspaces;
+    }
+    catch {
+        return [];
+    }
+}
+function lastWorkspacePath(appRoot) {
+    return join(appRoot, ".parallel-codex", lastWorkspaceFile);
+}
+function workspacesPath(appRoot) {
+    return join(appRoot, ".parallel-codex", workspacesFile);
+}
+export function resolveWorkspacePath(cwd, value) {
+    if (value === "~") {
+        return homedir();
+    }
+    if (value.startsWith("~/")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    return resolve(cwd, value);
+}
+function resolveStoredWorkspacePath(appRoot, value) {
+    return resolveWorkspacePath(appRoot, value);
+}

package/dist/doctor.js

@@ -1,25 +1,23 @@
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { delimiter, join } from "node:path";
+import { prepareAppRoot } from "./core/app-root.js";
 import { configPath, loadConfig } from "./core/config.js";
 import { pathExists } from "./core/file-store.js";
+import { prepareWorkspace } from "./core/workspace.js";
 export async function runDoctor(appRoot, workspaceRoot, env = process.env) {
     const lines = ["parallel-codex-tui doctor"];
     let ok = true;
+    await prepareAppRoot(appRoot);
+    const preparedWorkspace = await prepareWorkspace(appRoot, workspaceRoot);
     if (isSupportedNodeVersion(process.versions.node)) {
         lines.push(`Node.js: ok (${process.versions.node})`);
     }
     else {
         ok = false;
-        lines.push(`Node.js: unsupported (${process.versions.node}; need 22.5+)`);
-    }
-    if (await pathExists(workspaceRoot)) {
-        lines.push(`workspace: ok (${workspaceRoot})`);
-    }
-    else {
-        ok = false;
-        lines.push(`workspace: missing (${workspaceRoot})`);
+        lines.push(`Node.js: unsupported (${process.versions.node}; need 26+)`);
     }
+    lines.push(`workspace: ok (${preparedWorkspace})`);
     const localConfigPath = configPath(appRoot);
     if (!(await pathExists(localConfigPath))) {
         ok = false;
@@ -51,21 +49,49 @@ export async function runDoctor(appRoot, workspaceRoot, env = process.env) {
             lines.push(`${command}: missing`);
         }
     }
+    for (const check of configuredWorkerModelEnvChecks(config, env)) {
+        if (check.ok) {
+            lines.push(`${check.label}: ok`);
+        }
+        else {
+            ok = false;
+            lines.push(`${check.label}: missing env ${check.envName}`);
+        }
+    }
     return {
         ok,
         text: `${lines.join("\n")}\n`
     };
 }
-function isSupportedNodeVersion(version) {
+export function isSupportedNodeVersion(version) {
     const [majorRaw = "0", minorRaw = "0"] = version.split(".");
     const major = Number.parseInt(majorRaw, 10);
     const minor = Number.parseInt(minorRaw, 10);
-    return major > 22 || (major === 22 && minor >= 5);
+    return major >= 26;
 }
 function configuredCommands(config) {
+    return Array.from(new Set(configuredEngines(config, { includeRouter: true })
+        .map((engine) => commandForEngine(config, engine))
+        .filter((command) => Boolean(command) && command !== "mock")));
+}
+function commandForEngine(config, engine) {
+    if (engine === "router-codex") {
+        return config.router.codex.command;
+    }
+    if (engine === "codex") {
+        return config.workers.codex.command;
+    }
+    if (engine === "claude") {
+        return config.workers.claude.command;
+    }
+    return null;
+}
+function configuredEngines(config, options) {
     const engines = new Set();
-    if (config.router.defaultMode === "auto") {
+    if (config.router.defaultMode === "auto" && options.includeRouter) {
         engines.add("router-codex");
+    }
+    if (config.router.defaultMode === "auto") {
         engines.add(config.pairing.main);
         engines.add(config.pairing.judge);
         engines.add(config.pairing.actor);
@@ -79,21 +105,29 @@ function configuredCommands(config) {
         engines.add(config.pairing.actor);
         engines.add(config.pairing.critic);
     }
-    return Array.from(new Set(Array.from(engines)
-        .map((engine) => commandForEngine(config, engine))
-        .filter((command) => Boolean(command) && command !== "mock")));
+    return Array.from(engines);
 }
-function commandForEngine(config, engine) {
-    if (engine === "router-codex") {
-        return config.router.codex.command;
-    }
-    if (engine === "codex") {
-        return config.workers.codex.command;
-    }
-    if (engine === "claude") {
-        return config.workers.claude.command;
+function configuredWorkerEngines(config) {
+    return configuredEngines(config, { includeRouter: false }).filter((engine) => engine === "codex" || engine === "claude");
+}
+function configuredWorkerModelEnvChecks(config, env) {
+    const checks = [];
+    for (const engine of configuredWorkerEngines(config)) {
+        const worker = engine === "codex" ? config.workers.codex : config.workers.claude;
+        for (const [key, value] of Object.entries(worker.model.env)) {
+            for (const envName of referencedEnvNames(value)) {
+                checks.push({
+                    label: `workers.${engine}.model.env.${key}`,
+                    envName,
+                    ok: Boolean(env[envName])
+                });
+            }
+        }
     }
-    return null;
+    return checks;
+}
+function referencedEnvNames(value) {
+    return Array.from(value.matchAll(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g), (match) => match[1] ?? "");
 }
 async function commandExists(command, env) {
     if (command.includes("/")) {

package/dist/orchestrator/orchestrator.js

@@ -12,14 +12,16 @@ export class Orchestrator {
     sessions;
     workers;
     routeRunner;
-    constructor(config, sessions, workers, routeRunner) {
+    routerCwd;
+    constructor(config, sessions, workers, routeRunner, routerCwd = config.projectRoot) {
         this.config = config;
         this.sessions = sessions;
         this.workers = workers;
         this.routeRunner = routeRunner;
+        this.routerCwd = routerCwd;
     }
     async handleRequest(input) {
-        const route = await routeRequestWithCodex(input.request, this.config, this.routeRunner, input.cwd);
+        const route = await this.routeRequest(input.request);
         const workers = [];
         if (route.mode === "simple") {
             input.onStatus?.({ taskId: "main", main: "running" });
@@ -104,7 +106,7 @@ export class Orchestrator {
     }
     async handleTaskTurn(input) {
         const task = this.sessions.taskFromId(input.taskId);
-        const route = await routeRequestWithCodex(input.request, this.config, this.routeRunner, input.cwd);
+        const route = await this.routeRequest(input.request);
         const turn = await this.sessions.appendTurn(task, {
             request: input.request,
             route
@@ -170,19 +172,7 @@ export class Orchestrator {
         }
     }
     async routeTaskFollowUp(input) {
-        const task = this.sessions.taskFromId(input.taskId);
-        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
-        const route = await routeRequestWithCodex([
-            "Active task follow-up routing.",
-            `Task id: ${input.taskId}`,
-            `Task status: ${meta?.status ?? "unknown"}`,
-            "",
-            "Choose simple for status/log/reason/explanation questions that can be answered from session files.",
-            "Choose complex for requests that change direction, ask for code changes, reruns, fixes, new experiments, or implementation work.",
-            "",
-            "Follow-up request:",
-            input.request
-        ].join("\n"), this.config, this.routeRunner, input.cwd);
+        const route = await this.routeRequest(input.request);
         return {
             mode: route.mode,
             taskId: route.mode === "complex" ? input.taskId : null,
@@ -191,7 +181,7 @@ export class Orchestrator {
     }
     async answerTaskQuestion(input) {
         const task = this.sessions.taskFromId(input.taskId);
-        const meta = (await pathExists(task.metaPath)) ? await readJson(task.metaPath, TaskMetaSchema) : null;
+        const meta = await readTaskMetaIfValid(task.metaPath);
         const workerSummaries = await Promise.all(["judge", "actor", "critic"].map((role) => this.readLatestWorkerQuestionSummary(task, role)));
         const workers = workerSummaries.filter((worker) => worker !== null);
         const failed = workers.find((worker) => worker.status.state === "failed");
@@ -228,7 +218,10 @@ export class Orchestrator {
             if (!(await pathExists(statusPath))) {
                 continue;
             }
-            const status = await readJson(statusPath, WorkerStatusSchema);
+            const status = await readWorkerStatusIfValid(statusPath);
+            if (!status) {
+                continue;
+            }
             workers.push({
                 id: status.worker_id,
                 role: status.role,
@@ -240,6 +233,9 @@ export class Orchestrator {
         }
         return workers.sort((left, right) => workerRoleOrder(left.role) - workerRoleOrder(right.role));
     }
+    routeRequest(request) {
+        return routeRequestWithCodex(request, this.config, this.routeRunner, this.routerCwd);
+    }
     async runMain(input, workers) {
         const engine = this.config.pairing.main;
         const dir = this.sessions.mainSessionDir();
@@ -476,7 +472,10 @@ export class Orchestrator {
             if (!(await pathExists(files.statusPath))) {
                 continue;
             }
-            const status = await readJson(files.statusPath, WorkerStatusSchema);
+            const status = await readWorkerStatusIfValid(files.statusPath);
+            if (!status) {
+                continue;
+            }
             return {
                 status,
                 logTail: tailText(await readTextIfExists(files.outputLogPath), 8)
@@ -490,6 +489,25 @@ function ensureWorkerSuccess(workerId, exitCode) {
         throw new Error(`${workerId} failed with exit code ${exitCode}`);
     }
 }
+async function readWorkerStatusIfValid(statusPath) {
+    try {
+        return await readJson(statusPath, WorkerStatusSchema);
+    }
+    catch {
+        return null;
+    }
+}
+async function readTaskMetaIfValid(metaPath) {
+    if (!(await pathExists(metaPath))) {
+        return null;
+    }
+    try {
+        return await readJson(metaPath, TaskMetaSchema);
+    }
+    catch {
+        return null;
+    }
+}
 function summarizeRetirementReason(reason) {
     const lines = reason
         .split(/\r?\n/)

package/dist/tui/App.js

@@ -10,7 +10,7 @@ import { AppShell } from "./AppShell.js";
 import { InputBar } from "./InputBar.js";
 import { applyNativeInputChunk } from "./native-input.js";
 import { nextScrollOffset } from "./scrolling.js";
-import { chooseSubmitTarget, nextSubmitMemoryState } from "./task-memory.js";
+import { chooseSubmitTarget, nextSubmitMemoryState, shouldClearWorkersForSubmit } from "./task-memory.js";
 import { TerminalOutput } from "./TerminalOutput.js";
 import { NativeTerminalScreen } from "./terminal-screen.js";
 import { WorkerOutputView } from "./WorkerOutputView.js";
@@ -405,13 +405,6 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
         setInput("");
         busyRef.current = true;
         setBusy(true);
-        setWorkers([]);
-        selectedWorkerIndexRef.current = 0;
-        autoSelectedFailedWorkerRef.current = false;
-        userSelectedWorkerRef.current = false;
-        setSelectedWorkerIndex(0);
-        setWorkerScrollOffset(0);
-        setWorkerMaxScrollOffset(0);
         setMessages((current) => [...current, { from: "user", text: request }]);
         try {
             const callbacks = {
@@ -433,6 +426,15 @@ export function App({ config, orchestrator, cwd, initialTaskId = null, prepareNa
                 })
                 : undefined;
             const target = chooseSubmitTarget(memory, followUpRoute);
+            if (shouldClearWorkersForSubmit(target)) {
+                setWorkers([]);
+                selectedWorkerIndexRef.current = 0;
+                autoSelectedFailedWorkerRef.current = false;
+                userSelectedWorkerRef.current = false;
+                setSelectedWorkerIndex(0);
+                setWorkerScrollOffset(0);
+                setWorkerMaxScrollOffset(0);
+            }
             const result = target.kind === "task-turn"
                 ? await orchestrator.handleTaskTurn({
                     request,

package/dist/tui/task-memory.js

@@ -24,3 +24,6 @@ export function nextSubmitMemoryState(current, target, result) {
         activeTaskId: result.mode === "complex" ? result.taskId : null
     };
 }
+export function shouldClearWorkersForSubmit(target) {
+    return target.kind !== "task-question";
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.1.0";
+export const version = "0.1.3";