@zq-silk/yui 0.15.7 → 0.15.9

package/dist/runtime/codexAppServerRuntime.js

@@ -1,3 +1,16 @@
+import { YUI_VERSION } from "../version.js";
+/**
+ * Preserve the native non-interactive Codex identity used by our historical
+ * execution adapter. A proxy's environment cannot set the daemon's originator;
+ * the daemon derives it from initialization (and can retain its first identity).
+ * Keep Yui's title/version explicit and do not opt into unsupported attestation.
+ */
+export function codexClientInitialization() {
+    return {
+        clientInfo: { name: "codex_exec", title: "Yui", version: YUI_VERSION },
+        capabilities: { experimentalApi: true, requestAttestation: false }
+    };
+}
 export class CodexAppServerRequestError extends Error {
     code;
     data;
@@ -8,6 +21,10 @@ export class CodexAppServerRequestError extends Error {
         this.data = data;
     }
 }
+/** The pre-submit read failed; no mutation request was issued. */
+export class CodexPreSubmissionError extends Error {
+    name = "CodexPreSubmissionError";
+}
 /**
  * Continuable Codex integration over App Server. A transport connection is
  * deliberately not an Activation identity: callers supply the persisted
@@ -41,11 +58,11 @@ export class CodexAppServerRuntime {
             name: text(input.name, "Codex thread name")
         });
     }
-    async readConversation(conversationId) {
+    async readConversation(conversationId, options = {}) {
         const id = text(conversationId, "Codex thread id");
         const result = await this.transport.request("thread/read", {
             threadId: id,
-            includeTurns: true
+            includeTurns: options.includeTurns ?? true
         });
         return parseThreadSnapshot(result, id, "unknown");
     }
@@ -84,22 +101,26 @@ export class CodexAppServerRuntime {
         const requestedThreadId = text(input.conversationId, "Codex thread id");
         let threadId = requestedThreadId;
         try {
-            const snapshot = await this.readConversation(requestedThreadId);
+            // Submission needs current availability, not historical Turns. Some
+            // App Server transports expose status without supporting history reads.
+            const snapshot = await this.readConversation(requestedThreadId, { includeTurns: false });
             threadId = snapshot.threadId;
-            if (input.expectedNoActiveTurn && snapshot.activeTurnId !== undefined) {
+            if (input.expectedNoActiveTurn
+                && (snapshot.status === "active" || snapshot.activeTurnId !== undefined)) {
                 return {
                     status: "busy",
-                    activeTurnId: snapshot.activeTurnId,
-                    reason: `active-turn:${snapshot.activeTurnId}`
+                    ...(snapshot.activeTurnId === undefined ? {} : { activeTurnId: snapshot.activeTurnId }),
+                    reason: snapshot.activeTurnId === undefined
+                        ? "Provider Conversation has an active Turn."
+                        : `active-turn:${snapshot.activeTurnId}`
                 };
             }
+            if (snapshot.status !== "idle" && snapshot.status !== "active") {
+                throw new Error(`Codex Session availability is ${snapshot.status}; no input was submitted.`);
+            }
         }
         catch (error) {
-            // A new App Server thread has no materialized Turn history yet. This
-            // exact response proves there cannot be an active Turn, so its first
-            // mutation can proceed without weakening unknown-delivery handling.
-            if (!codexAppServerErrorIsUnmaterialized(error))
-                throw error;
+            throw new CodexPreSubmissionError("Codex Session inspection failed before input submission.", { cause: error });
         }
         try {
             const result = await this.transport.request("turn/start", {
@@ -126,7 +147,9 @@ export class CodexAppServerRuntime {
     async steerTurn(input) {
         const threadId = text(input.conversationId, "Codex thread id");
         const expectedTurnId = text(input.expectedTurnId, "Codex expected Turn id");
-        const snapshot = await this.readConversation(threadId);
+        const snapshot = await this.readConversation(threadId).catch((error) => {
+            throw new CodexPreSubmissionError("Codex Session inspection failed before native steer.", { cause: error });
+        });
         if (snapshot.activeTurnId !== expectedTurnId) {
             return {
                 status: "not-accepted",
@@ -215,9 +238,7 @@ export class CodexAppServerRuntime {
                         input.providerNamespace,
                         input.accountScope,
                         input.conversationId,
-                        input.activationId,
-                        continuation.continuationId,
-                        continuation.generation
+                        continuation.continuationId
                     ].join("\u0000"),
                     ...state
                 });
@@ -233,14 +254,14 @@ export class CodexAppServerRuntime {
         return { quality: "exact", continuations: Object.freeze(observed) };
     }
 }
-/** thread/closed means the loaded Activation ended; the durable thread remains resumable. */
+/** thread/closed unloads the client attachment; the durable thread remains resumable. */
 export function codexNotificationBoundary(input) {
     const conversationId = optionalId(input.params.threadId)
         ?? optionalId(objectMember(input.params, "thread")?.id);
     const turnId = optionalId(input.params.turnId)
         ?? optionalId(objectMember(input.params, "turn")?.id);
     if (input.method === "thread/closed")
-        return { kind: "activation-ended", conversationId };
+        return { kind: "attachment-closed", conversationId };
     if (input.method === "thread/goal/updated")
         return { kind: "goal-updated", conversationId, turnId };
     if (input.method === "thread/goal/cleared")
@@ -481,30 +502,17 @@ function optionalTurnStatus(value) {
 }
 function classifyMutationError(error) {
     if (error instanceof CodexAppServerRequestError) {
-        if (codexAppServerErrorIsBusy(error)) {
-            return { status: "busy", reason: error.message };
-        }
         if (["INVALID_PARAMS", "NOT_FOUND", "TURN_NOT_ACTIVE", -32602].includes(error.code)) {
             return { status: "not-accepted", reason: error.message };
         }
     }
     return { status: "unknown", reason: error instanceof Error ? error.message : String(error) };
 }
-function codexAppServerErrorIsBusy(error) {
-    return /\b(active turn|turn (?:is )?(?:already )?(?:active|in progress|running)|already has an active)\b/iu
-        .test(error.message);
-}
 function isNotLoaded(error) {
     return error instanceof CodexAppServerRequestError
         && (String(error.code).toLowerCase().includes("not_loaded")
             || error.message.toLowerCase().includes("not loaded"));
 }
-function codexAppServerErrorIsUnmaterialized(error) {
-    if (!(error instanceof CodexAppServerRequestError) || Number(error.code) !== -32600) {
-        return false;
-    }
-    return /\bthread\b.*\bnot materialized yet\b.*\bbefore first user message\b/iu.test(error.message);
-}
 export function codexAppServerErrorIsMissing(error) {
     if (!(error instanceof CodexAppServerRequestError))
         return false;

package/dist/runtime/codexInteractiveHost.js

@@ -7,7 +7,7 @@ import { openCodexInteractiveConnection } from "./structuredProviderHost.js";
 /**
  * Keep the native TUI and its transparent App Server attachment in one pane.
  * The existing Host acknowledgement carries the ID from that TUI's exact
- * thread/start or thread/resume response, before any user/model Turn.
+ * thread/start or thread/resume response, before any user/model AgentRun.
  *
  * Codex 0.150.1 cannot resume a pre-created empty Thread: no rollout exists
  * until its first message. Observing the TUI's own startup avoids creating a
@@ -29,8 +29,7 @@ export async function runCodexInteractiveHost(home, payload) {
     }
     const expectedId = environment.YUI_NATIVE_SESSION_ID;
     let snapshot = {
-        schemaVersion: 2, state: "starting", adapterId: "codex",
-        runtimeGenerationId: payload.runtimeGenerationId, updatedAt: new Date().toISOString()
+        schemaVersion: 2, state: "starting", adapterId: "codex", updatedAt: new Date().toISOString()
     };
     const control = await openAgentHostControl(home, payload, () => snapshot, async (request) => {
         if (request.type !== "status") {
@@ -59,8 +58,8 @@ export async function runCodexInteractiveHost(home, payload) {
         stop();
     };
     try {
-        // This proxy is a disposable client, not the daemon. No Yui initialization
-        // or Thread request is injected; all requests below belong to the TUI.
+        // This proxy is a disposable client, not the daemon. All requests belong
+        // to the TUI; its startup carries the reserved launch's per-Thread options.
         connection = await openCodexInteractiveConnection({
             command: payload.command, args: [...baseArgs, "app-server", "proxy"],
             environment, cwd: payload.cwd
@@ -105,6 +104,7 @@ export async function runCodexInteractiveHost(home, payload) {
                             throw new Error("Codex TUI startup does not match the reserved Session.");
                         }
                         startupRequestId = message.id;
+                        message.params = codexInteractiveStartupParameters(payload, params);
                     }
                     void connection.send(message).catch(fail);
                 }
@@ -159,7 +159,7 @@ export async function runCodexInteractiveHost(home, payload) {
         args.splice(remoteIndex + 2, 0, "--remote-auth-token-env", "YUI_CODEX_REMOTE_AUTH_TOKEN");
         child = spawn(payload.command, args, {
             cwd: payload.cwd,
-            env: { ...environment, YUI_CODEX_REMOTE_AUTH_TOKEN: token },
+            env: { ...localCodexTuiEnvironment(environment), YUI_CODEX_REMOTE_AUTH_TOKEN: token },
             stdio: "inherit"
         });
         for (const signal of signals)
@@ -183,6 +183,41 @@ export async function runCodexInteractiveHost(home, payload) {
         await control.close();
     }
 }
+/** The remote TUI can omit local launch configuration. Apply the reserved
+ * workspace and managed identity on its actual startup, never by starting a
+ * second Thread or changing daemon-wide configuration. */
+export function codexInteractiveStartupParameters(payload, params) {
+    const options = payload.interactiveCodexThread;
+    if (options === undefined)
+        throw new Error("Global Codex launch is missing its per-Thread options.");
+    const config = params.config === undefined || params.config === null ? {} : jsonObject(params.config);
+    const shell = config.shell_environment_policy === undefined ? {} : jsonObject(config.shell_environment_policy);
+    const set = shell.set === undefined ? {} : jsonObject(shell.set);
+    return {
+        ...params,
+        ...options,
+        cwd: payload.cwd,
+        config: {
+            ...config,
+            ...options.config,
+            shell_environment_policy: {
+                ...shell,
+                set: {
+                    ...set,
+                    ...Object.fromEntries(Object.entries(payload.environment).filter(([name]) => name.startsWith("YUI_")))
+                }
+            }
+        }
+    };
+}
+/** Our loopback relay must stay local, even when the TUI inherits HTTP proxies. */
+export function localCodexTuiEnvironment(environment) {
+    const bypass = [
+        "127.0.0.1", "localhost", "::1",
+        environment.NO_PROXY, environment.no_proxy
+    ].filter(Boolean).join(",");
+    return { ...environment, NO_PROXY: bypass, no_proxy: bypass };
+}
 function jsonObject(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Invalid Codex App Server object.");

package/dist/runtime/continuationManager.js

@@ -11,7 +11,7 @@ export function foldContinuationObservation(existing, raw) {
     const base = existing ?? createProviderContinuation({
         taskId: observation.fence.taskId,
         roleName: observation.fence.roleName,
-        turnId: observation.fence.turnId,
+        runId: observation.fence.runId,
         identity,
         ...(observation.fence.parentContinuationId === undefined
             ? {}
@@ -116,17 +116,13 @@ export function applyContinuationObservationAtomically(store, raw, factRef) {
 }
 function continuationIdentity(observation) {
     const fence = observation.fence;
-    if (fence.taskId === undefined || fence.turnId === undefined
-        || fence.conversationId === undefined || fence.activationId === undefined
-        || fence.continuationId === undefined) {
+    if (fence.taskId === undefined || fence.runId === undefined || fence.conversationId === undefined || fence.continuationId === undefined) {
         throw new Error("Continuation observation fence is incomplete.");
     }
     return {
         providerNamespace: fence.driverId,
         accountScope: fence.agentId,
         conversationId: fence.conversationId,
-        activationId: fence.activationId,
         continuationId: fence.continuationId,
-        generation: fence.continuationGeneration
     };
 }

package/dist/runtime/executionEnvironment.js

@@ -0,0 +1,30 @@
+import { isDeepStrictEqual } from "node:util";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
+import { createProjectResources } from "../resources/projectResourceService.js";
+/** Revalidate the adopted owner; a saved path alone never authorizes execution. */
+export function assertExecutionEnvironmentCurrent(store, taskId, snapshot) {
+    if (snapshot.taskId !== taskId)
+        throw new Error("Execution environment belongs to another Task.");
+    const current = createProjectResources(store).resolveExecutionEnvironment(taskId, snapshot.preparationId);
+    if (!isDeepStrictEqual(current, snapshot)) {
+        throw new Error("Execution environment changed; select an adopted environment and start a new Session.");
+    }
+}
+/** Last local check before native process creation or another Provider input. */
+export function assertAgentExecutionEnvironment(home, payload) {
+    const snapshot = payload.executionEnvironment;
+    if (snapshot === undefined)
+        return;
+    if (payload.environment.YUI_SESSION_SCOPE !== "task"
+        || payload.environment.YUI_TASK_ID !== snapshot.taskId
+        || payload.cwd !== snapshot.directory.path) {
+        throw new Error("Agent launch does not match its adopted execution environment.");
+    }
+    const store = openCurrentTaskStore(home);
+    try {
+        assertExecutionEnvironmentCurrent(store, snapshot.taskId, snapshot);
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/runtime/firstProgressAdvisory.js

@@ -4,15 +4,15 @@ export function projectFirstProgressAdvisory(input) {
         : [...(input.sessions.history ?? []), ...Object.values(input.sessions.sessions)]
             .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
     const unique = [...new Map(sessions.map((session) => [
-            `${session.nativeSessionId}\0${session.runtimeGenerationId ?? ""}`,
+            session.nativeSessionId,
             session
         ])).values()];
-    const firstGenerationAt = unique[0]?.createdAt;
-    const progress = firstGenerationAt === undefined
+    const firstSessionAt = unique[0]?.createdAt;
+    const progress = firstSessionAt === undefined
         ? []
         : [
             ...input.events
-                .filter((event) => typeof event.payload.leaderTurnId === "string")
+                .filter((event) => typeof event.payload.leaderRunId === "string")
                 .map((event) => ({ at: event.createdAt, ref: `event:${event.id}` })),
             ...input.workItems
                 .filter((item) => item.status !== "retired")
@@ -20,21 +20,21 @@ export function projectFirstProgressAdvisory(input) {
             ...input.reviewRounds.map((round) => ({ at: round.createdAt, ref: `review-round:${round.id}` })),
             ...input.integrations.map((attempt) => ({ at: attempt.createdAt, ref: `integration-attempt:${attempt.id}` }))
         ]
-            .filter(({ at }) => at >= firstGenerationAt)
+            .filter(({ at }) => at >= firstSessionAt)
             .sort((left, right) => left.at.localeCompare(right.at) || left.ref.localeCompare(right.ref));
     const firstProgressAt = progress[0]?.at;
-    const generationsBeforeFirstProgress = unique.filter((session) => (firstProgressAt === undefined || session.createdAt <= firstProgressAt)).length;
+    const sessionsBeforeFirstProgress = unique.filter((session) => (firstProgressAt === undefined || session.createdAt <= firstProgressAt)).length;
     const attentionRecommended = firstProgressAt === undefined
-        && generationsBeforeFirstProgress >= 2;
+        && sessionsBeforeFirstProgress >= 2;
     return Object.freeze({
         attentionRecommended,
-        generationsBeforeFirstProgress,
-        ...(firstGenerationAt === undefined ? {} : { firstGenerationAt }),
+        sessionsBeforeFirstProgress,
+        ...(firstSessionAt === undefined ? {} : { firstSessionAt }),
         ...(firstProgressAt === undefined ? {} : { firstProgressAt }),
         reason: attentionRecommended
-            ? `${generationsBeforeFirstProgress} fresh Leader generations produced no first durable progress; Operator attention may be useful before another generation.`
+            ? `${sessionsBeforeFirstProgress} fresh Leader Sessions produced no first durable progress; Operator attention may be useful before another Session.`
             : firstProgressAt !== undefined
                 ? `First durable progress was recorded at ${firstProgressAt}.`
-                : "Fewer than two Leader generations exist before first durable progress."
+                : "Fewer than two Leader Sessions exist before first durable progress."
     });
 }

package/dist/runtime/index.js

@@ -5,16 +5,17 @@ export { createRuntimeBinding } from "./runtimeBinding.js";
 export { normalizeRuntimeOwner } from "./runtimeOwner.js";
 export { createSessionLaunchRequest } from "./sessionLaunchRequest.js";
 export { DEFAULT_RECENT_TURN_ID_LIMIT, hasRecentTurnId, rememberRecentTurnId, validateRecentTurnIds } from "./recentTurnIds.js";
-export { promptPushOutcome, RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeHostUnavailableError, RuntimeLaunchError } from "./ports.js";
+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, discoverProviderRootByLaunchEnv, isLinuxProcessLive, listLaunchFencedProcesses, listOwnedProcessTree, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
+export { createSessionOwnerIdentity, isLinuxProcessLive, listOwnedProcessTree, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
 export { FileSessionOwnerRegistry } from "./sessionOwnerRegistry.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";
 export { codexNotificationBoundary, codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
-export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, managedProviderTurnId, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderAuthority, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, managedProviderTurnId, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 export { FencedProviderControl } from "./providerControl.js";
 export { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 export { reconcileSessionOwners } from "./sessionReconciliation.js";
+export { createAgentEndpointFactory, builtinAgentEndpointImplementation } from "./agentEndpoint.js";

package/dist/runtime/jsonLineChannel.js

@@ -0,0 +1,109 @@
+export const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+/**
+ * Newline-delimited JSON over a child process's stdio. This is a plain shared
+ * transport: it carries whole JSON objects and never interprets them, so any
+ * line-framed Provider protocol can sit on top of it.
+ */
+export class JsonLineChannel {
+    child;
+    mirror;
+    #listeners = new Set();
+    #closeListeners = new Set();
+    #buffer = "";
+    #closedError;
+    constructor(child, mirror) {
+        this.child = child;
+        this.mirror = mirror;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.#receive(chunk));
+        child.once("error", (error) => this.#close(error));
+        child.once("close", (code, signal) => this.#close(new Error(`Provider process exited (code=${code ?? "none"}, signal=${signal ?? "none"}).`)));
+    }
+    /** The transport's terminal failure, once it has one. */
+    get closedError() {
+        return this.#closedError;
+    }
+    onMessage(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    /**
+     * Observe transport closure. A listener registered after the channel already
+     * closed is called immediately, so a caller cannot lose the loss of the pipe
+     * to a registration race and then wait forever for a reply that cannot come.
+     */
+    onClose(listener) {
+        if (this.#closedError !== undefined) {
+            listener(this.#closedError);
+            return () => { };
+        }
+        this.#closeListeners.add(listener);
+        return () => this.#closeListeners.delete(listener);
+    }
+    async send(message) {
+        if (this.#closedError !== undefined)
+            throw this.#closedError;
+        const line = `${JSON.stringify(message)}\n`;
+        if (Buffer.byteLength(line, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
+            throw new Error("Provider request exceeds its message bound.");
+        }
+        await new Promise((resolvePromise, reject) => {
+            this.child.stdin.write(line, "utf8", (error) => {
+                if (error === null || error === undefined)
+                    resolvePromise();
+                else
+                    reject(error);
+            });
+        });
+    }
+    #receive(chunk) {
+        this.mirror("stdout", chunk);
+        this.#buffer += chunk;
+        if (Buffer.byteLength(this.#buffer, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
+            this.#close(new Error("Provider response line exceeds its message bound."));
+            terminateProcessGroup(this.child, "SIGTERM");
+            return;
+        }
+        for (;;) {
+            const newline = this.#buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (line.length === 0)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+                    continue;
+                for (const listener of this.#listeners)
+                    listener(parsed);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    #close(error) {
+        if (this.#closedError !== undefined)
+            return;
+        this.#closedError = error;
+        for (const listener of this.#closeListeners)
+            listener(error);
+    }
+}
+export function terminateProcessGroup(child, signal) {
+    if (child.pid === undefined)
+        return;
+    // Managed Providers are spawned detached and therefore own a process group.
+    // Kill that exact group so a CLI helper cannot outlive the Agent Host. The
+    // direct-child fallback covers embedded runtimes that cannot create setsid.
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+        child.kill(signal);
+    }
+}

package/dist/runtime/launchBroker.js

@@ -1,7 +1,13 @@
 import { randomBytes } from "node:crypto";
-import { resolve } from "node:path";
+import { resolve, isAbsolute } from "node:path";
 import { validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { AGENT_HOST_LAUNCH_TICKET_TTL_MS } from "./runtimeDeadlines.js";
+import { validateAgentEndpointImplementation } from "./agentEndpointIdentity.js";
+import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
+import { isAgentAdapterId } from "../agent/adapterCatalog.js";
+import { adapterIdForExecutionComponent, isAgentExecutionComponentId } from "../agent/executionComponents.js";
+import { agentTransportForAdapter } from "../agent/connectionPlan.js";
+import { resolveAgentAdapter } from "../executor/agentAdapter.js";
 const brokers = new Map();
 /** One Controller-process broker per canonical Home. Payloads never hit disk or tmux. */
 export function launchBrokerForHome(home) {
@@ -17,30 +23,27 @@ export class LaunchBroker {
     #reservations = new Map();
     reserve(payload) {
         validatePayload(payload);
-        if (this.#reservations.has(payload.runtimeGenerationId)) {
-            throw new Error(`Launch payload is already reserved: ${payload.runtimeGenerationId}.`);
-        }
         const ticket = randomBytes(32).toString("hex");
-        this.#reservations.set(payload.runtimeGenerationId, Object.freeze({
+        this.#reservations.set(ticket, Object.freeze({
             ticket,
             payload,
             createdAt: Date.now()
         }));
-        return Object.freeze({ runtimeGenerationId: payload.runtimeGenerationId, ticket });
+        return Object.freeze({ ticket });
     }
-    redeem(runtimeGenerationId, ticket) {
-        const reservation = this.#reservations.get(runtimeGenerationId);
+    redeem(ticket) {
+        const reservation = this.#reservations.get(ticket);
         if (reservation === undefined || reservation.ticket !== ticket) {
             throw new Error("Launch ticket is invalid or already consumed.");
         }
-        this.#reservations.delete(runtimeGenerationId);
+        this.#reservations.delete(ticket);
         if (Date.now() - reservation.createdAt > AGENT_HOST_LAUNCH_TICKET_TTL_MS) {
             throw new Error("Launch ticket expired before redemption.");
         }
         return reservation.payload;
     }
-    revoke(runtimeGenerationId) {
-        this.#reservations.delete(runtimeGenerationId);
+    revoke(ticket) {
+        this.#reservations.delete(ticket);
     }
     pendingCount() {
         return this.#reservations.size;
@@ -55,7 +58,6 @@ export function validateAgentHostLaunchPayload(value) {
 function validatePayload(payload) {
     if (payload.schemaVersion !== 2)
         throw new Error("Agent Host launch payload version is invalid.");
-    text(payload.runtimeGenerationId, "runtimeGenerationId");
     text(payload.command, "command");
     text(payload.cwd, "cwd");
     if (!Array.isArray(payload.args))
@@ -70,6 +72,14 @@ function validatePayload(payload) {
             throw new Error("Agent Host launch environment value is invalid.");
         }
     }
+    if (payload.executionEnvironment !== undefined) {
+        const adopted = validateExecutionEnvironmentSnapshot(payload.executionEnvironment);
+        if (payload.environment.YUI_SESSION_SCOPE !== "task"
+            || payload.environment.YUI_TASK_ID !== adopted.taskId
+            || payload.cwd !== adopted.directory.path) {
+            throw new Error("Agent Host execution environment does not match its Task and cwd.");
+        }
+    }
     if (payload.childLifecycle !== "persistent" && payload.childLifecycle !== "per-turn") {
         throw new Error("Agent Host child lifecycle is invalid.");
     }
@@ -83,18 +93,37 @@ function validatePayload(payload) {
 function validateProviderControl(control) {
     if (control.schemaVersion !== 1)
         throw new Error("Agent Host Provider control version is invalid.");
-    if (control.adapterId !== "codex" && control.adapterId !== "claude") {
+    if (control.endpointImplementation !== undefined)
+        validateAgentEndpointImplementation(control.endpointImplementation);
+    if (!isAgentAdapterId(control.adapterId)) {
         throw new Error("Agent Host Provider control adapter is invalid.");
     }
-    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-proxy")
-        || (control.adapterId === "claude" && control.transport !== "claude-stream-json")) {
+    // The connection plan owns the protocol/transport pair. Re-deriving it here
+    // is what keeps a control from naming a carrier its adapter does not speak.
+    if (control.transport !== agentTransportForAdapter(control.adapterId)) {
         throw new Error("Agent Host Provider control transport does not match its adapter.");
     }
+    // The component determines its plan, so a control naming both must have them
+    // agree. Letting them drift would let a launch apply one product's
+    // configuration decisions to another product's Session.
+    if (control.component !== undefined) {
+        if (!isAgentExecutionComponentId(control.component)) {
+            throw new Error("Agent Host Provider control execution component is invalid.");
+        }
+        if (adapterIdForExecutionComponent(control.component) !== control.adapterId) {
+            throw new Error("Agent Host Provider control execution component does not match its adapter.");
+        }
+    }
     if ((control.adapterId === "codex") !== (control.codexThread !== undefined)) {
         throw new Error("Agent Host Provider thread settings do not match its adapter.");
     }
     if (control.codexThread !== undefined)
         validateCodexThreadOptions(control.codexThread);
+    if (control.adapterId !== "acp" && control.acpSession !== undefined) {
+        throw new Error("Agent Host ACP session settings do not match its adapter.");
+    }
+    if (control.acpSession !== undefined)
+        validateAcpSessionOptions(control.acpSession);
     if (control.mode !== "new" && control.mode !== "resume") {
         throw new Error("Agent Host Provider control mode is invalid.");
     }
@@ -114,7 +143,11 @@ function validateProviderControl(control) {
         text(control.ownedTurn.attemptId, "owned Provider input attemptId");
         text(control.ownedTurn.turnId, "owned Provider Turn id");
     }
-    const requiresNativeSessionId = control.mode === "resume" || control.adapterId === "claude";
+    // Resume always needs the id being resumed. A new launch needs one only from
+    // an Agent that accepts a caller-chosen Session id; the others report theirs
+    // once they answer, so demanding it up front rejects a valid launch.
+    const requiresNativeSessionId = control.mode === "resume"
+        || resolveAgentAdapter(control.adapterId).capabilities.nativeSessionDiscovery === "preallocated";
     if (requiresNativeSessionId !== (control.nativeSessionId !== undefined)) {
         throw new Error("Agent Host Provider resume identity is inconsistent.");
     }
@@ -155,6 +188,48 @@ function validateCodexThreadOptions(options) {
         throw new Error("Agent Host Codex thread config is invalid.");
     }
 }
+function validateAcpSessionOptions(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new Error("Agent Host ACP session settings are invalid.");
+    }
+    if (options.additionalDirectories !== undefined) {
+        if (!Array.isArray(options.additionalDirectories)) {
+            throw new Error("Agent Host ACP additional workspace roots are invalid.");
+        }
+        // ACP requires each additional root to be absolute. Rejecting a relative
+        // path here keeps an invalid request from reaching the Agent at all.
+        for (const root of options.additionalDirectories) {
+            if (!isAbsolute(text(root, "ACP additional workspace root"))) {
+                throw new Error("Agent Host ACP additional workspace root must be absolute.");
+            }
+        }
+    }
+    if (options.sessionBootstrap !== undefined) {
+        text(options.sessionBootstrap, "ACP session bootstrap");
+    }
+    const desired = options.desiredConfiguration;
+    if (desired !== undefined) {
+        if (desired === null || typeof desired !== "object" || Array.isArray(desired)) {
+            throw new Error("Agent Host ACP session configuration is invalid.");
+        }
+        if (desired.model !== undefined)
+            text(desired.model, "ACP session model");
+        if (desired.effort !== undefined)
+            text(desired.effort, "ACP session effort");
+        if (desired.permissionMode !== undefined) {
+            text(desired.permissionMode, "ACP session permission mode");
+        }
+        if (desired.permissionBypass !== undefined && typeof desired.permissionBypass !== "boolean") {
+            throw new Error("Agent Host ACP session permission bypass is invalid.");
+        }
+        // Naming an exact mode and asking for bypass are two different requests, and
+        // a payload carrying both leaves it ambiguous which one the user made.
+        if (desired.permissionMode !== undefined && desired.permissionBypass === true) {
+            throw new Error("Agent Host ACP session configuration cannot request both a named permission "
+                + "mode and the bypass strategy.");
+        }
+    }
+}
 function text(value, label) {
     if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
         throw new Error(`Agent Host ${label} is invalid.`);