parallel-codex-tui 0.1.3 → 0.1.5

package/dist/workers/process-adapter.js

@@ -1,6 +1,13 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
 import { appendText, writeJson } from "../core/file-store.js";
+import { clearWorkerProcessRecord, writeWorkerProcessRecord } from "../core/process-ownership.js";
+import { terminateProcessTree } from "../core/process-tree.js";
 import { detectNativeSessionId } from "./native-session-detection.js";
+const WORKER_DIAGNOSTIC_TAIL_CHARS = 64 * 1024;
+const RESUME_DETECTION_OVERLAP_CHARS = 512;
+const RESUME_REASON_CHARS = 2048;
 export class ProcessWorkerAdapter {
     name;
     command;
@@ -14,7 +21,8 @@ export class ProcessWorkerAdapter {
     }
     async run(spec) {
         const model = spec.modelConfig ?? this.defaults.model;
-        const launch = buildLaunch(this.args, spec.nativeSession, spec.nativeSessionConfig, model);
+        const capabilities = resolveWorkerCapabilities(this.name, this.defaults.capabilities);
+        const launch = buildLaunch(this.args, spec.nativeSession, spec.nativeSessionConfig, model, capabilities, spec.writableDirs, spec.enforceWorkspaceIsolation);
         const runSpec = {
             ...spec,
             timeoutMs: spec.timeoutMs ?? this.defaults.timeoutMs,
@@ -23,7 +31,9 @@ export class ProcessWorkerAdapter {
             nativeSession: launch.nativeSession,
             modelConfig: model
         };
-        const first = await this.runAttempt(runSpec, launch);
+        const first = await this.runAttempt(runSpec, launch, {
+            initialNativeSessionId: launch.initialNativeSessionId
+        });
         if (!shouldFallbackToNewNativeSession(first, runSpec.nativeSessionConfig)) {
             return first.result;
         }
@@ -32,20 +42,32 @@ export class ProcessWorkerAdapter {
             await runSpec.onNativeSessionRetired?.(retiredSessionId, first.output);
         }
         await appendText(runSpec.outputLogPath, `\nNative resume for ${retiredSessionId ?? "unknown session"} is unrecoverable; starting a fresh native session.\n`);
-        const freshLaunch = buildFreshLaunch(this.args, model);
+        const freshLaunch = buildFreshLaunch(this.args, model, capabilities, runSpec.writableDirs, runSpec.enforceWorkspaceIsolation, runSpec.nativeSessionConfig);
         return (await this.runAttempt({
             ...runSpec,
             nativeSession: null
         }, freshLaunch, {
-            initialNativeSessionId: undefined,
+            initialNativeSessionId: freshLaunch.initialNativeSessionId,
             startPhase: "native-resume-fallback",
             startSummary: `${this.command} starting fresh session after unrecoverable native resume`
         })).result;
     }
     async runAttempt(runSpec, launch, options = {}) {
+        if (runSpec.signal?.aborted) {
+            const result = {
+                workerId: runSpec.workerId,
+                exitCode: 130,
+                signal: "SIGTERM",
+                cancelled: true
+            };
+            await setStatus(runSpec, "cancelled", "process-cancelled", `${this.command} cancelled before start`);
+            await appendText(runSpec.outputLogPath, "Process cancelled by user before start\n");
+            return { result, output: "", launch };
+        }
         await setStatus(runSpec, "starting", options.startPhase ?? "process-starting", options.startSummary ?? `Starting ${this.command}`);
         await appendText(runSpec.outputLogPath, `$ ${formatShellCommand(this.command, launch.args)}\n`);
         return new Promise((resolve, reject) => {
+            const detached = process.platform !== "win32";
             const child = spawn(this.command, launch.args, {
                 cwd: runSpec.cwd,
                 env: {
@@ -55,102 +77,354 @@ export class ProcessWorkerAdapter {
                     PARALLEL_CODEX_ROLE: runSpec.role,
                     PARALLEL_CODEX_FILES_DIR: runSpec.filesDir
                 },
-                stdio: ["pipe", "pipe", "pipe"]
+                stdio: ["pipe", "pipe", "pipe"],
+                detached
             });
+            let processRecordError;
+            const processRecordReady = typeof child.pid === "number"
+                ? writeWorkerProcessRecord(runSpec.filesDir, {
+                    workerId: runSpec.workerId,
+                    pid: child.pid,
+                    command: this.command,
+                    ...(detached ? { processGroupId: child.pid } : {})
+                }).then(() => undefined, (error) => {
+                    processRecordError = error;
+                })
+                : Promise.resolve();
             let settled = false;
+            let finishing = false;
             let timeout;
             let idleTimeout;
             let firstOutputTimeout;
+            let processTreeCleanup;
+            let abortListener;
             let terminalPhase;
             let terminalSummary;
+            let terminalState;
             let outputWrites = Promise.resolve();
+            let persistenceError;
+            let hasPersistenceError = false;
             let detectedNativeSessionId = options.initialNativeSessionId ?? runSpec.nativeSession?.session_id;
+            let initialNativeSessionPersisted = !options.initialNativeSessionId;
+            const persistedNativeSessionId = () => (initialNativeSessionPersisted ? detectedNativeSessionId : undefined);
+            let stdoutSessionDetectionTail = "";
+            let stderrSessionDetectionTail = "";
             let sawOutput = false;
-            const outputChunks = [];
-            const finish = async (result) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
+            let outputTail = "";
+            let stdoutResumeDetectionTail = "";
+            let stderrResumeDetectionTail = "";
+            let unrecoverableResumeReason;
+            const stdoutDecoder = new StringDecoder("utf8");
+            const stderrDecoder = new StringDecoder("utf8");
+            let outputDecodersEnded = false;
+            const clearRunTimers = () => {
                 if (timeout) {
                     clearTimeout(timeout);
+                    timeout = undefined;
                 }
                 if (idleTimeout) {
                     clearTimeout(idleTimeout);
+                    idleTimeout = undefined;
                 }
                 if (firstOutputTimeout) {
                     clearTimeout(firstOutputTimeout);
+                    firstOutputTimeout = undefined;
                 }
-                await outputWrites;
-                const phase = terminalPhase ?? (launch.isResume && result.exitCode !== 0 ? "native-resume-failed" : "process-exited");
-                const summary = terminalSummary ??
-                    (launch.isResume && result.exitCode !== 0
-                        ? `${this.command} native resume exited with code ${result.exitCode}`
-                        : `${this.command} exited with code ${result.exitCode}`);
-                await setStatus(runSpec, result.exitCode === 0 ? "done" : "failed", phase, summary, detectedNativeSessionId);
-                resolve({
-                    result,
-                    output: outputChunks.join(""),
-                    launch
+            };
+            const ensureProcessTreeStopped = () => {
+                processTreeCleanup ??= terminateProcessTree(child, {
+                    processGroup: detached,
+                    label: `${this.command} worker process`,
+                    termGraceMs: 1500,
+                    killWaitMs: 500,
+                    pollMs: 20
                 });
+                return processTreeCleanup;
+            };
+            const terminalFallbackResult = () => ({
+                workerId: runSpec.workerId,
+                exitCode: terminalState === "cancelled" ? 130 : 1,
+                signal: null,
+                ...(terminalState === "cancelled" ? { cancelled: true } : {})
+            });
+            const finishAfterCleanupFailure = (error) => {
+                void finish(terminalFallbackResult(), error);
+            };
+            const failForPersistence = (error) => {
+                if (!hasPersistenceError) {
+                    hasPersistenceError = true;
+                    persistenceError = error;
+                }
+                if (settled || terminalState) {
+                    return;
+                }
+                terminalState = "failed";
+                terminalPhase = "process-finalization-error";
+                terminalSummary = `${this.command} persistence failed: ${errorMessage(error)}`;
+                clearRunTimers();
+                void ensureProcessTreeStopped().catch(finishAfterCleanupFailure);
+            };
+            const queuePersistence = (operation) => {
+                outputWrites = outputWrites.then(async () => {
+                    if (hasPersistenceError) {
+                        return;
+                    }
+                    try {
+                        await operation();
+                    }
+                    catch (error) {
+                        failForPersistence(error);
+                    }
+                });
+            };
+            const recordDecodedOutput = (text, stream) => {
+                if (!text || settled || finishing) {
+                    return;
+                }
+                outputTail = appendBoundedTextTail(outputTail, text, WORKER_DIAGNOSTIC_TAIL_CHARS);
+                if (launch.isResume && !unrecoverableResumeReason) {
+                    const detectionTail = stream === "stdout" ? stdoutResumeDetectionTail : stderrResumeDetectionTail;
+                    const detectionText = `${detectionTail}${text}`;
+                    unrecoverableResumeReason = findUnrecoverableNativeResumeReason(detectionText);
+                    if (stream === "stdout") {
+                        stdoutResumeDetectionTail = detectionText.slice(-RESUME_DETECTION_OVERLAP_CHARS);
+                    }
+                    else {
+                        stderrResumeDetectionTail = detectionText.slice(-RESUME_DETECTION_OVERLAP_CHARS);
+                    }
+                }
+                queuePersistence(async () => {
+                    await appendText(runSpec.outputLogPath, text);
+                    if (!initialNativeSessionPersisted && options.initialNativeSessionId) {
+                        await runSpec.onNativeSession?.(options.initialNativeSessionId);
+                        initialNativeSessionPersisted = true;
+                    }
+                    if (!detectedNativeSessionId && runSpec.nativeSessionConfig?.detectSessionId !== false) {
+                        const detectionTail = stream === "stdout" ? stdoutSessionDetectionTail : stderrSessionDetectionTail;
+                        const detectionText = `${detectionTail}${text}`;
+                        const sessionId = detectNativeSessionId(detectionText);
+                        if (sessionId) {
+                            detectedNativeSessionId = sessionId;
+                            stdoutSessionDetectionTail = "";
+                            stderrSessionDetectionTail = "";
+                            await runSpec.onNativeSession?.(sessionId);
+                        }
+                        else if (stream === "stdout") {
+                            stdoutSessionDetectionTail = detectionText.slice(-512);
+                        }
+                        else {
+                            stderrSessionDetectionTail = detectionText.slice(-512);
+                        }
+                    }
+                    if (!settled && !terminalState) {
+                        await setStatus(runSpec, "running", "process-output", summarizeOutput(text), persistedNativeSessionId());
+                    }
+                });
+            };
+            const endOutputDecoders = () => {
+                if (outputDecodersEnded) {
+                    return;
+                }
+                outputDecodersEnded = true;
+                recordDecodedOutput(stdoutDecoder.end(), "stdout");
+                recordDecodedOutput(stderrDecoder.end(), "stderr");
+            };
+            const failAndTerminate = (phase, summary, logLine) => {
+                if (settled || terminalState) {
+                    return;
+                }
+                terminalState = "failed";
+                terminalPhase = phase;
+                terminalSummary = summary;
+                clearRunTimers();
+                queuePersistence(async () => {
+                    await appendText(runSpec.outputLogPath, logLine);
+                    await setStatus(runSpec, "running", "process-stopping", `${summary}; stopping process tree`, persistedNativeSessionId());
+                });
+                void ensureProcessTreeStopped().catch(finishAfterCleanupFailure);
+            };
+            const failForProcessOwnership = () => {
+                if (!processRecordError || settled || terminalState) {
+                    return;
+                }
+                const detail = processRecordError instanceof Error
+                    ? processRecordError.message
+                    : String(processRecordError);
+                failAndTerminate("process-ownership-error", `${this.command} process ownership could not be recorded: ${detail}`, `\nProcess ownership record failed: ${detail}\n`);
+            };
+            const rejectForFinalization = async (error) => {
+                settled = true;
+                const detail = errorMessage(error);
+                const phase = "process-finalization-error";
+                const summary = `${this.command} worker finalization failed: ${detail}`;
+                try {
+                    await appendText(runSpec.outputLogPath, `\nWorker finalization failed: ${detail}\n`);
+                }
+                catch {
+                    // Preserve the original finalization error.
+                }
+                try {
+                    await setStatus(runSpec, "failed", phase, summary, persistedNativeSessionId());
+                }
+                catch {
+                    // The ownership record remains the recovery authority when status cannot be written.
+                }
+                reject(new Error(summary, { cause: error }));
+            };
+            const finish = async (result, knownCleanupError) => {
+                if (settled || finishing) {
+                    return;
+                }
+                endOutputDecoders();
+                finishing = true;
+                try {
+                    clearRunTimers();
+                    if (abortListener) {
+                        runSpec.signal?.removeEventListener("abort", abortListener);
+                        abortListener = undefined;
+                    }
+                    await processRecordReady;
+                    failForProcessOwnership();
+                    let cleanupError = knownCleanupError;
+                    if (!cleanupError) {
+                        try {
+                            await ensureProcessTreeStopped();
+                        }
+                        catch (error) {
+                            cleanupError = error;
+                        }
+                    }
+                    settled = true;
+                    await outputWrites;
+                    if (cleanupError) {
+                        const detail = errorMessage(cleanupError);
+                        const phase = "process-cleanup-error";
+                        const summary = `${this.command} process tree cleanup failed: ${detail}`;
+                        await appendText(runSpec.outputLogPath, `\nProcess tree cleanup failed: ${detail}\n`);
+                        await setStatus(runSpec, "failed", phase, summary, persistedNativeSessionId());
+                        resolve({
+                            result: {
+                                workerId: runSpec.workerId,
+                                exitCode: result.exitCode || 1,
+                                signal: result.signal,
+                                failure: { phase, summary }
+                            },
+                            output: unrecoverableResumeReason ?? outputTail,
+                            launch
+                        });
+                        return;
+                    }
+                    if (hasPersistenceError) {
+                        throw persistenceError;
+                    }
+                    const phase = terminalPhase ?? (launch.isResume && result.exitCode !== 0 ? "native-resume-failed" : "process-exited");
+                    const summary = terminalSummary ??
+                        (launch.isResume && result.exitCode !== 0
+                            ? `${this.command} native resume exited with code ${result.exitCode}`
+                            : `${this.command} exited with code ${result.exitCode}`);
+                    await setStatus(runSpec, terminalState ?? (result.exitCode === 0 ? "done" : "failed"), phase, summary, persistedNativeSessionId());
+                    if (!processRecordError) {
+                        await clearWorkerProcessRecord(runSpec.filesDir);
+                    }
+                    const finalResult = {
+                        ...result,
+                        ...(terminalState === "cancelled" ? { cancelled: true } : {}),
+                        ...(terminalState === "failed"
+                            ? { failure: { phase, summary } }
+                            : {})
+                    };
+                    resolve({
+                        result: finalResult,
+                        output: unrecoverableResumeReason ?? outputTail,
+                        launch
+                    });
+                }
+                catch (error) {
+                    await rejectForFinalization(error);
+                }
             };
             const resetIdleTimeout = () => {
-                if (!runSpec.idleTimeoutMs || runSpec.idleTimeoutMs <= 0 || settled) {
+                if (!runSpec.idleTimeoutMs || runSpec.idleTimeoutMs <= 0 || settled || terminalState) {
+                    return;
+                }
+                if (!sawOutput) {
+                    return;
+                }
+                if (runSpec.timeoutMs
+                    && runSpec.timeoutMs > 0
+                    && runSpec.idleTimeoutMs >= runSpec.timeoutMs) {
                     return;
                 }
                 if (idleTimeout) {
                     clearTimeout(idleTimeout);
                 }
                 idleTimeout = setTimeout(() => {
-                    terminalPhase = "process-idle-timeout";
-                    terminalSummary = `${this.command} produced no output for ${runSpec.idleTimeoutMs}ms`;
-                    void appendText(runSpec.outputLogPath, `\nProcess idle timed out after ${runSpec.idleTimeoutMs}ms\n`);
-                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary);
-                    child.kill("SIGTERM");
+                    failAndTerminate("process-idle-timeout", `${this.command} produced no output for ${runSpec.idleTimeoutMs}ms`, `\nProcess idle timed out after ${runSpec.idleTimeoutMs}ms\n`);
                 }, runSpec.idleTimeoutMs);
             };
-            const recordOutput = (chunk) => {
+            const recordOutput = (chunk, decoder, stream) => {
+                if (settled || finishing) {
+                    return;
+                }
                 sawOutput = true;
                 if (firstOutputTimeout) {
                     clearTimeout(firstOutputTimeout);
                     firstOutputTimeout = undefined;
                 }
-                const text = chunk.toString("utf8");
-                outputChunks.push(text);
-                outputWrites = outputWrites.then(async () => {
-                    await appendText(runSpec.outputLogPath, text);
-                    const sessionId = detectNativeSessionId(text);
-                    if (sessionId && sessionId !== detectedNativeSessionId && runSpec.nativeSessionConfig?.detectSessionId !== false) {
-                        detectedNativeSessionId = sessionId;
-                        await runSpec.onNativeSession?.(sessionId);
-                    }
-                    if (!settled) {
-                        await setStatus(runSpec, "running", "process-output", summarizeOutput(text), detectedNativeSessionId);
-                    }
-                });
+                recordDecodedOutput(decoder.write(chunk), stream);
                 resetIdleTimeout();
             };
             child.stdout.on("data", (chunk) => {
-                recordOutput(chunk);
+                recordOutput(chunk, stdoutDecoder, "stdout");
             });
             child.stderr.on("data", (chunk) => {
-                recordOutput(chunk);
+                recordOutput(chunk, stderrDecoder, "stderr");
             });
             child.on("error", (error) => {
                 if (settled) {
                     return;
                 }
-                settled = true;
-                if (timeout) {
-                    clearTimeout(timeout);
+                if (terminalState) {
+                    void finish({
+                        workerId: runSpec.workerId,
+                        exitCode: terminalState === "cancelled" ? 130 : 1,
+                        signal: null,
+                        ...(terminalState === "cancelled" ? { cancelled: true } : {})
+                    });
+                    return;
                 }
-                if (idleTimeout) {
-                    clearTimeout(idleTimeout);
+                if (runSpec.signal?.aborted) {
+                    terminalState = "cancelled";
+                    terminalPhase = "process-cancelled";
+                    terminalSummary = `${this.command} cancelled by user`;
+                    void finish({
+                        workerId: runSpec.workerId,
+                        exitCode: 130,
+                        signal: "SIGTERM",
+                        cancelled: true
+                    });
+                    return;
                 }
-                if (firstOutputTimeout) {
-                    clearTimeout(firstOutputTimeout);
+                endOutputDecoders();
+                settled = true;
+                clearRunTimers();
+                if (abortListener) {
+                    runSpec.signal?.removeEventListener("abort", abortListener);
                 }
-                void setStatus(runSpec, "failed", "process-error", error.message, detectedNativeSessionId).finally(() => reject(error));
+                void (async () => {
+                    try {
+                        await processRecordReady;
+                        await ensureProcessTreeStopped();
+                        await setStatus(runSpec, "failed", "process-error", error.message, persistedNativeSessionId());
+                        if (!processRecordError) {
+                            await clearWorkerProcessRecord(runSpec.filesDir);
+                        }
+                        reject(error);
+                    }
+                    catch (finalizationError) {
+                        await rejectForFinalization(finalizationError);
+                    }
+                })();
             });
             child.on("close", (code, signal) => {
                 void finish({
@@ -159,53 +433,225 @@ export class ProcessWorkerAdapter {
                     signal
                 });
             });
+            child.stdin.once("error", (error) => {
+                failAndTerminate("process-input-error", `${this.command} input failed: ${error.message}`, `\nProcess input failed: ${error.message}\n`);
+            });
+            abortListener = () => {
+                if (settled || terminalState) {
+                    return;
+                }
+                terminalState = "cancelled";
+                terminalPhase = "process-cancelled";
+                terminalSummary = `${this.command} cancelled by user`;
+                clearRunTimers();
+                queuePersistence(async () => {
+                    await appendText(runSpec.outputLogPath, "\nProcess cancelled by user\n");
+                    await setStatus(runSpec, "running", "process-stopping", `${terminalSummary}; stopping process tree`, persistedNativeSessionId());
+                });
+                void ensureProcessTreeStopped().catch(finishAfterCleanupFailure);
+            };
+            runSpec.signal?.addEventListener("abort", abortListener, { once: true });
             if (runSpec.timeoutMs && runSpec.timeoutMs > 0) {
                 timeout = setTimeout(() => {
-                    terminalPhase = "process-timeout";
-                    terminalSummary = `${this.command} exceeded ${runSpec.timeoutMs}ms`;
-                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary, detectedNativeSessionId);
-                    child.kill("SIGTERM");
-                    void appendText(runSpec.outputLogPath, `\nProcess timed out after ${runSpec.timeoutMs}ms\n`);
+                    failAndTerminate("process-timeout", `${this.command} exceeded ${runSpec.timeoutMs}ms`, `\nProcess timed out after ${runSpec.timeoutMs}ms\n`);
                 }, runSpec.timeoutMs);
             }
-            if (runSpec.firstOutputTimeoutMs && runSpec.firstOutputTimeoutMs > 0) {
+            if (runSpec.firstOutputTimeoutMs
+                && runSpec.firstOutputTimeoutMs > 0
+                && (!runSpec.timeoutMs || runSpec.timeoutMs <= 0 || runSpec.firstOutputTimeoutMs < runSpec.timeoutMs)) {
                 firstOutputTimeout = setTimeout(() => {
                     if (sawOutput || settled) {
                         return;
                     }
-                    terminalPhase = "process-first-output-timeout";
-                    terminalSummary = `${this.command} produced no first output for ${runSpec.firstOutputTimeoutMs}ms`;
-                    void setStatus(runSpec, "failed", terminalPhase, terminalSummary, detectedNativeSessionId);
-                    child.kill("SIGTERM");
-                    void appendText(runSpec.outputLogPath, `\nProcess produced no first output after ${runSpec.firstOutputTimeoutMs}ms\n`);
+                    failAndTerminate("process-first-output-timeout", `${this.command} produced no first output for ${runSpec.firstOutputTimeoutMs}ms`, `\nProcess produced no first output after ${runSpec.firstOutputTimeoutMs}ms\n`);
                 }, runSpec.firstOutputTimeoutMs);
             }
-            void setStatus(runSpec, "running", "process-running", `${this.command} running`, detectedNativeSessionId);
-            resetIdleTimeout();
-            child.stdin.write(runSpec.prompt);
-            child.stdin.end();
+            void processRecordReady.then(() => {
+                failForProcessOwnership();
+                if (processRecordError || settled || finishing || terminalState) {
+                    return;
+                }
+                if (runSpec.signal?.aborted) {
+                    abortListener?.();
+                }
+                else {
+                    child.stdin.end(runSpec.prompt);
+                }
+            });
         });
     }
 }
-function buildLaunch(defaultArgs, nativeSession, nativeSessionConfig, modelConfig) {
+function buildLaunch(defaultArgs, nativeSession, nativeSessionConfig, modelConfig, capabilities, writableDirs, enforceWorkspaceIsolation = false) {
     const modelArgs = buildModelArgs(modelConfig);
     if (!nativeSession || !nativeSessionConfig?.enabled || nativeSessionConfig.resumeArgs.length === 0) {
-        return buildFreshLaunch(defaultArgs, modelConfig);
+        return buildFreshLaunch(defaultArgs, modelConfig, capabilities, writableDirs, enforceWorkspaceIsolation, nativeSessionConfig);
     }
     return {
-        args: [
+        args: withWritableDirectoryArgs(enforceWorkerIsolationArgs([
             ...nativeSessionConfig.resumeArgs.map((arg) => renderTemplate(arg, nativeSession.session_id, modelConfig)),
             ...modelArgs
-        ],
+        ], capabilities.profile, enforceWorkspaceIsolation), capabilities, true, writableDirs),
         isResume: true,
         nativeSession
     };
 }
-function buildFreshLaunch(defaultArgs, modelConfig) {
+function buildFreshLaunch(defaultArgs, modelConfig, capabilities, writableDirs, enforceWorkspaceIsolation = false, nativeSessionConfig) {
+    const isolatedArgs = enforceWorkerIsolationArgs([...defaultArgs, ...buildModelArgs(modelConfig)], capabilities.profile, enforceWorkspaceIsolation);
+    const freshSession = withFreshSessionId(isolatedArgs, capabilities, nativeSessionConfig, modelConfig);
     return {
-        args: [...defaultArgs, ...buildModelArgs(modelConfig)],
+        args: withWritableDirectoryArgs(freshSession.args, capabilities, false, writableDirs),
         isResume: false,
-        nativeSession: null
+        nativeSession: null,
+        ...(freshSession.sessionId ? { initialNativeSessionId: freshSession.sessionId } : {})
+    };
+}
+function withFreshSessionId(args, capabilities, nativeSessionConfig, modelConfig) {
+    if (!nativeSessionConfig?.enabled
+        || nativeSessionConfig.detectSessionId === false
+        || nativeSessionConfig.resumeArgs.length === 0
+        || capabilities.freshSessionArgs.length === 0) {
+        return { args };
+    }
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--session-id") {
+            const sessionId = args[index + 1]?.trim();
+            return sessionId ? { args, sessionId } : { args };
+        }
+        const match = arg.match(/^--session-id=(.+)$/);
+        if (match?.[1]?.trim()) {
+            return { args, sessionId: match[1].trim() };
+        }
+    }
+    const sessionId = randomUUID();
+    return {
+        args: [
+            ...args,
+            ...capabilities.freshSessionArgs.map((arg) => renderTemplate(arg, sessionId, modelConfig))
+        ],
+        sessionId
+    };
+}
+function enforceWorkerIsolationArgs(args, profile, enforce) {
+    if (!enforce) {
+        return args;
+    }
+    if (profile === "codex") {
+        return enforceCodexWorkspaceSandbox(args);
+    }
+    if (profile === "claude") {
+        return enforceClaudeEditPermissions(args);
+    }
+    return args;
+}
+function enforceCodexWorkspaceSandbox(args) {
+    const result = [];
+    let hasSandbox = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--dangerously-bypass-approvals-and-sandbox") {
+            continue;
+        }
+        if (arg === "--sandbox" || arg === "-s") {
+            result.push(arg, "workspace-write");
+            hasSandbox = true;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--sandbox=") || arg.startsWith("-s=")) {
+            result.push(arg.startsWith("-s=") ? "-s=workspace-write" : "--sandbox=workspace-write");
+            hasSandbox = true;
+            continue;
+        }
+        result.push(arg);
+    }
+    if (!hasSandbox) {
+        const execIndex = result.indexOf("exec");
+        const promptIndex = result.lastIndexOf("-");
+        const insertAt = execIndex >= 0 ? execIndex + 1 : promptIndex >= 0 ? promptIndex : result.length;
+        result.splice(insertAt, 0, "--sandbox", "workspace-write");
+    }
+    return result;
+}
+function enforceClaudeEditPermissions(args) {
+    const result = [];
+    let hasPermissionMode = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? "";
+        if (arg === "--dangerously-skip-permissions") {
+            continue;
+        }
+        if (arg === "--permission-mode") {
+            result.push(arg, "acceptEdits");
+            hasPermissionMode = true;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--permission-mode=")) {
+            result.push("--permission-mode=acceptEdits");
+            hasPermissionMode = true;
+            continue;
+        }
+        result.push(arg);
+    }
+    if (!hasPermissionMode) {
+        result.push("--permission-mode", "acceptEdits");
+    }
+    return result;
+}
+function withWritableDirectoryArgs(args, capabilities, isResume, writableDirs) {
+    const directories = [...new Set((writableDirs ?? []).filter(Boolean))];
+    if (directories.length === 0 || capabilities.writableDirArgs.length === 0) {
+        return args;
+    }
+    const directoryArgs = directories.flatMap((directory) => (capabilities.writableDirArgs.map((arg) => arg.replaceAll("{dir}", directory))));
+    if (capabilities.profile !== "codex") {
+        return [...args, ...directoryArgs];
+    }
+    if (isResume) {
+        const resumeIndex = args.indexOf("resume");
+        const execIndex = args.lastIndexOf("exec", resumeIndex);
+        if (resumeIndex < 0 || execIndex < 0) {
+            return args;
+        }
+        return [
+            ...args.slice(0, resumeIndex),
+            ...directoryArgs,
+            ...args.slice(resumeIndex)
+        ];
+    }
+    const promptIndex = args.lastIndexOf("-");
+    if (promptIndex < 0) {
+        return [...args, ...directoryArgs];
+    }
+    return [
+        ...args.slice(0, promptIndex),
+        ...directoryArgs,
+        ...args.slice(promptIndex)
+    ];
+}
+function resolveWorkerCapabilities(engine, configured) {
+    if (configured) {
+        return configured;
+    }
+    if (engine === "codex") {
+        return {
+            profile: "codex",
+            writableDirArgs: ["--add-dir", "{dir}"],
+            freshSessionArgs: []
+        };
+    }
+    if (engine === "claude") {
+        return {
+            profile: "claude",
+            writableDirArgs: ["--add-dir", "{dir}"],
+            freshSessionArgs: ["--session-id", "{sessionId}"]
+        };
+    }
+    return {
+        profile: "generic",
+        writableDirArgs: [],
+        freshSessionArgs: []
     };
 }
 function buildModelArgs(modelConfig) {
@@ -221,8 +667,13 @@ function buildModelEnv(modelConfig) {
     return Object.fromEntries(Object.entries(modelConfig.env).map(([key, value]) => [key, renderTemplate(value, undefined, modelConfig)]));
 }
 function shouldFallbackToNewNativeSession(attempt, nativeSessionConfig) {
+    if (attempt.result.failure?.phase === "process-cleanup-error"
+        || attempt.result.failure?.phase === "process-ownership-error") {
+        return false;
+    }
     return (attempt.launch.isResume &&
-        attempt.result.exitCode !== 0 &&
+        !attempt.result.cancelled &&
+        (Boolean(attempt.result.failure) || attempt.result.exitCode !== 0) &&
         nativeSessionConfig?.fallback === "new" &&
         isUnrecoverableNativeResumeOutput(attempt.output));
 }
@@ -233,6 +684,33 @@ function isUnrecoverableNativeResumeOutput(output) {
         normalized.includes("clear earlier history") ||
         normalized.includes("start a new thread"));
 }
+function findUnrecoverableNativeResumeReason(output) {
+    const normalized = output.toLowerCase();
+    const matchIndex = [
+        "context window",
+        "ran out of room",
+        "clear earlier history",
+        "start a new thread"
+    ].reduce((earliest, phrase) => {
+        const index = normalized.indexOf(phrase);
+        return index < 0 || (earliest >= 0 && earliest <= index) ? earliest : index;
+    }, -1);
+    if (matchIndex < 0) {
+        return undefined;
+    }
+    const lineStart = output.lastIndexOf("\n", matchIndex - 1) + 1;
+    const nextLine = output.indexOf("\n", matchIndex);
+    const lineEnd = nextLine < 0 ? output.length : nextLine;
+    const contextStart = Math.max(lineStart, matchIndex - 256);
+    const contextEnd = Math.min(lineEnd, contextStart + RESUME_REASON_CHARS);
+    return output.slice(contextStart, contextEnd).trim() || "Native session context is exhausted";
+}
+function appendBoundedTextTail(current, chunk, limit) {
+    if (chunk.length >= limit) {
+        return chunk.slice(-limit);
+    }
+    return `${current.slice(-(limit - chunk.length))}${chunk}`;
+}
 function renderTemplate(value, sessionId, modelConfig) {
     return value
         .replaceAll("{sessionId}", sessionId ?? "")
@@ -257,15 +735,32 @@ function summarizeOutput(text) {
     const summary = lines.at(-1) ?? "Worker produced output";
     return summary.length > 160 ? `${summary.slice(0, 157)}...` : summary;
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function setStatus(spec, state, phase, summary, nativeSessionId) {
-    await writeJson(spec.statusPath, {
+    const status = {
         worker_id: spec.workerId,
+        ...(spec.featureId ? { feature_id: spec.featureId } : {}),
+        ...(spec.featureTitle ? { feature_title: spec.featureTitle } : {}),
         role: spec.role,
         engine: spec.engine,
+        ...(spec.modelConfig?.name.trim() ? { model_name: spec.modelConfig.name.trim() } : {}),
+        ...(spec.modelConfig?.provider.trim() ? { model_provider: spec.modelConfig.provider.trim() } : {}),
         state,
         phase,
         last_event_at: new Date().toISOString(),
         summary,
         ...(nativeSessionId ? { native_session_id: nativeSessionId } : {})
-    });
+    };
+    await writeJson(spec.statusPath, status);
+    notifyStatus(spec, status);
+}
+function notifyStatus(spec, status) {
+    try {
+        void Promise.resolve(spec.onStatus?.(status)).catch(() => { });
+    }
+    catch {
+        // Status observers cannot change the worker outcome.
+    }
 }