@longtable/cli 0.1.56 → 0.1.58

package/dist/cli.js

@@ -18,7 +18,7 @@ import { installCodexPromptAliases, listInstalledCodexPromptAliases, removeCodex
 import { buildPersonaGuidance, parseInvocationDirective } from "./persona-router.js";
 import { PERSONA_DEFINITIONS, listRoleDefinitions } from "./personas.js";
 import { buildPanelFallback, renderPanelSummary } from "./panel.js";
-import { createPanelWorkerRun, launchPanelWorkerRun, panelWorkerRunPath, readPanelWorkerRun, refreshPanelWorkerRun, requestPanelWorkerStop, resumePanelWorkerRun, waitForPanelWorkerRun } from "./panel-runtime.js";
+import { createPanelWorkerRun, launchPanelWorkerRun, panelWorkerRunPath, readPanelWorkerRun, refreshPanelWorkerRun, requestPanelWorkerStop, resumePanelWorkerRun, shutdownPanelWorkerRun, waitForPanelWorkerRun } from "./panel-runtime.js";
 import { LONGTABLE_MANAGED_HOOK_EVENTS, codexHooksEnabled, enableCodexHooksFeature, getMissingManagedCodexHookEvents, getMissingManagedCodexHookTrustState, mergeCodexHookTrustState, mergeManagedCodexHooksConfig, removeCodexHookTrustState, removeManagedCodexHooks } from "./codex-hooks.js";
 import { appendInvocationRecordToWorkspace, applyResearchSpecificationPatch, assertWorkspaceNotBlocked, answerWorkspaceQuestion, buildQuestionOpportunitySpecs, clearWorkspaceQuestion, createWorkspaceFollowUpQuestions, createWorkspaceQuestion, createOrUpdateProjectWorkspace, createWorkspaceHandoff, diffResearchSpecifications, inspectProjectWorkspace, loadWorkspaceState, loadProjectContextFromDirectory, findUnincorporatedResearchEvidence, proposeResearchSpecificationPatch, pruneWorkspaceQuestions, readResearchSpecificationHistory, recordPanelResultInWorkspace, repairWorkspaceStateConsistency, renderProjectWorkspaceSummary, syncCurrentWorkspaceView } from "./project-session.js";
 import { buildTeamDebate } from "./debate.js";
@@ -162,6 +162,7 @@ function usage() {
         "  longtable panel [--prompt <text>] [--role <role[,role]>] [--mode review|critique|draft|commit] [--visibility synthesis_only|show_on_conflict|always_visible] [--provider codex|claude] [--native-workers|--native-subagents] [--wait [ms]] [--print] [--json] [--setup <path>] [--cwd <path>]",
         "  longtable panel status --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
         "  longtable panel stop --run <panel_run_id> [--cwd <path>] [--json]",
+        "  longtable panel shutdown --run <panel_run_id> [--cwd <path>] [--json]",
         "  longtable panel resume --run <panel_run_id> [--wait [ms]] [--cwd <path>] [--json]",
         "  longtable panel record [--invocation <id>] --result-file <json> [--surface sequential_fallback|native_subagents|native_workers] [--cwd <path>] [--json]",
         "  longtable handoff [--cwd <path>] [--output <file>] [--print] [--json]",
@@ -2343,6 +2344,7 @@ function panelWorkerNextCommands(context, runId) {
     return {
         status: `longtable panel status ${cwdFlag} --run ${runId}`,
         stop: `longtable panel stop ${cwdFlag} --run ${runId}`,
+        shutdown: `longtable panel shutdown ${cwdFlag} --run ${runId}`,
         resume: `longtable panel resume ${cwdFlag} --run ${runId}`
     };
 }
@@ -2372,6 +2374,32 @@ function summarizePanelRecordOutput(result) {
         evidenceRecordIds: result.evidenceRecords.map((record) => record.id)
     };
 }
+function summarizePanelWorkerExecution(run) {
+    const bridgeStatus = run.bridgeStatus ?? run.status;
+    const bridgeFailureReason = run.bridgeFailureReason ?? (bridgeStatus === "degraded"
+        ? "native worker bridge unavailable before execution"
+        : bridgeStatus === "failed" || bridgeStatus === "blocked"
+            ? "native worker bridge did not complete all role passes"
+            : undefined);
+    return {
+        requestedSurface: run.requestedSurface,
+        fallbackSurface: run.fallbackSurface,
+        bridgeStatus,
+        bridgeFailureReason,
+        sequentialFallbackExecuted: false,
+        paneIds: run.workers.map((worker) => worker.paneId).filter((paneId) => typeof paneId === "string" && paneId.length > 0),
+        workers: run.workers.map((worker) => ({
+            id: worker.id,
+            role: worker.role,
+            label: worker.label,
+            status: worker.status,
+            paneId: worker.paneId,
+            resultPath: worker.resultPath,
+            diagnostics: worker.diagnostics
+        })),
+        diagnostics: run.diagnostics
+    };
+}
 async function runPanelStatusCommand(args) {
     const context = await requireWorkspaceContext(args);
     const runId = requireRunId(args);
@@ -2381,7 +2409,12 @@ async function runPanelStatusCommand(args) {
     const recordedPanelResult = await recordTerminalNativeWorkerRun(context, refreshed);
     const nextCommands = panelWorkerNextCommands(context, refreshed.id);
     if (args.json === true) {
-        console.log(JSON.stringify({ ...refreshed, nextCommands, recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult) }, null, 2));
+        console.log(JSON.stringify({
+            ...refreshed,
+            execution: summarizePanelWorkerExecution(refreshed),
+            nextCommands,
+            recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult)
+        }, null, 2));
         return;
     }
     console.log("LongTable panel run status");
@@ -2391,6 +2424,7 @@ async function runPanelStatusCommand(args) {
         console.log(`- ${worker.label} (${worker.role}): ${worker.status}`);
     }
     console.log(`- stop: ${nextCommands.stop}`);
+    console.log(`- shutdown: ${nextCommands.shutdown}`);
     console.log(`- resume: ${nextCommands.resume}`);
     if (recordedPanelResult) {
         console.log(`- recorded evidence: ${recordedPanelResult.evidenceRecords.length}`);
@@ -2411,13 +2445,36 @@ async function runPanelStopCommand(args) {
     for (const worker of stopped.workers) {
         console.log(`- ${worker.label} (${worker.role}): ${worker.status}`);
     }
+    console.log(`- shutdown: ${nextCommands.shutdown}`);
+    console.log(`- resume: ${nextCommands.resume}`);
+}
+async function runPanelShutdownCommand(args) {
+    const context = await requireWorkspaceContext(args);
+    const runId = requireRunId(args);
+    const shutdown = await shutdownPanelWorkerRun(await readPanelWorkerRun(context.project.projectPath, runId));
+    const nextCommands = panelWorkerNextCommands(context, shutdown.id);
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            ...shutdown,
+            execution: summarizePanelWorkerExecution(shutdown),
+            nextCommands
+        }, null, 2));
+        return;
+    }
+    console.log("LongTable panel run shutdown requested");
+    console.log(`- run: ${shutdown.id}`);
+    console.log(`- status: ${shutdown.status}`);
+    for (const worker of shutdown.workers) {
+        console.log(`- ${worker.label} (${worker.role}): ${worker.status}`);
+    }
+    console.log(`- status command: ${nextCommands.status}`);
     console.log(`- resume: ${nextCommands.resume}`);
 }
 async function runPanelResumeCommand(args) {
     const context = await requireWorkspaceContext(args);
     const runId = requireRunId(args);
     const waitMs = parseWaitMs(args.wait);
-    const { run } = await refreshPanelWorkerRun(await readPanelWorkerRun(context.project.projectPath, runId));
+    const run = await readPanelWorkerRun(context.project.projectPath, runId);
     const resumed = run.status === "completed" ? run : await launchPanelWorkerRun(await resumePanelWorkerRun(run));
     const finalRun = waitMs ? await waitForPanelWorkerRun(resumed, waitMs) : resumed;
     const recordedPanelResult = await recordTerminalNativeWorkerRun(context, finalRun);
@@ -2587,10 +2644,17 @@ async function runPanelCommand(args) {
                 nativeRunCreated: Boolean(finalNativeRun),
                 waitMs,
                 degradedReason: nativeWorkersRequested && !finalNativeRun
-                    ? "native workers require an existing LongTable workspace; sequential fallback prompt returned"
+                    ? "native workers require an existing LongTable workspace; no native run was created and no sequential fallback was executed"
                     : finalNativeRun?.status === "degraded"
-                        ? "native workers require local tmux and codex commands; sequential fallback remains available"
-                        : undefined
+                        ? "native worker bridge unavailable; sequential fallback remains available but was not executed by this native-workers request"
+                        : undefined,
+                bridgeStatus: finalNativeRun?.bridgeStatus ?? finalNativeRun?.status,
+                bridgeFailureReason: finalNativeRun?.bridgeFailureReason ?? (finalNativeRun?.status === "degraded"
+                    ? "native worker bridge unavailable before execution"
+                    : finalNativeRun?.status === "failed" || finalNativeRun?.status === "blocked"
+                        ? "native worker bridge did not complete all role passes"
+                        : undefined),
+                sequentialFallbackExecuted: !nativeWorkersRequested
             },
             nativeRun: finalNativeRun,
             recordedPanelResult: summarizePanelRecordOutput(recordedPanelResult),
@@ -2608,17 +2672,26 @@ async function runPanelCommand(args) {
         const nextCommands = panelWorkerNextCommands(nativeRunContext, finalNativeRun.id);
         console.log(`- next status: ${nextCommands.status}`);
         console.log(`- stop: ${nextCommands.stop}`);
+        console.log(`- shutdown: ${nextCommands.shutdown}`);
         console.log(`- resume: ${nextCommands.resume}`);
         if (recordedPanelResult) {
             console.log(`- recorded evidence: ${recordedPanelResult.evidenceRecords.length}`);
         }
         if (finalNativeRun.status === "degraded") {
-            console.log("- degraded: native workers are unavailable; use the sequential fallback prompt below.");
+            console.log("- degraded: native workers are unavailable; sequential fallback is available but was not executed by this native-workers request.");
             console.log("");
             console.log(fallback.prompt);
         }
         return;
     }
+    if (nativeWorkersRequested) {
+        console.log("LongTable native panel worker run was not created");
+        console.log("- status: failed");
+        console.log("- reason: native workers require an existing LongTable workspace; sequential fallback was not executed by this native-workers request.");
+        console.log("");
+        console.log(fallback.prompt);
+        exit(1);
+    }
     const exitCode = await runCodexThinWrapper({
         prompt: fallback.prompt,
         mode,
@@ -4295,6 +4368,10 @@ async function main() {
             await runPanelStopCommand(values);
             return;
         }
+        if (subcommand === "shutdown") {
+            await runPanelShutdownCommand(values);
+            return;
+        }
         if (subcommand === "resume") {
             await runPanelResumeCommand(values);
             return;

package/dist/panel-runtime.d.ts

@@ -17,4 +17,5 @@ export declare function refreshPanelWorkerRun(run: PanelWorkerRun): Promise<{
 }>;
 export declare function requestPanelWorkerStop(run: PanelWorkerRun): Promise<PanelWorkerRun>;
 export declare function resumePanelWorkerRun(run: PanelWorkerRun): Promise<PanelWorkerRun>;
+export declare function shutdownPanelWorkerRun(run: PanelWorkerRun): Promise<PanelWorkerRun>;
 export declare function waitForPanelWorkerRun(run: PanelWorkerRun, timeoutMs: number): Promise<PanelWorkerRun>;

package/dist/panel-runtime.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 function nowIso() {
     return new Date().toISOString();
@@ -26,6 +26,30 @@ function appendDiagnostic(existing, diagnostic) {
 function panelRunsDirectory(workingDirectory) {
     return join(workingDirectory, ".longtable", "panel-runs");
 }
+function safeName(value) {
+    return value.replace(/[^A-Za-z0-9._/-]/g, "-").replace(/\/+/g, "/").slice(0, 180);
+}
+function workerSafeName(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 80);
+}
+function gitOutput(workingDirectory, args) {
+    return execFileSync("git", args, { cwd: workingDirectory, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function currentGitCommit(workingDirectory) {
+    try {
+        return gitOutput(workingDirectory, ["rev-parse", "HEAD"]);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function appendLifecycleEvent(run, event) {
+    if (!run.eventLogPath) {
+        return;
+    }
+    await mkdir(dirname(run.eventLogPath), { recursive: true });
+    await appendFile(run.eventLogPath, `${JSON.stringify({ id: createId("event"), createdAt: nowIso(), ...event })}\n`, "utf8");
+}
 export function panelWorkerRunDirectory(workingDirectory, runId) {
     return join(panelRunsDirectory(workingDirectory), runId);
 }
@@ -38,16 +62,41 @@ async function writeJsonAtomic(path, value) {
     await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
     await rename(tempPath, path);
 }
-function workerTaskPrompt(fallback, worker) {
+function workerRuntimeDirectory(worker) {
+    return join(worker.worktreePath ?? dirname(worker.resultPath), ".longtable-worker");
+}
+function workerRuntimePaths(worktreePath) {
+    const workerDirectory = join(worktreePath, ".longtable-worker");
+    return {
+        taskPath: join(workerDirectory, "task.md"),
+        resultPath: join(workerDirectory, "result.json"),
+        logPath: join(workerDirectory, "worker.log"),
+        launcherPath: join(workerDirectory, "launch.sh"),
+        exitCodePath: join(workerDirectory, "result.exit.json"),
+        mailboxPath: join(workerDirectory, "mailbox.jsonl"),
+        taskStatePath: join(workerDirectory, "state.json")
+    };
+}
+function shouldNormalizeWorkerRuntimePaths(run, worker) {
+    if (worker.status === "completed" || worker.status === "blocked" || worker.status === "running") {
+        return false;
+    }
+    return run.status === "planned" ||
+        run.status === "failed" ||
+        run.status === "stopped" ||
+        run.status === "stop_requested" ||
+        run.status === "resumable";
+}
+function workerTaskPrompt(run, worker) {
     return [
         "LongTable native panel worker",
         "",
         `Role: ${worker.label} (${worker.role})`,
-        `Invocation: ${fallback.invocationRecord.id}`,
-        `Panel plan: ${fallback.plan.id}`,
+        `Invocation: ${run.invocationId}`,
+        `Panel plan: ${run.planId}`,
         "",
         "Instructions:",
-        "- Work read-only unless the researcher explicitly asked for drafting.",
+        "- Work inside the assigned writable worker worktree; do not mutate the leader checkout directly.",
         "- Do not expose or persist hidden reasoning, private tool traces, or chain-of-thought.",
         "- Persist only the structured final role output to the result path below.",
         "- Return JSON matching this shape:",
@@ -55,9 +104,12 @@ function workerTaskPrompt(fallback, worker) {
         "",
         `Result path: ${worker.resultPath}`,
         `Log path: ${worker.logPath}`,
+        worker.worktreePath ? `Writable worker worktree: ${worker.worktreePath}` : "",
+        worker.mailboxPath ? `Worker mailbox: ${worker.mailboxPath}` : "",
+        worker.taskStatePath ? `Worker task lifecycle state: ${worker.taskStatePath}` : "",
         "",
         "Research object:",
-        fallback.plan.prompt
+        run.prompt
     ].join("\n");
 }
 const PANEL_WORKER_OUTPUT_SCHEMA = {
@@ -80,18 +132,22 @@ function launcherScript(run, worker) {
     const role = shellQuote(worker.role);
     const label = shellQuote(worker.label);
     const stdoutPath = `${worker.resultPath}.stdout`;
+    const worktreePath = worker.worktreePath ?? run.workingDirectory;
+    const commitPath = `${worker.resultPath}.commit`;
     return [
         "#!/usr/bin/env bash",
         "set +e",
         `printf 'started_at=%s\\n' "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" > ${shellQuote(worker.logPath)}`,
+        `mkdir -p ${shellQuote(join(worktreePath, ".longtable-worker"))}`,
+        `printf '{"workerId":%s,"runId":%s,"startedAt":"%s"}\\n' ${shellQuote(JSON.stringify(worker.id))} ${shellQuote(JSON.stringify(run.id))} "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" > ${shellQuote(join(worktreePath, ".longtable-worker", `${worker.id}.json`))}`,
         `if [ -f ${shellQuote(run.stopFilePath)} ]; then`,
         `  printf 'stop_requested_before_launch\\n' >> ${shellQuote(worker.logPath)}`,
         "  exit 0",
         "fi",
         [
             "codex exec",
-            "-s read-only",
-            `-C ${shellQuote(run.workingDirectory)}`,
+            "-s workspace-write",
+            `-C ${shellQuote(worktreePath)}`,
             "--skip-git-repo-check",
             `--output-schema ${shellQuote(run.outputSchemaPath)}`,
             "-",
@@ -100,7 +156,7 @@ function launcherScript(run, worker) {
         ].join(" "),
         "code=$?",
         `if [ -s ${shellQuote(stdoutPath)} ]; then`,
-        `  node -e 'const fs=require("fs"); const [stdoutPath,resultPath]=process.argv.slice(1); const parsed=JSON.parse(fs.readFileSync(stdoutPath,"utf8").trim()); fs.writeFileSync(resultPath, JSON.stringify(parsed, null, 2)+"\\n");' ${shellQuote(stdoutPath)} ${shellQuote(worker.resultPath)}`,
+        `  node -e 'const fs=require("fs"); const [stdoutPath,resultPath]=process.argv.slice(1); const parsed=JSON.parse(fs.readFileSync(stdoutPath,"utf8").trim()); const strings=(value)=>Array.isArray(value)?value.filter((entry)=>typeof entry==="string"):[]; const status=["completed","blocked","error"].includes(parsed.status)?parsed.status:"error"; const sanitized={role:typeof parsed.role==="string"?parsed.role:"",label:typeof parsed.label==="string"?parsed.label:"",status,summary:typeof parsed.summary==="string"?parsed.summary:"",claims:strings(parsed.claims),objections:strings(parsed.objections),openQuestions:strings(parsed.openQuestions),evidenceRefs:strings(parsed.evidenceRefs),error:typeof parsed.error==="string"?parsed.error:""}; fs.writeFileSync(resultPath, JSON.stringify(sanitized, null, 2)+"\\n");' ${shellQuote(stdoutPath)} ${shellQuote(worker.resultPath)}`,
         "  parse_code=$?",
         `  rm -f ${shellQuote(stdoutPath)}`,
         `  if [ "$parse_code" -ne 0 ]; then code=1; fi`,
@@ -110,6 +166,12 @@ function launcherScript(run, worker) {
         `if [ "$code" -ne 0 ] && [ ! -s ${shellQuote(worker.resultPath)} ]; then`,
         `  node -e 'const fs=require("fs"); const [path,role,label,code]=process.argv.slice(1); fs.writeFileSync(path, JSON.stringify({role,label,status:"error",summary:"",claims:[],objections:[],openQuestions:[],evidenceRefs:[],error:\`codex exec exited ${"${code}"}\`}, null, 2)+"\\n");' ${shellQuote(worker.resultPath)} ${role} ${label} "$code"`,
         "fi",
+        `if git -C ${shellQuote(worktreePath)} status --porcelain >/tmp/longtable-worker-status.$$ 2>/dev/null && [ -s /tmp/longtable-worker-status.$$ ]; then`,
+        `  git -C ${shellQuote(worktreePath)} add -A >/dev/null 2>&1`,
+        `  git -C ${shellQuote(worktreePath)} -c user.name='LongTable Panel Worker' -c user.email='longtable-panel-worker@example.invalid' commit -m ${shellQuote(`longtable panel worker ${worker.id}`)} >/dev/null 2>&1`,
+        "fi",
+        `rm -f /tmp/longtable-worker-status.$$`,
+        `git -C ${shellQuote(worktreePath)} rev-parse HEAD > ${shellQuote(commitPath)} 2>/dev/null`,
         "exit $code",
         ""
     ].join("\n");
@@ -125,24 +187,32 @@ export async function createPanelWorkerRun(options) {
     const resultDirectory = join(runDirectory, "results");
     const logDirectory = join(runDirectory, "logs");
     const launcherDirectory = join(runDirectory, "launchers");
-    await mkdir(taskDirectory, { recursive: true });
-    await mkdir(resultDirectory, { recursive: true });
-    await mkdir(logDirectory, { recursive: true });
-    await mkdir(launcherDirectory, { recursive: true });
+    const worktreeDirectory = join(runDirectory, "worktrees");
+    const mailboxDirectory = join(runDirectory, "mailbox");
+    await mkdir(runDirectory, { recursive: true });
+    await mkdir(worktreeDirectory, { recursive: true });
     const runStatus = options.initialStatus ?? "planned";
     const workers = options.fallback.plan.members.map((member, index) => {
         const workerId = `worker-${index + 1}-${member.role}`;
+        const worktreePath = join(worktreeDirectory, workerSafeName(workerId));
+        const paths = workerRuntimePaths(worktreePath);
         return {
             id: workerId,
             role: member.role,
             label: member.label,
             required: member.required,
             status: plannedWorkerStatus(runStatus),
-            taskPath: join(taskDirectory, `${workerId}.md`),
-            resultPath: join(resultDirectory, `${workerId}.json`),
-            logPath: join(logDirectory, `${workerId}.log`),
-            launcherPath: join(launcherDirectory, `${workerId}.sh`),
-            exitCodePath: join(resultDirectory, `${workerId}.exit.json`),
+            taskPath: paths.taskPath,
+            resultPath: paths.resultPath,
+            logPath: paths.logPath,
+            launcherPath: paths.launcherPath,
+            exitCodePath: paths.exitCodePath,
+            worktreePath,
+            worktreeBranch: safeName(`longtable/panel/${runId}/${workerId}`),
+            mailboxPath: paths.mailboxPath,
+            taskStatePath: paths.taskStatePath,
+            cleanupStatus: "not_started",
+            executionState: "not_started",
             updatedAt: createdAt,
             diagnostics: []
         };
@@ -167,9 +237,14 @@ export async function createPanelWorkerRun(options) {
         resultDirectory,
         logDirectory,
         launcherDirectory,
+        worktreeDirectory,
+        mailboxDirectory,
+        eventLogPath: join(runDirectory, "events.jsonl"),
         outputSchemaPath: join(runDirectory, "panel-worker-output.schema.json"),
         stopFilePath: join(runDirectory, "stop-requested"),
         aggregateResultPath: join(runDirectory, "panel-result.json"),
+        bridgeStatus: runStatus === "planned" ? "not_requested" : "running",
+        sequentialFallbackAvailable: true,
         workers,
         diagnostics: options.diagnostics ?? []
     };
@@ -179,7 +254,7 @@ export async function createPanelWorkerRun(options) {
         note: "Durable worker state stores task/status/result metadata, not hidden reasoning or raw tool traces."
     });
     await writeJsonAtomic(run.outputSchemaPath, PANEL_WORKER_OUTPUT_SCHEMA);
-    await Promise.all(workers.map((worker) => writeFile(worker.taskPath, workerTaskPrompt(options.fallback, worker), "utf8")));
+    await appendLifecycleEvent(run, { type: "run_created", message: "LongTable native worker bridge run created." });
     await writePanelWorkerRun(run);
     return run;
 }
@@ -189,17 +264,38 @@ export async function readPanelWorkerRun(workingDirectory, runId) {
 function normalizePanelWorkerRun(run) {
     const launcherDirectory = run.launcherDirectory ?? join(run.runDirectory, "launchers");
     const resultDirectory = run.resultDirectory ?? join(run.runDirectory, "results");
+    const worktreeDirectory = run.worktreeDirectory ?? join(run.runDirectory, "worktrees");
+    const mailboxDirectory = run.mailboxDirectory ?? join(run.runDirectory, "mailbox");
     return {
         ...run,
         launcherDirectory,
+        worktreeDirectory,
+        mailboxDirectory,
+        eventLogPath: run.eventLogPath ?? join(run.runDirectory, "events.jsonl"),
+        bridgeStatus: run.bridgeStatus ?? bridgeStatusFromRunStatus(run.status),
+        sequentialFallbackAvailable: run.sequentialFallbackAvailable ?? true,
         outputSchemaPath: run.outputSchemaPath ?? join(run.runDirectory, "panel-worker-output.schema.json"),
         stopFilePath: run.stopFilePath ?? join(run.runDirectory, "stop-requested"),
-        workers: run.workers.map((worker) => ({
-            ...worker,
-            launcherPath: worker.launcherPath ?? join(launcherDirectory, `${worker.id}.sh`),
-            exitCodePath: worker.exitCodePath ?? join(resultDirectory, `${worker.id}.exit.json`),
-            diagnostics: worker.diagnostics ?? []
-        }))
+        workers: run.workers.map((worker) => {
+            const worktreePath = worker.worktreePath ?? join(worktreeDirectory, workerSafeName(worker.id));
+            const runtimePaths = workerRuntimePaths(worktreePath);
+            const normalizePaths = shouldNormalizeWorkerRuntimePaths(run, worker);
+            return {
+                ...worker,
+                taskPath: normalizePaths ? runtimePaths.taskPath : worker.taskPath,
+                resultPath: normalizePaths ? runtimePaths.resultPath : worker.resultPath,
+                logPath: normalizePaths ? runtimePaths.logPath : worker.logPath,
+                launcherPath: normalizePaths ? runtimePaths.launcherPath : worker.launcherPath ?? join(launcherDirectory, `${worker.id}.sh`),
+                exitCodePath: normalizePaths ? runtimePaths.exitCodePath : worker.exitCodePath ?? join(resultDirectory, `${worker.id}.exit.json`),
+                worktreePath,
+                worktreeBranch: worker.worktreeBranch ?? safeName(`longtable/panel/${run.id}/${worker.id}`),
+                mailboxPath: normalizePaths ? runtimePaths.mailboxPath : worker.mailboxPath ?? join(mailboxDirectory, `${worker.id}.jsonl`),
+                taskStatePath: normalizePaths ? runtimePaths.taskStatePath : worker.taskStatePath ?? join(run.taskDirectory, `${worker.id}.state.json`),
+                cleanupStatus: worker.cleanupStatus ?? "not_started",
+                executionState: worker.executionState ?? "not_started",
+                diagnostics: worker.diagnostics ?? []
+            };
+        })
     };
 }
 export async function writePanelWorkerRun(run) {
@@ -207,6 +303,24 @@ export async function writePanelWorkerRun(run) {
         ...run,
         updatedAt: nowIso()
     });
+    await Promise.all(run.workers.map((worker) => worker.taskStatePath
+        && existsSync(dirname(worker.taskStatePath))
+        && (!worker.worktreePath || existsSync(worker.worktreePath))
+        ? writeJsonAtomic(worker.taskStatePath, {
+            workerId: worker.id,
+            status: worker.status,
+            executionState: worker.executionState,
+            paneId: worker.paneId,
+            runtime: worker.runtime,
+            worktreePath: worker.worktreePath,
+            worktreeBranch: worker.worktreeBranch,
+            worktreeCommit: worker.worktreeCommit,
+            cleanupStatus: worker.cleanupStatus,
+            failureReason: worker.failureReason,
+            error: worker.error,
+            updatedAt: worker.updatedAt
+        })
+        : Promise.resolve()));
 }
 function parseWorkerResult(worker) {
     if (!existsSync(worker.resultPath)) {
@@ -242,7 +356,7 @@ function statusFromWorkers(workers) {
         return "running";
     }
     if (workers.some((worker) => worker.status === "failed")) {
-        return "resumable";
+        return "failed";
     }
     if (workers.some((worker) => worker.status === "blocked")) {
         return "blocked";
@@ -255,6 +369,15 @@ function statusFromWorkers(workers) {
     }
     return "running";
 }
+function bridgeStatusFromRunStatus(status) {
+    return status === "planned" || status === "resumable" ? "not_requested" : status;
+}
+function bridgeStatusFromWorkers(status, workers) {
+    if (status === "failed" && workers.every((worker) => worker.executionState === "preflight_failed")) {
+        return "preflight_failed";
+    }
+    return bridgeStatusFromRunStatus(status);
+}
 function tmuxPaneAlive(paneId) {
     if (!commandAvailable("tmux")) {
         return false;
@@ -268,35 +391,169 @@ function tmuxPaneAlive(paneId) {
     }
 }
 function terminalStatus(status) {
-    return status === "completed" || status === "blocked" || status === "stopped" || status === "degraded";
+    return status === "completed" || status === "blocked" || status === "stopped" || status === "degraded" || status === "failed";
 }
-function launchWorkerPane(run, worker) {
-    const command = `bash ${shellQuote(worker.launcherPath)}`;
+function preflightNativeWorkerBridge(run) {
+    const failures = [
+        commandAvailable("tmux") ? null : "tmux:unavailable",
+        commandAvailable("codex") ? null : "codex:unavailable",
+        commandAvailable("git") ? null : "git:unavailable"
+    ].filter((entry) => Boolean(entry));
+    if (!process.env.TMUX && !process.env.TMUX_PANE) {
+        failures.push("tmux:attached-pane-unavailable");
+    }
+    try {
+        execFileSync("tmux", ["display-message", "-p", "#{pane_id}"], { stdio: "ignore" });
+    }
+    catch {
+        failures.push("tmux:current-pane-unavailable");
+    }
     try {
-        return execFileSync("tmux", [
-            "new-window",
-            "-d",
-            "-P",
-            "-F",
-            "#{pane_id}",
-            "-n",
-            `lt-${worker.id.slice(0, 12)}`,
-            command
-        ], { encoding: "utf8" }).trim();
+        gitOutput(run.workingDirectory, ["rev-parse", "--is-inside-work-tree"]);
     }
     catch {
-        const sessionName = `longtable-${run.id}-${worker.id}`.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 80);
-        return execFileSync("tmux", [
-            "new-session",
-            "-d",
-            "-P",
-            "-F",
-            "#{pane_id}",
-            "-s",
-            sessionName,
-            command
-        ], { encoding: "utf8" }).trim();
+        failures.push("git:working-directory-unavailable");
+    }
+    return failures;
+}
+function applyLeaderTrackedChanges(run, worker) {
+    if (!worker.worktreePath) {
+        return undefined;
+    }
+    const patch = execFileSync("git", ["diff", "--binary", "HEAD"], {
+        cwd: run.workingDirectory,
+        encoding: "buffer",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (patch.length === 0) {
+        return undefined;
+    }
+    try {
+        execFileSync("git", ["apply", "--check", "--whitespace=nowarn", "-"], {
+            cwd: worker.worktreePath,
+            input: patch,
+            stdio: ["pipe", "ignore", "pipe"]
+        });
+        execFileSync("git", ["apply", "--whitespace=nowarn", "-"], {
+            cwd: worker.worktreePath,
+            input: patch,
+            stdio: ["pipe", "ignore", "pipe"]
+        });
+        return "Leader tracked workspace changes were applied to the worker worktree before launch.";
+    }
+    catch (error) {
+        try {
+            execFileSync("git", ["apply", "--reverse", "--check", "--whitespace=nowarn", "-"], {
+                cwd: worker.worktreePath,
+                input: patch,
+                stdio: ["pipe", "ignore", "pipe"]
+            });
+            return "Leader tracked workspace changes were already present in the worker worktree before launch.";
+        }
+        catch {
+            throw error;
+        }
+    }
+}
+async function markBridgePreflightFailed(run, failures) {
+    const updatedAt = nowIso();
+    const reason = failures.join(", ");
+    const nextRun = {
+        ...run,
+        status: "failed",
+        bridgeStatus: "preflight_failed",
+        bridgeFailureReason: reason,
+        updatedAt,
+        diagnostics: [...run.diagnostics, ...failures, "Native worker bridge preflight failed; sequential fallback was not executed implicitly."],
+        workers: run.workers.map((worker) => ({
+            ...worker,
+            status: worker.status === "completed" ? worker.status : "failed",
+            executionState: "preflight_failed",
+            failureReason: reason,
+            error: reason,
+            updatedAt,
+            diagnostics: appendDiagnostic(worker.diagnostics, "Native worker bridge preflight failed before launch.")
+        }))
+    };
+    await appendLifecycleEvent(nextRun, { type: "preflight_failed", message: reason });
+    await writePanelWorkerRun(nextRun);
+    return nextRun;
+}
+async function provisionWorkerWorktree(run, worker) {
+    if (!worker.worktreePath || !worker.worktreeBranch) {
+        throw new Error(`missing worktree metadata for ${worker.id}`);
     }
+    await mkdir(dirname(worker.worktreePath), { recursive: true });
+    if (!existsSync(worker.worktreePath)) {
+        try {
+            gitOutput(run.workingDirectory, ["worktree", "add", worker.worktreePath, "-b", worker.worktreeBranch, "HEAD"]);
+        }
+        catch (firstError) {
+            try {
+                gitOutput(run.workingDirectory, ["worktree", "add", worker.worktreePath, worker.worktreeBranch]);
+            }
+            catch {
+                throw firstError;
+            }
+        }
+    }
+    const commit = currentGitCommit(worker.worktreePath);
+    const snapshotDiagnostic = applyLeaderTrackedChanges(run, worker);
+    await mkdir(workerRuntimeDirectory(worker), { recursive: true });
+    await writeFile(worker.mailboxPath ?? join(workerRuntimeDirectory(worker), "mailbox.jsonl"), "", { flag: "a" });
+    await appendLifecycleEvent(run, {
+        workerId: worker.id,
+        type: "worktree_provisioned",
+        message: `Worker worktree provisioned at ${worker.worktreePath}.`,
+        path: worker.worktreePath
+    });
+    return {
+        ...worker,
+        worktreeCommit: commit,
+        cleanupStatus: "retained",
+        executionState: "provisioned",
+        diagnostics: snapshotDiagnostic
+            ? appendDiagnostic(appendDiagnostic(worker.diagnostics, "Writable git worktree provisioned for LongTable native worker."), snapshotDiagnostic)
+            : appendDiagnostic(worker.diagnostics, "Writable git worktree provisioned for LongTable native worker.")
+    };
+}
+async function writeWorkerTask(run, worker) {
+    await mkdir(workerRuntimeDirectory(worker), { recursive: true });
+    await writeFile(worker.taskPath, workerTaskPrompt(run, worker), "utf8");
+}
+async function clearWorkerAttemptArtifacts(worker) {
+    const paths = [
+        worker.resultPath,
+        `${worker.resultPath}.stdout`,
+        `${worker.resultPath}.commit`,
+        worker.exitCodePath,
+        worker.logPath
+    ].filter((path) => typeof path === "string" && path.length > 0);
+    await Promise.all(paths.map((path) => rm(path, { force: true })));
+}
+function launchWorkerPane(run, worker) {
+    const command = `cd ${shellQuote(worker.worktreePath ?? run.workingDirectory)} && bash ${shellQuote(worker.launcherPath)}`;
+    const args = [
+        "split-window",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}"
+    ];
+    if (process.env.TMUX_PANE) {
+        args.push("-t", process.env.TMUX_PANE);
+    }
+    args.push(command);
+    const paneId = execFileSync("tmux", args, { encoding: "utf8" }).trim();
+    if (paneId) {
+        try {
+            execFileSync("tmux", ["set-option", "-p", "-t", paneId, "remain-on-exit", "on"], { stdio: "ignore" });
+        }
+        catch {
+            // Pane retention is best-effort on older tmux versions; the pane id is still recorded.
+        }
+    }
+    return paneId;
 }
 async function writeWorkerLauncher(run, worker) {
     if (!worker.launcherPath) {
@@ -309,66 +566,81 @@ export async function launchPanelWorkerRun(run) {
     if (terminalStatus(run.status) || run.status === "stop_requested") {
         return run;
     }
-    const tmuxAvailable = commandAvailable("tmux");
-    const codexAvailable = commandAvailable("codex");
-    if (!tmuxAvailable || !codexAvailable) {
-        const unavailable = [
-            tmuxAvailable ? null : "tmux:unavailable",
-            codexAvailable ? null : "codex:unavailable"
-        ].filter((entry) => Boolean(entry));
-        const nextRun = {
-            ...run,
-            status: "degraded",
-            updatedAt: nowIso(),
-            diagnostics: [...run.diagnostics, ...unavailable, "Native worker launch degraded; use sequential_fallback or resume when local runtime is available."],
-            workers: run.workers.map((worker) => worker.status === "completed"
-                ? worker
-                : {
-                    ...worker,
-                    status: "pending",
-                    updatedAt: nowIso(),
-                    diagnostics: appendDiagnostic(worker.diagnostics, "Launch skipped because tmux or codex is unavailable.")
-                })
-        };
-        await writePanelWorkerRun(nextRun);
-        return nextRun;
+    const preflightFailures = preflightNativeWorkerBridge(run);
+    if (preflightFailures.length > 0) {
+        return markBridgePreflightFailed(run, preflightFailures);
     }
     const launchedAt = nowIso();
-    const workers = await Promise.all(run.workers.map(async (worker) => {
+    const workers = [];
+    for (const worker of run.workers) {
         if (worker.status !== "pending" && worker.status !== "stopped" && worker.status !== "failed") {
-            return worker;
+            workers.push(worker);
+            continue;
         }
-        const launchable = {
-            ...worker,
-            launcherPath: worker.launcherPath ?? join(run.launcherDirectory, `${worker.id}.sh`),
-            exitCodePath: worker.exitCodePath ?? join(run.resultDirectory, `${worker.id}.exit.json`)
-        };
-        await writeWorkerLauncher(run, launchable);
         try {
+            const provisioned = await provisionWorkerWorktree(run, {
+                ...worker,
+                launcherPath: worker.launcherPath ?? join(run.launcherDirectory, `${worker.id}.sh`),
+                exitCodePath: worker.exitCodePath ?? join(run.resultDirectory, `${worker.id}.exit.json`),
+                executionState: "provisioning"
+            });
+            const launchable = {
+                ...provisioned,
+                executionState: "launching"
+            };
+            await writeWorkerTask(run, launchable);
+            await writeWorkerLauncher(run, launchable);
             const paneId = launchWorkerPane(run, launchable);
-            return {
+            const launchedWorker = {
                 ...launchable,
                 status: "running",
                 paneId: paneId || launchable.paneId,
+                runtime: {
+                    transport: "tmux",
+                    paneId: paneId || launchable.paneId,
+                    paneTarget: process.env.TMUX_PANE,
+                    splitCommand: "split-window",
+                    retainPane: true,
+                    launchedAt
+                },
+                executionState: "running",
                 startedAt: launchedAt,
                 updatedAt: launchedAt,
-                diagnostics: appendDiagnostic(launchable.diagnostics, "Launched with tmux/codex read-only native worker command; launcher persists the structured final output file.")
+                diagnostics: appendDiagnostic(launchable.diagnostics, "Launched in a retained current-window tmux split pane with Codex workspace-write scoped to the worker worktree.")
             };
+            await appendLifecycleEvent(run, {
+                workerId: worker.id,
+                type: "worker_launched",
+                message: `Worker launched in tmux split pane ${paneId}.`,
+                path: launchable.worktreePath
+            });
+            workers.push(launchedWorker);
         }
         catch (error) {
-            return {
-                ...launchable,
+            const failedWorker = {
+                ...worker,
                 status: "failed",
+                executionState: worker.worktreePath && existsSync(worker.worktreePath) ? "launch_failed" : "provision_failed",
+                failureReason: error instanceof Error ? error.message : String(error),
                 updatedAt: nowIso(),
                 error: error instanceof Error ? error.message : String(error),
-                diagnostics: appendDiagnostic(launchable.diagnostics, "tmux launch failed before worker result was created.")
+                diagnostics: appendDiagnostic(worker.diagnostics, "Native worker bridge provisioning or tmux launch failed before worker result was created.")
             };
+            await appendLifecycleEvent(run, {
+                workerId: worker.id,
+                type: "worker_failed",
+                message: failedWorker.error ?? "worker launch failed",
+                path: worker.worktreePath
+            });
+            workers.push(failedWorker);
         }
-    }));
+    }
     const nextRun = {
         ...run,
         workers,
         status: statusFromWorkers(workers),
+        bridgeStatus: bridgeStatusFromWorkers(statusFromWorkers(workers), workers),
+        bridgeFailureReason: workers.find((worker) => worker.status === "failed")?.error,
         updatedAt: nowIso()
     };
     await writePanelWorkerRun(nextRun);
@@ -405,12 +677,21 @@ export async function refreshPanelWorkerRun(run) {
             }
             memberResults.push(result);
             const nextStatus = result.status === "error" ? "failed" : result.status === "blocked" ? "blocked" : "completed";
+            const commitPath = `${worker.resultPath}.commit`;
+            const worktreeCommit = existsSync(commitPath)
+                ? readFileSyncUtf8(commitPath).trim()
+                : worker.worktreePath
+                    ? currentGitCommit(worker.worktreePath)
+                    : worker.worktreeCommit;
             return {
                 ...worker,
                 status: nextStatus,
+                executionState: nextStatus === "completed" || nextStatus === "blocked" ? "result_ready" : "launch_failed",
                 completedAt: nextStatus === "failed" ? worker.completedAt : updatedAt,
+                worktreeCommit,
                 updatedAt,
-                error: result.error
+                error: result.error,
+                failureReason: nextStatus === "failed" ? result.error : worker.failureReason
             };
         }
         catch (error) {
@@ -427,6 +708,8 @@ export async function refreshPanelWorkerRun(run) {
         ...run,
         workers,
         status: statusFromWorkers(workers),
+        bridgeStatus: bridgeStatusFromWorkers(statusFromWorkers(workers), workers),
+        bridgeFailureReason: workers.find((worker) => worker.status === "failed")?.error,
         updatedAt
     };
     if (nextRun.status === "completed" || nextRun.status === "blocked") {
@@ -457,6 +740,7 @@ export async function requestPanelWorkerStop(run) {
     const nextRun = {
         ...run,
         status: "stop_requested",
+        bridgeStatus: "stop_requested",
         updatedAt,
         workers: run.workers.map((worker) => {
             if (worker.status === "completed") {
@@ -475,20 +759,32 @@ export async function requestPanelWorkerStop(run) {
             return {
                 ...worker,
                 status: stopped ? "stopped" : "stop_requested",
+                executionState: stopped ? "stopped" : "stopping",
+                runtime: worker.runtime
+                    ? { ...worker.runtime, stoppedAt: updatedAt }
+                    : worker.paneId
+                        ? { transport: "tmux", paneId: worker.paneId, retainPane: true, stoppedAt: updatedAt }
+                        : worker.runtime,
                 updatedAt,
                 diagnostics: appendDiagnostic(worker.diagnostics, "Stop requested through LongTable panel runtime.")
             };
         })
     };
+    await appendLifecycleEvent(nextRun, { type: "stop_requested", message: "Stop requested through LongTable panel runtime." });
     await writePanelWorkerRun(nextRun);
     return nextRun;
 }
 export async function resumePanelWorkerRun(run) {
     const updatedAt = nowIso();
     await rm(run.stopFilePath, { force: true });
+    await Promise.all(run.workers
+        .filter((worker) => worker.status !== "completed")
+        .map((worker) => clearWorkerAttemptArtifacts(worker)));
     const nextRun = {
         ...run,
         status: "planned",
+        bridgeStatus: "not_requested",
+        bridgeFailureReason: undefined,
         updatedAt,
         workers: run.workers.map((worker) => worker.status === "completed"
             ? worker
@@ -497,10 +793,73 @@ export async function resumePanelWorkerRun(run) {
                 status: "pending",
                 paneId: undefined,
                 error: undefined,
+                failureReason: undefined,
+                executionState: "not_started",
                 updatedAt,
                 diagnostics: appendDiagnostic(worker.diagnostics, "Resume requested; worker is ready to be relaunched.")
             })
     };
+    await appendLifecycleEvent(nextRun, { type: "resume_requested", message: "Resume requested; incomplete workers are ready to relaunch." });
+    await writePanelWorkerRun(nextRun);
+    return nextRun;
+}
+export async function shutdownPanelWorkerRun(run) {
+    const updatedAt = nowIso();
+    await writeFile(run.stopFilePath, `${updatedAt}\n`, "utf8");
+    const workers = [];
+    for (const worker of run.workers) {
+        let cleanupStatus = worker.cleanupStatus ?? "not_started";
+        let cleanupError;
+        if (worker.paneId && commandAvailable("tmux")) {
+            try {
+                execFileSync("tmux", ["kill-pane", "-t", worker.paneId], { stdio: "ignore" });
+            }
+            catch {
+                // A missing pane is already shut down for LongTable lifecycle purposes.
+            }
+        }
+        if (worker.worktreePath && existsSync(worker.worktreePath) && commandAvailable("git")) {
+            try {
+                gitOutput(run.workingDirectory, ["worktree", "remove", "--force", worker.worktreePath]);
+                cleanupStatus = "removed";
+            }
+            catch (error) {
+                cleanupStatus = "failed";
+                cleanupError = error instanceof Error ? error.message : String(error);
+                await appendLifecycleEvent(run, {
+                    workerId: worker.id,
+                    type: "cleanup_failed",
+                    message: cleanupError,
+                    path: worker.worktreePath
+                });
+            }
+        }
+        workers.push({
+            ...worker,
+            status: worker.status === "completed" ? "completed" : "stopped",
+            executionState: cleanupStatus === "failed" ? "cleanup_failed" : "shutdown",
+            shutdownRequestedAt: updatedAt,
+            cleanupStatus,
+            error: cleanupError ?? worker.error,
+            failureReason: cleanupError ?? worker.failureReason,
+            runtime: worker.runtime
+                ? { ...worker.runtime, shutdownAt: updatedAt }
+                : worker.paneId
+                    ? { transport: "tmux", paneId: worker.paneId, retainPane: true, shutdownAt: updatedAt }
+                    : worker.runtime,
+            updatedAt,
+            diagnostics: appendDiagnostic(worker.diagnostics, "Shutdown requested through LongTable panel runtime.")
+        });
+    }
+    const nextRun = {
+        ...run,
+        status: workers.some((worker) => worker.cleanupStatus === "failed") ? "failed" : "stopped",
+        bridgeStatus: workers.some((worker) => worker.cleanupStatus === "failed") ? "failed" : "shutdown",
+        bridgeFailureReason: workers.find((worker) => worker.cleanupStatus === "failed")?.error,
+        workers,
+        updatedAt
+    };
+    await appendLifecycleEvent(nextRun, { type: "shutdown_requested", message: "Shutdown requested; panes killed and worker worktrees removed when possible." });
     await writePanelWorkerRun(nextRun);
     return nextRun;
 }

package/dist/panel.js

@@ -85,11 +85,11 @@ export function buildPanelPlan(options) {
         rationale: [
             "Option A uses provider-neutral panel semantics before native provider orchestration.",
             preferredSurface === "native_workers"
-                ? "LongTable-native workers may execute role passes through durable worker state; outputs must normalize back to this PanelResult."
+                ? "LongTable-native workers may execute role passes through durable worker state; outputs must normalize back to this PanelResult, and bridge failure must be reported separately from any later sequential fallback."
                 : preferredSurface === "native_subagents"
                     ? "Codex native subagents may execute the role passes when the current provider session exposes them; outputs must normalize back to this PanelResult."
                     : "Sequential fallback is the stable execution path for both Claude Code and Codex.",
-            "Sequential fallback remains the required degradation path.",
+            "Sequential fallback remains the ordinary degradation path, but it is not treated as executed merely because a native-worker bridge request failed.",
             roles.length === explicitRoles.length && explicitRoles.length > 0
                 ? "The panel is constrained by explicitly requested roles."
                 : "The panel combines default research-review roles with prompt-triggered roles."
@@ -194,7 +194,7 @@ export function createPlannedInvocationRecord(options) {
         panelPlan: options.plan,
         panelResult: options.result,
         degradationReason: options.plan.preferredSurface === "native_workers"
-            ? "LongTable-native panel workers are optional; sequential_fallback is the required degradation path when local worker execution is unavailable."
+            ? "LongTable-native panel workers are optional; bridge failure is reported explicitly, and sequential_fallback remains available only when it is deliberately executed."
             : options.plan.preferredSurface === "native_subagents"
                 ? "Codex native subagent execution is session-dependent; sequential_fallback is the required LongTable degradation path."
                 : "Sequential fallback is the stable LongTable panel surface."
@@ -225,7 +225,7 @@ export function renderSequentialFallbackPrompt(plan) {
         : plan.preferredSurface === "native_workers"
             ? [
                 "Preferred execution surface: LongTable-native panel workers when the local runtime supports them.",
-                "Fallback: if native workers are unavailable or stopped, run the same role passes sequentially and disclose the fallback in the technical record."
+                "Fallback: if native workers are unavailable or stopped, report the bridge failure explicitly; run sequential fallback only as a deliberate fallback execution and disclose it in the technical record."
             ]
             : ["Execution surface: sequential_fallback"];
     return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -29,12 +29,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@longtable/checkpoints": "0.1.56",
-    "@longtable/core": "0.1.56",
-    "@longtable/memory": "0.1.56",
-    "@longtable/provider-claude": "0.1.56",
-    "@longtable/provider-codex": "0.1.56",
-    "@longtable/setup": "0.1.56"
+    "@longtable/checkpoints": "0.1.58",
+    "@longtable/core": "0.1.58",
+    "@longtable/memory": "0.1.58",
+    "@longtable/provider-claude": "0.1.58",
+    "@longtable/provider-codex": "0.1.58",
+    "@longtable/setup": "0.1.58"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",