@zq-silk/yui 1.0.1 → 1.1.2

package/dist/resources/liveReferences.js

@@ -5,11 +5,12 @@
  * consumes another Issue's completion flag. Any source that cannot be read
  * fails closed: the resource is treated as referenced and retained.
  */
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { promisify } from "node:util";
+import { processOwnerIsLive } from "../core/fileLockOwner.js";
 import { readRuntimeIdentity, releasesDirectory, resolveActiveRelease } from "../release/runtimeRelease.js";
 import { isControllerSocketPathForHome } from "../core/controllerEndpoint.js";
 import { parseControllerDiscovery } from "../core/protocol.js";
@@ -172,8 +173,10 @@ function readRuntimeIdentityClaims(home) {
         if (!isProcessAlive(identity.pid)) {
             return Object.freeze({ claims: Object.freeze([]), diagnostics: Object.freeze([]) });
         }
-        const currentIdentity = readLinuxProcessStartIdentity(identity.pid);
-        if (currentIdentity === undefined || currentIdentity !== identity.processStartIdentity) {
+        const sameGeneration = process.platform === "linux"
+            ? readLinuxProcessStartIdentity(identity.pid) === identity.processStartIdentity
+            : processOwnerIsLive(identity.pid, identity.processStartIdentity);
+        if (!sameGeneration) {
             return Object.freeze({
                 claims: Object.freeze([]),
                 diagnostics: Object.freeze([{
@@ -242,8 +245,10 @@ export function readSessionOwnerClaims(records) {
             // The normal reconciliation owner releases dead custody records.
             continue;
         }
-        const currentIdentity = readLinuxProcessStartIdentity(pid);
-        if (currentIdentity === undefined || currentIdentity !== startIdentity) {
+        const sameGeneration = process.platform === "linux"
+            ? readLinuxProcessStartIdentity(pid) === startIdentity
+            : processOwnerIsLive(pid, startIdentity);
+        if (!sameGeneration) {
             diagnostics.push({
                 source: "controller",
                 severity: "error",
@@ -270,6 +275,8 @@ export function readSessionOwnerClaims(records) {
  * scan fails closed: every candidate path receives a protective ref.
  */
 export function scanProcessPathRefs(paths) {
+    if (process.platform === "darwin")
+        return scanDarwinProcessPathRefs(paths);
     const refs = new Map();
     const diagnostics = [];
     const add = (path, token) => {
@@ -335,6 +342,54 @@ export function scanProcessPathRefs(paths) {
     }
     return freezeResult(refs, diagnostics);
 }
+/** lsof supplies the same-user cwd and open-file observations on macOS. */
+function scanDarwinProcessPathRefs(paths) {
+    const refs = new Map();
+    try {
+        const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+        const output = execFileSync("/usr/sbin/lsof", [
+            "-nP", "-w", "-F0pfn", "-u", String(uid)
+        ], { encoding: "utf8", timeout: 10_000, maxBuffer: 16 * 1024 * 1024 });
+        if (output.includes("\ufffd"))
+            throw new Error("lsof returned an undecodable path.");
+        let pid = "";
+        let descriptor = "";
+        let sawProcess = false;
+        for (const raw of output.split("\0")) {
+            const field = raw.replace(/^\n+/u, "");
+            if (field.startsWith("p") && /^[1-9][0-9]*$/u.test(field.slice(1))) {
+                pid = field.slice(1);
+                descriptor = "";
+                sawProcess = true;
+            }
+            else if (field.startsWith("f")) {
+                descriptor = field.slice(1);
+            }
+            else if (field.startsWith("n") && pid !== "" && field[1] === "/") {
+                const observed = field.slice(1);
+                for (const path of paths) {
+                    if (!isPathWithin(observed, path))
+                        continue;
+                    const tokens = refs.get(path) ?? new Set();
+                    tokens.add(`lsof:${descriptor}:${pid}`);
+                    refs.set(path, tokens);
+                }
+            }
+        }
+        if (!sawProcess)
+            throw new Error("lsof did not return a process inventory.");
+        return freezeResult(refs, []);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const diagnostics = [{
+                source: "proc", severity: "error", message: `macOS process path scan failed: ${detail}`
+            }];
+        for (const path of paths)
+            refs.set(path, new Set(["lsof:unverified"]));
+        return freezeResult(refs, diagnostics);
+    }
+}
 function freezeResult(refs, diagnostics) {
     const frozen = new Map();
     for (const [path, tokens] of refs)
@@ -435,8 +490,10 @@ export function readControllerDiscovery(home) {
     }
     // PID is alive. When a start identity is recorded, verify it to guard
     // against PID reuse.
-    const currentIdentity = readLinuxProcessStartIdentity(record.pid);
-    if (currentIdentity === undefined || currentIdentity !== record.processStartIdentity) {
+    const sameGeneration = process.platform === "linux"
+        ? readLinuxProcessStartIdentity(record.pid) === record.processStartIdentity
+        : processOwnerIsLive(record.pid, record.processStartIdentity);
+    if (!sameGeneration) {
         return Object.freeze({
             protects: false,
             token: "",

package/dist/runtime/agentEndpointIdentity.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { detectRunningRelease } from "../release/runtimeRelease.js";
 import { isAgentAdapterId } from "../agent/adapterCatalog.js";
+import { nativeExecutable } from "./nativeExecutable.js";
 /**
  * The generation of the Endpoint code this process is actually executing.
  *
@@ -28,7 +29,7 @@ const ENDPOINT_CHECKOUT_MODULES = Object.freeze([
     "agentEndpoint.js",
     "agentEndpointIdentity.js",
     "structuredProviderHost.js",
-    "claude-process-owner",
+    "nativeExecutable.js",
     "codexAppServerRuntime.js",
     "acpSession.js",
     "acpProtocol.js",
@@ -48,6 +49,8 @@ function resolveEndpointGeneration() {
         // to an identity that would silently match a different build.
         hash.update(module).update("\0").update(readFileSync(new URL(module, import.meta.url))).update("\0");
     }
+    hash.update("claude-process-owner").update("\0")
+        .update(readFileSync(nativeExecutable("claude-process-owner"))).update("\0");
     return `checkout-${hash.digest("hex").slice(0, 23)}`;
 }
 const ENDPOINT_GENERATION = resolveEndpointGeneration();

package/dist/runtime/agentHost.js

@@ -24,7 +24,7 @@ import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox }
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { ProviderConversationMissingError, ProviderDeliveryUnknownError, ProviderTurnBusyError, ProviderTurnRejectedError } from "./providerErrors.js";
 import { AGENT_HOST_CLIENT_EXIT_GRACE_MS, AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS, ENDPOINT_DRAIN_TIMEOUT_MS, PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
-import { createSessionOwnerIdentity, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
+import { createSessionOwnerIdentity, readProcessIdentity } from "./sessionOwnerIdentity.js";
 export { AGENT_HOST_CONTROL_PROTOCOL } from "./agentHostProtocol.js";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
 const CODEX_CLIENT_STABLE_MS = 5_000;
@@ -1243,10 +1243,8 @@ export async function runAgentHost(input) {
 /** Host-restart-independent OS custody. No secret or launch payload is stored. */
 async function recordProviderConnection(home, payload, endpoint) {
     const environment = payload.environment;
-    const identity = endpoint.ownedProcessId === undefined ? undefined : readLinuxProcessIdentity(endpoint.ownedProcessId);
-    if (endpoint.ownedProcessId !== undefined && identity === undefined) {
-        throw new Error("Dedicated Provider process identity was lost before registration.");
-    }
+    const identity = endpoint.ownedProcessId === undefined ? undefined
+        : readProcessIdentity(endpoint.ownedProcessId);
     const taskId = environment.YUI_TASK_ID;
     const roleName = environment.YUI_ROLE;
     const userHome = resolve(payload.cwd, environment.HOME ?? homedir());
@@ -1289,10 +1287,11 @@ export function agentHostControlSocketPath(input) {
         .digest("hex")
         .slice(0, 16);
     const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-    // Linux sockaddr_un paths have a small fixed budget. Keep the endpoint
-    // independent of a potentially deep YUI_HOME while fencing aliases and
-    // copied Homes by their physical filesystem identity.
-    const root = process.platform === "linux" ? "/tmp" : tmpdir();
+    // sockaddr_un paths have a small fixed budget (104 bytes on macOS, 108 on
+    // Linux). Keep the endpoint under the short system root, independent of a
+    // potentially deep YUI_HOME or the long per-user TMPDIR macOS assigns,
+    // while fencing aliases and copied Homes by physical filesystem identity.
+    const root = process.platform === "win32" ? tmpdir() : "/tmp";
     return join(root, `yui-${uid}`, "agent-host", `${homeDigest}-${ownerDigest}.sock`);
 }
 export async function sendAgentHostLaunchControl(input) {

package/dist/runtime/codexInteractiveHost.js

@@ -63,7 +63,7 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         connection = await openCodexInteractiveConnection({
             command: payload.command, args: [...baseArgs, "app-server", "proxy"],
             environment, cwd: payload.cwd
-        });
+        }, true);
         connection.onClose(fail);
         const token = randomBytes(32).toString("hex");
         relay = new WebSocketServer({

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"))