@zq-silk/yui 0.13.2 → 0.13.4

package/dist/runtime/codexAppServerRuntime.js

@@ -22,21 +22,17 @@ export class CodexAppServerRuntime {
     async openConversation(input) {
         const result = await this.transport.request("thread/start", {
             cwd: text(input.cwd, "Codex thread cwd"),
-            ...(input.model === undefined ? {} : { model: input.model }),
-            ...(input.approvalPolicy === undefined ? {} : { approvalPolicy: input.approvalPolicy }),
-            ...(input.sandbox === undefined ? {} : { sandbox: input.sandbox }),
-            ...(input.developerInstructions === undefined
-                ? {}
-                : { developerInstructions: input.developerInstructions }),
-            ...(input.runtimeWorkspaceRoots === undefined
-                ? {}
-                : { runtimeWorkspaceRoots: [...input.runtimeWorkspaceRoots] })
+            ...threadOptions(input)
         });
         return { conversationId: threadId(result) };
     }
-    async resumeConversation(conversationId) {
+    async resumeConversation(conversationId, options = {}) {
         const id = text(conversationId, "Codex thread id");
-        const result = await this.transport.request("thread/resume", { threadId: id });
+        const result = await this.transport.request("thread/resume", {
+            threadId: id,
+            ...(options.cwd === undefined ? {} : { cwd: text(options.cwd, "Codex thread cwd") }),
+            ...threadOptions(options)
+        });
         return parseThreadSnapshot(result, id, true);
     }
     async setConversationName(input) {
@@ -85,7 +81,11 @@ export class CodexAppServerRuntime {
             const snapshot = await this.readConversation(requestedThreadId);
             threadId = snapshot.threadId;
             if (input.expectedNoActiveTurn && snapshot.activeTurnId !== undefined) {
-                return { status: "not-accepted", reason: `active-turn:${snapshot.activeTurnId}` };
+                return {
+                    status: "busy",
+                    activeTurnId: snapshot.activeTurnId,
+                    reason: `active-turn:${snapshot.activeTurnId}`
+                };
             }
         }
         catch (error) {
@@ -249,12 +249,25 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
     const turns = arrayMember(thread, "turns").map(object).filter((entry) => (entry !== null));
     const active = [...turns].reverse().find((turn) => (["inProgress", "in_progress", "running", "active"].includes(String(turn.status))));
     const latestStatus = optionalTurnStatus(turns.at(-1)?.status);
+    const turnSnapshots = turns.flatMap((turn) => {
+        const turnId = optionalId(turn.id);
+        if (turnId === undefined)
+            return [];
+        const status = optionalTurnStatus(turn.status);
+        const error = providerError(turn.error);
+        return [{
+                turnId,
+                ...(status === undefined ? {} : { status }),
+                ...(error === undefined ? {} : { error })
+            }];
+    });
     return {
         threadId: id,
         loaded,
         status: threadStatus(thread.status),
         ...(optionalId(active?.id) === undefined ? {} : { activeTurnId: optionalId(active?.id) }),
         ...(latestStatus === undefined ? {} : { latestTurnStatus: latestStatus }),
+        turns: Object.freeze(turnSnapshots),
         ...(optionalId(thread.parentThreadId) === undefined
             ? {}
             : { parentThreadId: optionalId(thread.parentThreadId) }),
@@ -262,6 +275,17 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         raw: result
     };
 }
+function providerError(value) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return value.trim();
+    const record = object(value);
+    if (record === null)
+        return undefined;
+    if (typeof record.message === "string" && record.message.trim().length > 0) {
+        return record.message.trim();
+    }
+    return JSON.stringify(record);
+}
 function codexContinuationState(snapshot) {
     if (snapshot.status === "active" || snapshot.latestTurnStatus === "inProgress") {
         return {
@@ -317,12 +341,19 @@ 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")
@@ -366,3 +397,23 @@ function text(value, label) {
     }
     return value.trim();
 }
+function threadOptions(input) {
+    return {
+        ...(input.model === undefined ? {} : { model: text(input.model, "Codex model") }),
+        ...(input.approvalPolicy === undefined
+            ? {}
+            : { approvalPolicy: text(input.approvalPolicy, "Codex approval policy") }),
+        ...(input.sandbox === undefined ? {} : { sandbox: text(input.sandbox, "Codex sandbox") }),
+        ...(input.developerInstructions === undefined
+            ? {}
+            : {
+                developerInstructions: text(input.developerInstructions, "Codex developer instructions")
+            }),
+        ...(input.runtimeWorkspaceRoots === undefined
+            ? {}
+            : {
+                runtimeWorkspaceRoots: input.runtimeWorkspaceRoots.map((root) => (text(root, "Codex runtime workspace root")))
+            }),
+        ...(input.config === undefined ? {} : { config: { ...input.config } })
+    };
+}

package/dist/runtime/launchBroker.js

@@ -86,10 +86,25 @@ function validateProviderControl(control) {
     if (control.adapterId !== "codex" && control.adapterId !== "claude") {
         throw new Error("Agent Host Provider control adapter is invalid.");
     }
-    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-stdio")
+    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-proxy")
         || (control.adapterId === "claude" && control.transport !== "claude-stream-json")) {
         throw new Error("Agent Host Provider control transport 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.adapterId === "codex") !== (control.codexDaemonStartArgs !== undefined)) {
+        throw new Error("Agent Host Provider daemon bootstrap does not match its adapter.");
+    }
+    if (control.codexThread !== undefined)
+        validateCodexThreadOptions(control.codexThread);
+    if (control.codexDaemonStartArgs !== undefined) {
+        if (!Array.isArray(control.codexDaemonStartArgs)
+            || control.codexDaemonStartArgs.length === 0) {
+            throw new Error("Agent Host Codex daemon bootstrap args are invalid.");
+        }
+        control.codexDaemonStartArgs.forEach((value) => text(value, "Codex daemon argument"));
+    }
     if (control.mode !== "new" && control.mode !== "resume") {
         throw new Error("Agent Host Provider control mode is invalid.");
     }
@@ -105,6 +120,16 @@ function validateProviderControl(control) {
     if (control.kind === "ensure" && control.initialTurn !== undefined) {
         throw new Error("Managed Provider ensure launch cannot carry a new Turn.");
     }
+    if (control.kind !== "ensure" && "ownedTurn" in control) {
+        throw new Error("Only a managed Provider ensure launch can recover an owned Turn.");
+    }
+    if (control.kind === "ensure" && control.ownedTurn !== undefined) {
+        if (control.adapterId !== "codex") {
+            throw new Error("Only Managed Codex can recover an owned Turn across client attachment.");
+        }
+        text(control.ownedTurn.attemptId, "owned Provider input attemptId");
+        text(control.ownedTurn.turnId, "owned Provider Turn id");
+    }
     const requiresNativeSessionId = control.mode === "resume" || control.adapterId === "claude";
     if (requiresNativeSessionId !== (control.nativeSessionId !== undefined)) {
         throw new Error("Agent Host Provider resume identity is inconsistent.");
@@ -129,6 +154,31 @@ function validateProviderControl(control) {
         }
     }
 }
+function validateCodexThreadOptions(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new Error("Agent Host Codex thread settings are invalid.");
+    }
+    for (const [value, label] of [
+        [options.model, "model"],
+        [options.approvalPolicy, "approval policy"],
+        [options.sandbox, "sandbox"],
+        [options.developerInstructions, "developer instructions"]
+    ]) {
+        if (value !== undefined)
+            text(value, `Codex thread ${label}`);
+    }
+    if (options.runtimeWorkspaceRoots !== undefined) {
+        if (!Array.isArray(options.runtimeWorkspaceRoots)) {
+            throw new Error("Agent Host Codex runtime workspace roots are invalid.");
+        }
+        options.runtimeWorkspaceRoots.forEach((root) => text(root, "Codex runtime workspace root"));
+    }
+    if (options.config !== undefined
+        && (options.config === null || typeof options.config !== "object"
+            || Array.isArray(options.config))) {
+        throw new Error("Agent Host Codex thread config is invalid.");
+    }
+}
 function text(value, label) {
     if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
         throw new Error(`Agent Host ${label} is invalid.`);

package/dist/runtime/runtimeBinding.js

@@ -14,7 +14,15 @@ export function createRuntimeBinding(input) {
     const initialTurnRejectedRunId = input.initialTurnRejectedRunId === undefined
         ? undefined
         : requireSafeIdentity(input.initialTurnRejectedRunId, "Rejected initial Turn Run id");
-    if ([initialTurnRunId, initialTurnDeliveryUnknownRunId, initialTurnRejectedRunId]
+    const initialTurnBusyRunId = input.initialTurnBusyRunId === undefined
+        ? undefined
+        : requireSafeIdentity(input.initialTurnBusyRunId, "Busy initial Turn Run id");
+    if ([
+        initialTurnRunId,
+        initialTurnDeliveryUnknownRunId,
+        initialTurnBusyRunId,
+        initialTurnRejectedRunId
+    ]
         .filter((value) => value !== undefined).length > 1) {
         throw new TypeError("Runtime binding must report at most one initial Turn outcome.");
     }
@@ -30,6 +38,7 @@ export function createRuntimeBinding(input) {
         ...(initialTurnDeliveryUnknownRunId === undefined
             ? {}
             : { initialTurnDeliveryUnknownRunId }),
+        ...(initialTurnBusyRunId === undefined ? {} : { initialTurnBusyRunId }),
         ...(initialTurnRejectedRunId === undefined ? {} : { initialTurnRejectedRunId }),
         ...(input.nativeSessionId === undefined
             ? {}

package/dist/runtime/structuredProviderHost.js

@@ -4,6 +4,8 @@ import { CodexAppServerRequestError, CodexAppServerRuntime, codexAppServerErrorI
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { YUI_VERSION } from "../version.js";
 const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
+const CODEX_DAEMON_START_TIMEOUT_MS = 10_000;
+const CODEX_DAEMON_OUTPUT_MAX_BYTES = 64 * 1024;
 export class ProviderDeliveryUnknownError extends Error {
     attemptId;
     name = "ProviderDeliveryUnknownError";
@@ -20,6 +22,17 @@ export class ProviderTurnRejectedError extends Error {
         this.attemptId = attemptId;
     }
 }
+/** Another ordinary client currently owns the thread's active Turn. */
+export class ProviderTurnBusyError extends Error {
+    attemptId;
+    activeTurnId;
+    name = "ProviderTurnBusyError";
+    constructor(message, attemptId, activeTurnId) {
+        super(message);
+        this.attemptId = attemptId;
+        this.activeTurnId = activeTurnId;
+    }
+}
 export class ProviderConversationMissingError extends Error {
     conversationId;
     name = "ProviderConversationMissingError";
@@ -33,6 +46,9 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control === undefined) {
         throw new Error("Managed Agent Host launch requires Provider control metadata.");
     }
+    if (control.adapterId === "codex") {
+        await ensureCodexAppServerDaemon(payload, control);
+    }
     const child = spawn(payload.command, [...payload.args], {
         cwd: payload.cwd,
         env: { ...payload.environment },
@@ -45,9 +61,16 @@ export async function startStructuredProviderSession(payload, input = {}) {
     child.stderr.on("data", (chunk) => mirror("stderr", chunk));
     const exit = childExit(child, processInstanceId);
     try {
-        const session = control.adapterId === "codex"
-            ? await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onTerminal, mirror)
-            : await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onTerminal, mirror);
+        if (control.adapterId === "codex") {
+            const opened = await CodexStructuredProviderSession.open(child, exit, processInstanceId, payload, control, input.onTerminal, mirror);
+            return Object.freeze({
+                session: opened.session,
+                ...(opened.recoveredTerminal === undefined
+                    ? {}
+                    : { recoveredTerminal: opened.recoveredTerminal })
+            });
+        }
+        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onTerminal, mirror);
         return Object.freeze({ session });
     }
     catch (error) {
@@ -55,6 +78,58 @@ export async function startStructuredProviderSession(payload, input = {}) {
         throw error;
     }
 }
+async function ensureCodexAppServerDaemon(payload, control) {
+    if (payload.args.at(-2) !== "app-server" || payload.args.at(-1) !== "proxy")
+        return;
+    if (control.adapterId !== "codex")
+        return;
+    const environment = Object.fromEntries(Object.entries(payload.environment).filter(([key]) => (!key.startsWith("YUI_")
+        && key !== "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
+        && !["TMPDIR", "XDG_CACHE_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_RUNTIME_DIR"]
+            .includes(key))));
+    const child = spawn(payload.command, [...control.codexDaemonStartArgs], {
+        cwd: payload.cwd,
+        env: environment,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    await new Promise((resolvePromise, reject) => {
+        let output = "";
+        let settled = false;
+        let timer;
+        const settle = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (error === undefined)
+                resolvePromise();
+            else
+                reject(error);
+        };
+        const capture = (chunk) => {
+            output += String(chunk);
+            if (Buffer.byteLength(output, "utf8") <= CODEX_DAEMON_OUTPUT_MAX_BYTES)
+                return;
+            child.kill("SIGTERM");
+            settle(new Error("Codex App Server daemon start output exceeded its bound."));
+        };
+        child.stdout.on("data", capture);
+        child.stderr.on("data", capture);
+        child.once("error", (error) => settle(error));
+        child.once("close", (code, signal) => {
+            if (code === 0)
+                settle();
+            else
+                settle(new Error(`Codex App Server daemon start failed (${code ?? signal ?? "unknown"})${output.trim().length === 0 ? "" : `: ${output.trim()}`}`));
+        });
+        timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            settle(new Error("Codex App Server daemon start timed out."));
+        }, CODEX_DAEMON_START_TIMEOUT_MS);
+        timer.unref();
+    });
+}
 class JsonLineChannel {
     child;
     mirror;
@@ -181,17 +256,24 @@ class CodexStructuredProviderSession {
     processInstanceId;
     conversationId;
     runtime;
+    onTerminal;
     adapterId = "codex";
     #activeTurnId;
-    constructor(child, exit, processInstanceId, conversationId, runtime) {
+    #clientOwnedTurnId;
+    #submissionPending = false;
+    #bufferedTerminals = [];
+    constructor(child, exit, processInstanceId, conversationId, runtime, onTerminal) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
         this.conversationId = conversationId;
         this.runtime = runtime;
+        this.onTerminal = onTerminal;
     }
     static async open(child, exit, processInstanceId, payload, control, onTerminal, mirror) {
         const channel = new JsonLineChannel(child, mirror);
+        const openingMessages = [];
+        const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         await channel.request("initialize", {
             clientInfo: { name: "yui", title: "Yui", version: YUI_VERSION },
             capabilities: {
@@ -203,14 +285,22 @@ class CodexStructuredProviderSession {
         const runtime = new CodexAppServerRuntime(channel);
         let conversationId;
         let resumedActiveTurnId;
+        let resumedTurns = [];
         if (control.mode === "new") {
-            conversationId = (await runtime.openConversation({ cwd: payload.cwd })).conversationId;
+            conversationId = (await runtime.openConversation({
+                cwd: payload.cwd,
+                ...control.codexThread
+            })).conversationId;
         }
         else {
             try {
-                const resumed = await runtime.resumeConversation(control.nativeSessionId);
+                const resumed = await runtime.resumeConversation(control.nativeSessionId, {
+                    cwd: payload.cwd,
+                    ...control.codexThread
+                });
                 conversationId = resumed.threadId;
                 resumedActiveTurnId = resumed.activeTurnId;
+                resumedTurns = resumed.turns;
             }
             catch (error) {
                 if (codexAppServerErrorIsMissing(error)) {
@@ -225,39 +315,81 @@ class CodexStructuredProviderSession {
                 name: control.sessionTitle
             });
         }
-        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime);
+        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onTerminal);
         session.#activeTurnId = resumedActiveTurnId;
+        const ownedTurn = control.kind === "ensure" ? control.ownedTurn : undefined;
+        session.#clientOwnedTurnId = ownedTurn?.turnId;
+        stopOpeningBuffer();
+        let recoveredTerminal;
+        for (const message of openingMessages) {
+            const terminal = session.#observeMessage(message, false);
+            if (terminal?.clientOwned === true)
+                recoveredTerminal = terminal;
+        }
         channel.onMessage((message) => {
-            const method = typeof message.method === "string" ? message.method : "";
-            const params = object(message.params) ?? {};
-            if (optionalId(params.threadId) !== conversationId)
-                return;
-            if (method === "turn/started") {
-                const turnId = nestedId(params, "turn") ?? optionalId(params.turnId);
-                if (turnId !== undefined)
-                    session.#activeTurnId = turnId;
-                return;
+            session.#observeMessage(message, true);
+        });
+        if (ownedTurn !== undefined && recoveredTerminal === undefined
+            && session.#activeTurnId !== ownedTurn.turnId) {
+            const recovered = resumedTurns.find((turn) => turn.turnId === ownedTurn.turnId);
+            if (recovered?.status === "completed"
+                || recovered?.status === "interrupted"
+                || recovered?.status === "failed") {
+                recoveredTerminal = {
+                    conversationId,
+                    nativeSessionId: conversationId,
+                    nativeTurnId: ownedTurn.turnId,
+                    clientOwned: true,
+                    status: recovered.status === "failed"
+                        ? "failed"
+                        : recovered.status === "interrupted" ? "cancelled" : "completed",
+                    observedAt: new Date().toISOString(),
+                    ...(recovered.error === undefined ? {} : { error: recovered.error })
+                };
+                session.#clientOwnedTurnId = undefined;
             }
-            if (method !== "turn/completed")
-                return;
-            const turn = object(params.turn) ?? {};
-            const nativeTurnId = optionalId(turn.id) ?? optionalId(params.turnId);
-            if (nativeTurnId === undefined)
-                return;
-            session.#activeTurnId = undefined;
-            const status = turn.status === "failed"
-                ? "failed"
-                : turn.status === "interrupted" ? "cancelled" : "completed";
-            onTerminal?.({
-                conversationId,
-                nativeSessionId: conversationId,
-                nativeTurnId,
-                status,
-                observedAt: new Date().toISOString(),
-                ...(status !== "failed" ? {} : { error: providerErrorText(turn.error) })
-            });
+            else {
+                throw new ProviderDeliveryUnknownError(`Codex resume could not recover the persisted Yui Turn ${ownedTurn.turnId}.`, ownedTurn.attemptId);
+            }
+        }
+        return Object.freeze({
+            session,
+            ...(recoveredTerminal === undefined ? {} : { recoveredTerminal })
         });
-        return session;
+    }
+    #observeMessage(message, emit) {
+        const method = typeof message.method === "string" ? message.method : "";
+        const params = object(message.params) ?? {};
+        if (optionalId(params.threadId) !== this.conversationId)
+            return undefined;
+        if (method === "turn/started") {
+            const turnId = nestedId(params, "turn") ?? optionalId(params.turnId);
+            if (turnId !== undefined)
+                this.#activeTurnId = turnId;
+            return undefined;
+        }
+        if (method !== "turn/completed")
+            return undefined;
+        const turn = object(params.turn) ?? {};
+        const nativeTurnId = optionalId(turn.id) ?? optionalId(params.turnId);
+        if (nativeTurnId === undefined)
+            return undefined;
+        const status = turn.status === "failed"
+            ? "failed"
+            : turn.status === "interrupted" ? "cancelled" : "completed";
+        const terminal = {
+            conversationId: this.conversationId,
+            nativeSessionId: this.conversationId,
+            nativeTurnId,
+            status,
+            observedAt: new Date().toISOString(),
+            ...(status !== "failed" ? {} : { error: providerErrorText(turn.error) })
+        };
+        if (this.#submissionPending && emit) {
+            this.#bufferedTerminals.push(terminal);
+            return undefined;
+        }
+        return this.#completeTerminal(terminal, emit);
     }
     get nativeSessionId() {
         return this.conversationId;
@@ -267,28 +399,55 @@ class CodexStructuredProviderSession {
     }
     async submitTurn(turn) {
         if (this.#activeTurnId !== undefined) {
-            throw new ProviderTurnRejectedError(`Provider Conversation already has active Turn ${this.#activeTurnId}.`, turn.attemptId);
+            throw new ProviderTurnBusyError(`Provider Conversation already has active Turn ${this.#activeTurnId}.`, turn.attemptId, this.#activeTurnId);
         }
-        const acceptance = await this.runtime.submitTurn({
-            conversationId: this.conversationId,
-            attemptId: turn.attemptId,
-            text: turn.boundedText,
-            expectedNoActiveTurn: true
-        });
-        if (acceptance.status === "unknown") {
-            throw new ProviderDeliveryUnknownError(acceptance.reason, turn.attemptId);
+        this.#submissionPending = true;
+        try {
+            const acceptance = await this.runtime.submitTurn({
+                conversationId: this.conversationId,
+                attemptId: turn.attemptId,
+                text: turn.boundedText,
+                expectedNoActiveTurn: true
+            });
+            if (acceptance.status === "unknown") {
+                throw new ProviderDeliveryUnknownError(acceptance.reason, turn.attemptId);
+            }
+            if (acceptance.status === "busy") {
+                throw new ProviderTurnBusyError(acceptance.reason, turn.attemptId, acceptance.activeTurnId);
+            }
+            if (acceptance.status === "not-accepted") {
+                throw new ProviderTurnRejectedError(acceptance.reason, turn.attemptId);
+            }
+            this.#activeTurnId = acceptance.turnId;
+            this.#clientOwnedTurnId = acceptance.turnId;
+            return Object.freeze({
+                attemptId: turn.attemptId,
+                conversationId: this.conversationId,
+                nativeSessionId: this.conversationId,
+                nativeTurnId: acceptance.turnId,
+                acceptedAt: new Date().toISOString()
+            });
         }
-        if (acceptance.status === "not-accepted") {
-            throw new ProviderTurnRejectedError(acceptance.reason, turn.attemptId);
+        finally {
+            this.#submissionPending = false;
+            const buffered = this.#bufferedTerminals.splice(0);
+            for (const terminal of buffered)
+                this.#emitTerminal(terminal);
         }
-        this.#activeTurnId = acceptance.turnId;
-        return Object.freeze({
-            attemptId: turn.attemptId,
-            conversationId: this.conversationId,
-            nativeSessionId: this.conversationId,
-            nativeTurnId: acceptance.turnId,
-            acceptedAt: new Date().toISOString()
-        });
+    }
+    #emitTerminal(terminal) {
+        this.#completeTerminal(terminal, true);
+    }
+    #completeTerminal(terminal, emit) {
+        const clientOwned = terminal.nativeTurnId === this.#clientOwnedTurnId;
+        if (terminal.nativeTurnId === this.#activeTurnId)
+            this.#activeTurnId = undefined;
+        if (clientOwned)
+            this.#clientOwnedTurnId = undefined;
+        const completed = { ...terminal, clientOwned };
+        if (emit)
+            this.onTerminal?.(completed);
+        return completed;
     }
     waitForExit() {
         return this.exit;
@@ -420,6 +579,7 @@ class ClaudeStructuredProviderSession {
             conversationId: this.conversationId,
             nativeSessionId: this.conversationId,
             nativeTurnId,
+            clientOwned: true,
             status: failed ? "failed" : "completed",
             observedAt: new Date().toISOString(),
             ...(typeof message.result === "string" && message.result.length > 0

package/dist/runtime/tmuxAdapters.js

@@ -350,6 +350,7 @@ export class TmuxSessionHost {
         let hostCreated;
         let providerAcknowledged = false;
         let providerDeliveryUnknown = false;
+        let providerBusy = false;
         let providerRejected = false;
         let providerDispatchObserved = false;
         let providerSnapshot;
@@ -365,9 +366,11 @@ export class TmuxSessionHost {
                     requireTurnAck: planned.initialTurnRunId !== undefined
                 });
                 providerDeliveryUnknown = providerSnapshot.state === "delivery-unknown";
+                providerBusy = planned.initialTurnRunId !== undefined
+                    && providerSnapshot.state === "busy";
                 providerRejected = planned.initialTurnRunId !== undefined
                     && providerSnapshot.state === "rejected";
-                providerAcknowledged = !providerDeliveryUnknown && !providerRejected;
+                providerAcknowledged = !providerDeliveryUnknown && !providerBusy && !providerRejected;
                 if (providerSnapshot.state === "rejected" && !providerRejected) {
                     throw new Error("Agent Host rejected a launch without an initial Provider Turn.");
                 }
@@ -398,9 +401,11 @@ export class TmuxSessionHost {
                         && controlResult.snapshot.state === "idle");
                 const deliveryUnknownState = planned.initialTurnRunId !== undefined
                     && controlResult.snapshot.state === "delivery-unknown";
+                const busyState = planned.initialTurnRunId !== undefined
+                    && controlResult.snapshot.state === "busy";
                 const rejectedState = planned.initialTurnRunId !== undefined
                     && controlResult.snapshot.state === "rejected";
-                if ((!acceptableState && !deliveryUnknownState && !rejectedState)
+                if ((!acceptableState && !deliveryUnknownState && !busyState && !rejectedState)
                     || controlResult.snapshot.launchId !== reservation.launchId) {
                     broker.revoke(request.launchId);
                     throw new Error(`Agent Host did not return an exact Provider acknowledgement for ${reservation.launchId}.`);
@@ -408,6 +413,7 @@ export class TmuxSessionHost {
                 providerSnapshot = controlResult.snapshot;
                 providerAcknowledged = acceptableState;
                 providerDeliveryUnknown = deliveryUnknownState;
+                providerBusy = busyState;
                 providerRejected = rejectedState;
                 providerDispatchObserved = true;
             }
@@ -449,6 +455,9 @@ export class TmuxSessionHost {
             ...(providerDeliveryUnknown && planned.initialTurnRunId !== undefined
                 ? { initialTurnDeliveryUnknownRunId: planned.initialTurnRunId }
                 : {}),
+            ...(providerBusy && planned.initialTurnRunId !== undefined
+                ? { initialTurnBusyRunId: planned.initialTurnRunId }
+                : {}),
             ...(providerRejected && planned.initialTurnRunId !== undefined
                 ? { initialTurnRejectedRunId: planned.initialTurnRunId }
                 : {}),
@@ -567,6 +576,8 @@ export class AgentHostPromptPushAdapter {
             });
             if (result.snapshot.state === "delivery-unknown")
                 return "delivery-unknown";
+            if (result.snapshot.state === "busy")
+                return "busy";
             if (result.outcome === "rejected")
                 return "rejected";
             if (result.snapshot.attemptId !== request.envelope.id) {