@zq-silk/yui 1.0.1 → 1.1.0

package/dist/runtime/codexSharedDaemon.js

@@ -0,0 +1,211 @@
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { createConnection } from "node:net";
+import { isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const DAEMON_START_TIMEOUT_MS = 15_000;
+const CODEX_APP_BUNDLE_ID = "com.openai.codex";
+/** A denied probe says nothing about whether the shared daemon is running. */
+export function isCodexInspectionPermissionError(error) {
+    if (typeof error === "string") {
+        return /\b(?:EPERM|EACCES)\b|operation not permitted|permission denied/iu.test(error);
+    }
+    let current = error;
+    for (let depth = 0; depth < 4 && current !== null && typeof current === "object"; depth += 1) {
+        const candidate = current;
+        if (candidate.code === "EPERM" || candidate.code === "EACCES"
+            || [candidate.message, candidate.stderr].some((value) => typeof value === "string"
+                && /\b(?:EPERM|EACCES)\b|operation not permitted|permission denied/iu.test(value)))
+            return true;
+        current = candidate.cause;
+    }
+    return false;
+}
+/** Locate the installed App by bundle identity, including non-default installs. */
+export function findMacCodexAppExecutable(environment = process.env) {
+    if (process.platform !== "darwin")
+        return undefined;
+    const home = environment.HOME || homedir();
+    const candidates = [
+        "/Applications/ChatGPT.app", "/Applications/Codex.app",
+        join(home, "Applications/ChatGPT.app"), join(home, "Applications/Codex.app")
+    ];
+    for (const candidate of candidates) {
+        const executable = executableForCodexApp(candidate);
+        if (executable !== undefined)
+            return executable;
+    }
+    try {
+        const registered = execFileSync("/usr/bin/osascript", [
+            "-e", `POSIX path of (path to application id "${CODEX_APP_BUNDLE_ID}")`
+        ], { encoding: "utf8", timeout: 10_000 }).trim();
+        return executableForCodexApp(registered);
+    }
+    catch {
+        return undefined;
+    }
+}
+function executableForCodexApp(bundlePath) {
+    const plist = join(bundlePath, "Contents/Info.plist");
+    if (!existsSync(plist))
+        return undefined;
+    try {
+        const identifier = execFileSync("/usr/libexec/PlistBuddy", [
+            "-c", "Print :CFBundleIdentifier", plist
+        ], { encoding: "utf8", timeout: 2_000 }).trim();
+        if (identifier !== CODEX_APP_BUNDLE_ID)
+            return undefined;
+        const name = execFileSync("/usr/libexec/PlistBuddy", [
+            "-c", "Print :CFBundleExecutable", plist
+        ], { encoding: "utf8", timeout: 2_000 }).trim();
+        const executable = join(bundlePath, "Contents/MacOS", name);
+        return existsSync(executable) ? executable : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Prepare future App launches when an interactive Yui Codex Session starts. */
+export async function prepareMacCodexAppConnection(launch, appExecutable = findMacCodexAppExecutable(launch.environment), daemonStartedEarlier = false) {
+    if (process.platform !== "darwin")
+        return { state: "not-macos" };
+    if (launch.args.at(-2) !== "app-server" || launch.args.at(-1) !== "proxy") {
+        throw new Error("Codex App sharing requires the configured app-server proxy connection.");
+    }
+    const socketPath = codexSharedSocketPath(launch.environment, launch.cwd);
+    const started = await ensureCodexSharedDaemon(launch) || daemonStartedEarlier;
+    if (appExecutable === undefined)
+        return { state: "ready", socketPath };
+    const wsUrl = codexAppWebSocketUrl(launch.environment, launch.cwd);
+    try {
+        await execFileAsync("/bin/launchctl", ["setenv", "CODEX_APP_SERVER_WS_URL", wsUrl], {
+            cwd: launch.cwd, env: launch.environment, timeout: 5_000
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not configure future Codex App launches: ${String(error)}`, { cause: error });
+    }
+    let stdout;
+    try {
+        ({ stdout } = await execFileAsync("/bin/ps", ["-axo", "pid=,args="], {
+            cwd: launch.cwd, env: launch.environment, timeout: 5_000, maxBuffer: 4 * 1024 * 1024
+        }));
+    }
+    catch (error) {
+        throw new Error(`Could not inspect running Codex App processes: ${String(error)}`, { cause: error });
+    }
+    const pids = codexAppProcessIds(stdout, appExecutable);
+    for (const pid of pids) {
+        let appCommand;
+        try {
+            const app = await execFileAsync("/bin/ps", ["eww", "-p", pid, "-o", "command="], {
+                cwd: launch.cwd, env: launch.environment, timeout: 5_000, maxBuffer: 4 * 1024 * 1024
+            });
+            appCommand = String(app.stdout);
+        }
+        catch (error) {
+            // The App can exit between listing processes and reading its environment.
+            try {
+                process.kill(Number(pid), 0);
+            }
+            catch (probeError) {
+                if (probeError.code === "ESRCH")
+                    continue;
+            }
+            throw new Error(`Could not inspect Codex App pid=${pid}: ${String(error)}`, { cause: error });
+        }
+        if (codexAppNeedsRestart(appCommand, wsUrl, started)) {
+            return { state: "restart-required", socketPath };
+        }
+    }
+    return { state: "ready", socketPath };
+}
+export function codexAppProcessIds(processTable, appExecutable = "/Applications/ChatGPT.app/Contents/MacOS/ChatGPT") {
+    return processTable.split("\n").flatMap((line) => {
+        const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+        return match !== null
+            && (match[2] === appExecutable || match[2].startsWith(`${appExecutable} `))
+            ? [match[1]] : [];
+    });
+}
+export function codexAppWebSocketUrl(environment, cwd) {
+    return `ws+unix://localhost${codexSharedSocketPath(environment, cwd)}:/rpc`;
+}
+export function codexAppNeedsRestart(runningAppCommand, wsUrl, daemonStarted) {
+    return daemonStarted || !runningAppCommand.split(/\s+/).includes(`CODEX_APP_SERVER_WS_URL=${wsUrl}`);
+}
+/** Only a failed connection to the default shared socket can start the local daemon. */
+export async function startMissingCodexSharedDaemon(launch) {
+    if (launch.args.at(-2) !== "app-server" || launch.args.at(-1) !== "proxy")
+        return false;
+    const socketPath = codexSharedSocketPath(launch.environment, launch.cwd);
+    if (!await socketIsMissing(socketPath))
+        return false;
+    try {
+        await execFileAsync(launch.command, [
+            ...daemonBaseArgs(launch), "app-server", "daemon", "start"
+        ], {
+            cwd: launch.cwd,
+            env: launch.environment,
+            timeout: DAEMON_START_TIMEOUT_MS,
+            maxBuffer: 32 * 1024
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Codex shared app-server is unavailable at ${socketPath}; daemon start failed: ${detail}`, {
+            cause: error
+        });
+    }
+    return true;
+}
+export async function ensureCodexSharedDaemon(launch) {
+    const started = await startMissingCodexSharedDaemon(launch);
+    const socketPath = codexSharedSocketPath(launch.environment, launch.cwd);
+    for (let attempt = 0; attempt < 40; attempt += 1) {
+        if (!await socketIsMissing(socketPath))
+            return started;
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
+    }
+    throw new Error(`Codex shared app-server did not open ${socketPath}.`);
+}
+export function codexSharedSocketPath(environment, cwd) {
+    const accountHome = environment.CODEX_HOME?.trim()
+        || join(environment.HOME || homedir(), ".codex");
+    const codexHome = isAbsolute(accountHome) ? accountHome : resolve(cwd, accountHome);
+    return join(codexHome, "app-server-control", "app-server-control.sock");
+}
+function daemonBaseArgs(launch) {
+    let parsed;
+    try {
+        parsed = JSON.parse(launch.environment.YUI_AGENT_BASE_ARGS ?? "");
+    }
+    catch {
+        throw new Error("Codex daemon launch is missing the configured Agent base arguments.");
+    }
+    if (!Array.isArray(parsed) || !parsed.every((arg) => typeof arg === "string")) {
+        throw new Error("Codex daemon launch has invalid configured Agent base arguments.");
+    }
+    return parsed;
+}
+function socketIsMissing(path) {
+    return new Promise((resolvePromise, reject) => {
+        const socket = createConnection(path);
+        socket.setTimeout(1_000, () => socket.destroy(new Error("Codex shared app-server socket probe timed out.")));
+        socket.once("connect", () => {
+            socket.destroy();
+            resolvePromise(false);
+        });
+        socket.once("error", (error) => {
+            if (error.code === "ENOENT" || error.code === "ECONNREFUSED")
+                resolvePromise(true);
+            else if (isCodexInspectionPermissionError(error)) {
+                reject(new Error(`Cannot verify Codex shared app-server socket at ${path}: access denied; daemon state is unverified. ${error.message}`, { cause: error }));
+            }
+            else
+                reject(error);
+        });
+    });
+}

package/dist/runtime/index.js

@@ -8,7 +8,7 @@ export { DEFAULT_RECENT_TURN_ID_LIMIT, hasRecentTurnId, rememberRecentTurnId, va
 export { promptPushOutcome, RuntimeHostContentionError, RuntimeHostUnavailableError, RuntimeLaunchError } from "./ports.js";
 export { AgentHostPromptPushAdapter, TmuxSessionHost } from "./tmuxAdapters.js";
 export { FileTaskRuntimeIsolation, YUI_TASK_RUNTIME_ISOLATION_DESCRIPTOR, YUI_TASK_RUNTIME_SERVICE_NAMESPACE, assertTaskRuntimeIsolationPreflight, createTaskRuntimeIsolationDescriptor, parseTaskRuntimeIsolationDescriptor, planTaskRuntimeCleanup, taskRuntimeIsolationEnvironment, taskRuntimeIsolationFingerprint } from "./taskRuntimeIsolation.js";
-export { createSessionOwnerIdentity, isLinuxProcessLive, listOwnedProcessTree, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
+export { createSessionOwnerIdentity, isLinuxProcessLive, listOwnedProcessTree, readLinuxProcessIdentity, readProcessIdentity } from "./sessionOwnerIdentity.js";
 export { formatRuntimeLaunchDiagnostic, redactLaunchArgument, redactLaunchText, RuntimeLaunchFailure, toRuntimeLaunchFailure } from "./launchDiagnostics.js";
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
 export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";

package/dist/runtime/jsonLineChannel.js

@@ -130,8 +130,13 @@ export function terminateProcessGroup(child, signal) {
         process.kill(-child.pid, signal);
     }
     catch (error) {
-        if (error.code !== "ESRCH")
+        const code = error.code;
+        if (code !== "ESRCH" && code !== "EPERM")
             throw error;
+        // ESRCH: the group is already gone. EPERM: the group ID was reused by or
+        // inherited a process owned by another user (observed on macOS after the
+        // fixture child exits); the direct child is still ours to terminate.
+        // Node's ChildProcess.kill treats an already-exited child as a no-op.
         child.kill(signal);
     }
 }

package/dist/runtime/localStartup.js

@@ -0,0 +1,65 @@
+import { configuredAgentToDefinition, resolveAgentEnvironment } from "../agent/agent.js";
+import { codexSharedSocketPath, ensureCodexSharedDaemon, findMacCodexAppExecutable, prepareMacCodexAppConnection } from "./codexSharedDaemon.js";
+/** Current Role demand, not every CLI installed on the machine or stale Agent record. */
+export function codexAgentsInUse(store, targetAgentId) {
+    const ids = new Set();
+    if (targetAgentId !== undefined) {
+        ids.add(targetAgentId);
+    }
+    else {
+        for (const role of store.listGlobalRoles())
+            ids.add(role.activeAgentId);
+        for (const taskId of store.listActiveTaskIds()) {
+            for (const role of store.listRoles(taskId))
+                ids.add(role.activeAgentId);
+        }
+    }
+    return [...ids].flatMap((id) => {
+        const agent = store.getConfiguredAgent(id);
+        return agent?.adapterId === "codex" ? [agent] : [];
+    });
+}
+export async function prepareLocalCodexStartup(store, home, environment, targetAgentId, platform = process.platform) {
+    const agents = codexAgentsInUse(store, targetAgentId);
+    if (agents.length === 0)
+        return { daemons: [], app: "not-applicable" };
+    const groups = new Map();
+    for (const configured of agents) {
+        const agent = configuredAgentToDefinition(configured);
+        const launch = {
+            command: agent.command,
+            args: [...agent.baseArgs, "app-server", "proxy"],
+            cwd: home,
+            environment: {
+                ...environment,
+                ...resolveAgentEnvironment(agent, environment),
+                YUI_AGENT_BASE_ARGS: JSON.stringify(agent.baseArgs)
+            }
+        };
+        const socketPath = codexSharedSocketPath(launch.environment, home);
+        const existing = groups.get(socketPath);
+        if (existing === undefined)
+            groups.set(socketPath, { launch, agentIds: [agent.id] });
+        else
+            existing.agentIds.push(agent.id);
+    }
+    const daemons = [];
+    for (const [socketPath, group] of groups) {
+        const started = await ensureCodexSharedDaemon(group.launch);
+        daemons.push({ agentIds: group.agentIds, socketPath, started });
+    }
+    if (platform !== "darwin")
+        return { daemons, app: "not-applicable" };
+    const appExecutable = findMacCodexAppExecutable(environment);
+    if (appExecutable === undefined)
+        return { daemons, app: "not-detected" };
+    const operatorAgentId = store.getGlobalRole("operator")?.activeAgentId;
+    const selected = [...groups.values()].find((group) => group.agentIds.includes(operatorAgentId ?? ""))
+        ?? (groups.size === 1 ? [...groups.values()][0] : undefined);
+    if (selected === undefined)
+        return { daemons, app: "multiple-homes" };
+    const selectedSocketPath = codexSharedSocketPath(selected.launch.environment, home);
+    const daemonStartedEarlier = daemons.find((daemon) => daemon.socketPath === selectedSocketPath)?.started ?? false;
+    const prepared = await prepareMacCodexAppConnection(selected.launch, appExecutable, daemonStartedEarlier);
+    return { daemons, app: prepared.state };
+}

package/dist/runtime/nativeExecutable.js

@@ -0,0 +1,10 @@
+import { fileURLToPath } from "node:url";
+/** Native binaries are shipped together; never execute another platform's helper. */
+export function nativeExecutable(name, platform = process.platform, architecture = process.arch) {
+    const target = `${platform}-${architecture}`;
+    if (!["linux-x64", "darwin-x64", "darwin-arm64"].includes(target)
+        || (name === "process-identity" && platform !== "darwin")) {
+        throw new Error(`Unsupported native runtime: ${target}/${name}.`);
+    }
+    return fileURLToPath(new URL(`./native/${target}/${name}`, import.meta.url));
+}

package/dist/runtime/runtimeCoherence.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { isStorageVersion, compareStorageVersions } from "../storage/storageVersions.js";
-import { callController as defaultCallController } from "../core/controllerClient.js";
+import { callController as defaultCallController, ControllerClientError } from "../core/controllerClient.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { yuiVersionIdentity } from "../version.js";
 export async function assertRuntimeCoherence(input, options = {}) {
@@ -22,8 +22,15 @@ export async function assertRuntimeCoherence(input, options = {}) {
             assertControllerContinuityIdentity(status, identity);
         }
         catch (error) {
-            if (!isDefinitelyNotRunning(error))
-                throw error;
+            if (isDefinitelyNotRunning(error))
+                return identity;
+            if (error instanceof ControllerClientError
+                && ["CONTROLLER_UNAVAILABLE", "CONTROLLER_TIMEOUT", "CONTROLLER_DISCOVERY_INVALID", "INVALID_RESPONSE"].includes(error.code)) {
+                throw new Error(`Managed Controller could not be verified before this command: ${error.message} `
+                    + "Run `yui doctor` with this Session's YUI_HOME and CLI; ask the Operator or user "
+                    + "to restore it with `yui start` or `yui controller restart` as diagnosed.", { cause: error });
+            }
+            throw error;
         }
     }
     return identity;

package/dist/runtime/sessionOwnerIdentity.js

@@ -1,4 +1,5 @@
 import { readFileSync, readdirSync } from "node:fs";
+import { readProcessStartIdentity } from "../core/fileLockOwner.js";
 import { requireSafeIdentity, requireText, requireTimestamp } from "./validation.js";
 /** A concrete OS process identity, not an Agent launch identity. */
 export function sessionOwnerProcessKey(record) {
@@ -109,6 +110,24 @@ export function readLinuxProcessIdentity(pid) {
         return undefined;
     }
 }
+/**
+ * Identity of a process for durable ownership records. Linux returns the
+ * exact /proc start-time identity; macOS uses libproc's process start time.
+ */
+export function readProcessIdentity(pid = process.pid) {
+    if (process.platform === "linux") {
+        const identity = readLinuxProcessIdentity(pid);
+        if (identity === undefined) {
+            throw new Error(`Cannot read Linux process identity for PID ${pid}.`);
+        }
+        return identity;
+    }
+    const startIdentity = readProcessStartIdentity(pid);
+    if (startIdentity === undefined) {
+        throw new Error(`Dedicated Provider process identity could not be verified for PID ${pid}.`);
+    }
+    return { pid, startIdentity, rssBytes: 0 };
+}
 function readLinuxProcessRssBytes(pid) {
     try {
         const status = readFileSync(`/proc/${pid}/status`, "utf8");

package/dist/runtime/sessionTerminationGuard.js

@@ -30,11 +30,16 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
     if (records.length === 0) {
         // Without a recorded root only the exact Role pane can be stopped.
         const stopped = await ports.gracefulStop(owner);
-        const outcome = stopped ? "stop-confirmed" : "stop-blocked";
+        const outcome = stopped && options.requireProcessRecord !== true
+            ? "stop-confirmed" : "stop-blocked";
         emit(outcome);
         return {
             outcome, owner, confirmed: [], remaining: [],
-            ...(stopped ? {} : { verificationGap: "Role pane stop is unconfirmed." })
+            ...(outcome === "stop-confirmed" ? {} : {
+                verificationGap: stopped
+                    ? "No recorded Host process identity; pane exit cannot prove physical exit."
+                    : "Role pane stop is unconfirmed."
+            })
         };
     }
     const pollMs = duration(options.pollMs, DEFAULT_TERMINATION_POLL_MS);
@@ -60,7 +65,9 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
         }
         emit(signal === "SIGTERM" ? "graceful-stop" : "forced-stop");
         const deadline = Date.now() + grace;
-        while (records.some((record) => state(record) === "live") && Date.now() < deadline) {
+        // A process can be briefly unreadable while exiting. Wait for absence,
+        // not merely for the first unverified observation.
+        while (records.some((record) => state(record) !== "absent") && Date.now() < deadline) {
             await ports.sleep(Math.min(pollMs, Math.max(1, deadline - Date.now())));
         }
         if (records.every((record) => state(record) === "absent"))

package/dist/runtime/structuredProviderHost.js

@@ -1,7 +1,8 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { Duplex } from "node:stream";
-import { fileURLToPath } from "node:url";
+import { nativeExecutable } from "./nativeExecutable.js";
+import { startMissingCodexSharedDaemon } from "./codexSharedDaemon.js";
 import { ProviderConversationMissingError, ProviderDeliveryUnknownError, ProviderTurnBusyError, ProviderTurnRejectedError } from "./providerErrors.js";
 import WebSocket from "ws";
 import { YUI_VERSION } from "../version.js";
@@ -24,15 +25,32 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control === undefined) {
         throw new Error("Managed Agent Host launch requires Provider control metadata.");
     }
+    const mirror = input.mirrorOutput ?? defaultMirrorOutput;
+    if (control.adapterId === "codex" && control.transport === "codex-app-server-proxy") {
+        const proxy = await connectCodexProxy(payload, mirror, true);
+        try {
+            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
+            return Object.freeze({
+                session: opened.session,
+                ...(opened.recoveredTerminal === undefined
+                    ? {}
+                    : { recoveredTerminal: opened.recoveredTerminal }),
+                goal: opened.goal
+            });
+        }
+        catch (error) {
+            terminateProcessGroup(proxy.child, "SIGTERM");
+            throw error;
+        }
+    }
     const ownedClaude = control.adapterId === "claude" && control.transport !== "acp-stdio";
-    const child = spawn(ownedClaude ? fileURLToPath(new URL("./claude-process-owner", import.meta.url)) : payload.command, ownedClaude ? [payload.command, ...payload.args] : [...payload.args], {
+    const child = spawn(ownedClaude ? nativeExecutable("claude-process-owner") : payload.command, ownedClaude ? [payload.command, ...payload.args] : [...payload.args], {
         cwd: payload.cwd,
         env: { ...payload.environment },
         stdio: ["pipe", "pipe", "pipe"],
         detached: true
     });
     const processInstanceId = randomUUID();
-    const mirror = input.mirrorOutput ?? defaultMirrorOutput;
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk) => mirror("stderr", chunk));
     const exit = childExit(child, processInstanceId);
@@ -81,16 +99,6 @@ export async function startStructuredProviderSession(payload, input = {}) {
             }
             return Object.freeze({ session });
         }
-        if (control.adapterId === "codex") {
-            const opened = await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
-            return Object.freeze({
-                session: opened.session,
-                ...(opened.recoveredTerminal === undefined
-                    ? {}
-                    : { recoveredTerminal: opened.recoveredTerminal }),
-                goal: opened.goal
-            });
-        }
         const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, input.onDiagnostic, mirror);
         if (isPostCreateOperatorTitle(payload)) {
             input.onDiagnostic?.({
@@ -120,20 +128,38 @@ function isPostCreateOperatorTitle(payload) {
  * Open an uninitialized, transparent connection for a native TUI. The TUI
  * owns its requests; Yui observes only its exact startup response.
  */
-export async function openCodexInteractiveConnection(launch) {
-    const child = spawn(launch.command, [...launch.args], {
-        cwd: launch.cwd,
-        env: { ...launch.environment },
-        stdio: ["pipe", "pipe", "pipe"],
-        detached: true
-    });
-    child.stderr.resume();
+export async function openCodexInteractiveConnection(launch, startMissingDaemon = false) {
+    return (await connectCodexProxy(launch, () => { }, startMissingDaemon)).channel;
+}
+async function connectCodexProxy(launch, mirror, startMissingDaemon) {
+    const attempt = async () => {
+        const child = spawn(launch.command, [...launch.args], {
+            cwd: launch.cwd,
+            env: { ...launch.environment },
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: true
+        });
+        const processInstanceId = randomUUID();
+        const exit = childExit(child, processInstanceId);
+        void exit.catch(() => { });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => mirror("stderr", chunk));
+        try {
+            const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
+            return { child, channel, exit, processInstanceId };
+        }
+        catch (error) {
+            terminateProcessGroup(child, "SIGTERM");
+            throw error;
+        }
+    };
     try {
-        return await CodexProxyWebSocketChannel.connect(child, () => { });
+        return await attempt();
     }
     catch (error) {
-        terminateProcessGroup(child, "SIGTERM");
-        throw error;
+        if (!startMissingDaemon || !await startMissingCodexSharedDaemon(launch))
+            throw error;
+        return await attempt();
     }
 }
 class CodexProxyWebSocketChannel {
@@ -379,8 +405,7 @@ class CodexStructuredProviderSession {
         this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
-    static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
-        const channel = await CodexProxyWebSocketChannel.connect(child, mirror);
+    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         const initialized = await channel.request("initialize", codexClientInitialization());

package/dist/scheduler/activeRoleRunDelivery.js

@@ -8,7 +8,6 @@ import { formatProviderDeliveryFailure, providerDeliveryFailureFacts, innermostC
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { formatRunReceiptId } from "../task/taskRecordReference.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { runInputEnvelope } from "../agentRun/agentRun.js";
 import { captureRoleRunDispatch } from "../coordination/workMailboxQueue.js";
 import { isSchedulerPlanningDraft, isSchedulerTaskWorkspaceReady, selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
@@ -136,16 +135,8 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
             effective: run.effective,
             workspace: run.effective.workspace.root,
             ...(run.workspace === undefined ? {} : { managedWorkspace: run.workspace }),
-            // A Task owning no workspace by design states that explicitly, so the
-            // launch does not read the absent workspace as a missing one and fail
-            // closed (S27). Two distinct cases qualify: a Task activated with an
-            // empty plan and binding no Project, and a Draft planning conversation,
-            // which may already bind a Project but has not activated, so no worktree
-            // exists or is owed yet. Declaring it free is what keeps the isolation
-            // fence honest instead of letting it fail on a workspace nobody promised.
-            ...(run.workspace === undefined
-                && (isSchedulerPlanningDraft(task, run.purpose)
-                    || !taskOwnsManagedWorkspace(task))
+            // Draft planning has no delivery workspace or worktree to isolate.
+            ...(run.workspace === undefined && isSchedulerPlanningDraft(task, run.purpose)
                 ? { workspaceFree: true }
                 : {}),
             mode,

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,7 +1,6 @@
 import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
 import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { hasImmediateWakeReason } from "./wakeReason.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
@@ -78,7 +77,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 taskId: task.id, roleName: role.name, agentId: effective.agentId,
                 adapterId: effective.adapterId, effective, workspace: effective.workspace.root,
                 ...(role.managedWorkspace === undefined ? {} : { managedWorkspace: role.managedWorkspace }),
-                ...(task.status === "draft" || !taskOwnsManagedWorkspace(task)
+                ...(task.status === "draft"
                     ? { workspaceFree: true } : {}),
                 mode, ...(mode === "resume" && session?.nativeSessionId !== undefined
                     ? { nativeSessionId: session.nativeSessionId } : {})

package/dist/scheduler/ports.js

@@ -1,12 +1,8 @@
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 /**
  * Whether the Task's workspace state admits a launch.
  *
- * A Task that owns no managed workspace — activated with an empty environment
- * plan, binding no Project — is admitted with no workspace record at all. The
- * scheduler must not wait for a worktree that was deliberately never created.
- * Every Task that does own one still needs the full ownership proof.
+ * Active Tasks always need the full Task-owned workspace proof.
  *
  * A Draft planning conversation is a third case: the Task may already bind a
  * Project, yet activation has not run, so no worktree exists or is owed. It is
@@ -18,9 +14,6 @@ export function isSchedulerTaskWorkspaceReady(task, workspace, purpose) {
     if (isSchedulerPlanningDraft(task, purpose)) {
         return workspace === null || workspace === undefined;
     }
-    if (!taskOwnsManagedWorkspace(task)) {
-        return workspace === null || workspace === undefined;
-    }
     return isTaskOwnedWorkspace(workspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })));
 }
 /**

package/dist/scheduler/taskExecutionProjection.js

@@ -1,7 +1,6 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { providerRetryProjection } from "../runtime/providerRetry.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { actionableExecutionLaneRecoveries, summarizeExecutionGroupHealth } from "../execution/executionHealth.js";
@@ -651,11 +650,7 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
             summary: request.question
         });
     }
-    // A Task activated with an empty environment plan owns no workspace and no
-    // cwd by design; only a Task that should own one is blocked by its absence.
-    if (task.status === "active"
-        && taskOwnsManagedWorkspace(task)
-        && task.cwd === undefined) {
+    if (task.status === "active" && task.cwd === undefined) {
         blockers.push({
             kind: "identity",
             id: `workspace:${task.id}`,