@zq-silk/yui 2.21.0 → 2.23.0

package/dist/runtime/nativeTitleSync.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rmdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { createNonBlockingChecks } from "./lifecycleChecks.js";
+import { CodexNamingClient } from "../execution/codexThreadNaming.js";
+import { nativeTitleDirectory, parseNativeTitleReceipt } from "./nativeTitleReceipt.js";
+/** A standalone metadata process, NOT a second connection to the shared
+ * business daemon. It never starts/resumes a Thread or runs a Turn. Its hard
+ * process deadline releases even native locks after an unanswered request.
+ * Caller launches this in an independent lane; Goal/Turn never await it. */
+export async function synchronizeNativeTitle(request) {
+    const result = (status, detail, extra = {}) => ({ threadId: request.identity.threadId, status, detail, ...extra });
+    let client;
+    let locked = false;
+    let submitted = false;
+    let receipt;
+    const cancel = () => client?.close("SIGKILL");
+    const directory = nativeTitleDirectory(request.home, request.identity);
+    try {
+        if (!isAbsolute(request.home) || !isAbsolute(request.accountHome)
+            || [request.title, request.generatedTitle].some(title => title !== undefined
+                && (!title || title.trim() !== title || title.length > 1024 || /[\r\n\0]/u.test(title)))) {
+            return result("not-submitted", "Native title request has an invalid local identity or title.");
+        }
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed.");
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        // Never remove another attempt's lock, including after a Host crash.
+        await mkdir(join(directory, "writing"), { mode: 0o700 });
+        locked = true;
+        try {
+            receipt = parseNativeTitleReceipt(await readFile(join(directory, "receipt.json"), "utf8"), request.identity);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (receipt !== undefined && (receipt.accountHome !== request.accountHome || receipt.status !== "confirmed")) {
+            return result("not-submitted", "Prior title identity/effect is unresolved; no rename replayed.", { attemptId: receipt.attemptId, receiptPath: join(directory, "receipt.json") });
+        }
+        if (request.localTitle !== undefined && request.localTitle !== request.previousTitle
+            && !receipt?.generatedTitles.includes(request.localTitle)) {
+            return result("preserved", "Yui Session has a custom or unowned local title; native name left unchanged.");
+        }
+        client = await CodexNamingClient.start(request.command, { ...request.environment, CODEX_HOME: request.accountHome }, request.baseArgs, request.timeoutMs ?? 2_000);
+        request.signal?.addEventListener("abort", cancel, { once: true });
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed.");
+        if (client.accountHome !== request.accountHome) {
+            return result("not-submitted", "Metadata process account identity did not match the business connection.");
+        }
+        const read = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const thread = read.thread;
+        if (thread?.id !== request.identity.threadId
+            || !(thread.name == null || typeof thread.name === "string")) {
+            return result("not-submitted", "Native title observation has no exact Thread/name identity.");
+        }
+        const current = typeof thread.name === "string" && thread.name.length > 0 ? thread.name : null;
+        const previous = receipt?.requestedTitle ?? request.previousTitle;
+        const title = request.generatedTitle !== undefined
+            && (request.title === previous || receipt?.generatedTitles.includes(request.title))
+            ? request.generatedTitle : request.title;
+        // A prefix (including the historic Skill notice) is not ownership proof.
+        if (current !== previous && !(request.newThread && current === null && receipt === undefined)) {
+            const pollution = [current, thread.preview].some(value => typeof value === "string"
+                && (value.startsWith("Yui Host checked current Skills;")
+                    || value.startsWith("Yui Session Manifest:")
+                    || value.startsWith("<!-- yui:skills-checked -->")));
+            return result("preserved", pollution
+                ? "Historical Skill-prefix title/preview candidate; no native ownership proof, so no repair submitted."
+                : "Native name has no matching generated-title provenance; left unchanged.");
+        }
+        if (current === title)
+            return result("confirmed", "Existing generated title observed.", { title, ...(receipt === undefined ? {} : { attemptId: receipt.attemptId }) });
+        receipt = {
+            schemaVersion: 1, identity: request.identity, accountHome: request.accountHome,
+            attemptId: randomUUID(), requestedTitle: title, expectedTitle: current,
+            status: "submitted", generatedTitles: receipt?.generatedTitles ?? (previous === undefined ? [] : [previous])
+        };
+        // Durable intent precedes the only mutation. A crash anywhere after this
+        // write is an unknown effect, never permission to resubmit.
+        await saveReceipt(directory, receipt);
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed before mutation.");
+        // Persistence may yield to a user's edit. Recheck immediately before
+        // sending; the native API has no expected-name compare-and-swap.
+        const prewrite = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const fresh = prewrite.thread;
+        if (fresh?.id !== request.identity.threadId || (fresh.name ?? null) !== current) {
+            await saveReceipt(directory, { ...receipt, status: "preserved" });
+            return result("preserved", "Native name changed before submission; no rename sent.", { attemptId: receipt.attemptId });
+        }
+        if (request.signal?.aborted)
+            return result("not-submitted", "Title attachment closed before mutation.");
+        submitted = true;
+        await client.request("thread/name/set", { threadId: request.identity.threadId, name: title });
+        const confirmation = await client.request("thread/read", { threadId: request.identity.threadId, includeTurns: false });
+        const observed = confirmation.thread;
+        if (observed?.id !== request.identity.threadId || observed.name !== title) {
+            throw new Error("Title mutation has no matching readback; preserve unknown effect.");
+        }
+        receipt = { ...receipt, status: "confirmed",
+            generatedTitles: [...new Set([...receipt.generatedTitles, title])] };
+        await saveReceipt(directory, receipt);
+        return result("confirmed", "Native title acknowledged and read back.", {
+            attemptId: receipt.attemptId, title, receiptPath: join(directory, "receipt.json")
+        });
+    }
+    catch (error) {
+        if (submitted && receipt !== undefined) {
+            await saveReceipt(directory, { ...receipt, status: "unknown" }).catch(() => { });
+        }
+        return result(submitted ? "unknown" : "not-submitted", error instanceof Error ? error.message : String(error), receipt === undefined ? {} : { attemptId: receipt.attemptId, receiptPath: join(directory, "receipt.json") });
+    }
+    finally {
+        request.signal?.removeEventListener("abort", cancel);
+        client?.close();
+        await client?.exited;
+        if (locked)
+            await rmdir(join(directory, "writing")).catch(() => { });
+    }
+}
+/** Use task-161's independent lifecycle-check lane without changing its FSM.
+ * One trigger per attachment; receipt fencing handles reconnects/other Hosts. */
+export function createNativeTitleSync(payload, threadId, accountHome, report) {
+    let triggered = false;
+    const checks = createNonBlockingChecks([{
+            id: "native-title",
+            async run(_observation, signal) {
+                const env = payload.environment;
+                const title = payload.providerControl?.sessionTitle ?? env.YUI_SESSION_TITLE ?? env.YUI_NATIVE_TITLE_PROPOSAL;
+                if (title === undefined)
+                    return;
+                const scope = env.YUI_SESSION_SCOPE;
+                if (!accountHome || !env.YUI_HOME || !env.YUI_ROLE || !env.YUI_AGENT_ID
+                    || !["task", "global"].includes(scope ?? "") || scope === "task" && !env.YUI_TASK_ID
+                    || !env.YUI_AGENT_BASE_ARGS) {
+                    report({ threadId, status: "not-submitted", detail: "Native title synchronization lacks an exact local account/launch identity." });
+                    return;
+                }
+                const baseArgs = JSON.parse(env.YUI_AGENT_BASE_ARGS);
+                if (!Array.isArray(baseArgs) || baseArgs.some(value => typeof value !== "string")) {
+                    throw new Error("Invalid native naming executable arguments.");
+                }
+                const observed = await synchronizeNativeTitle({
+                    home: env.YUI_HOME, identity: {
+                        scope: scope,
+                        ...(scope === "task" ? { taskId: env.YUI_TASK_ID } : {}),
+                        roleName: env.YUI_ROLE, agentId: env.YUI_AGENT_ID, threadId
+                    },
+                    accountHome, command: payload.command, baseArgs,
+                    environment: env, title,
+                    ...(env.YUI_NATIVE_TITLE_PROPOSAL === undefined ? {} : { generatedTitle: env.YUI_NATIVE_TITLE_PROPOSAL }),
+                    ...(env.YUI_NATIVE_TITLE_LOCAL === undefined ? {} : { localTitle: env.YUI_NATIVE_TITLE_LOCAL }),
+                    newThread: payload.providerControl?.mode === "new"
+                        || payload.providerControl === undefined && env.YUI_NATIVE_SESSION_ID === undefined,
+                    ...(payload.providerControl?.previousSessionTitle === undefined ? {} : {
+                        previousTitle: payload.providerControl.previousSessionTitle
+                    }),
+                    signal
+                });
+                if (!signal.aborted)
+                    report(observed);
+            }
+        }], error => report({ threadId, status: "not-submitted", detail: String(error) }));
+    return {
+        notify() { if (!triggered) {
+            triggered = true;
+            checks.notify(true);
+        } },
+        close() { checks.close(); }
+    };
+}
+async function saveReceipt(directory, receipt) {
+    const temporary = join(directory, `${receipt.attemptId}-${receipt.status}.tmp`);
+    const file = await open(temporary, "wx", 0o600);
+    try {
+        await file.writeFile(JSON.stringify(receipt) + "\n");
+        await file.sync();
+    }
+    finally {
+        await file.close();
+    }
+    await rename(temporary, join(directory, "receipt.json"));
+    const parent = await open(directory, "r");
+    try {
+        await parent.sync();
+    }
+    finally {
+        await parent.close();
+    }
+}

package/dist/runtime/providerRetry.js

@@ -164,16 +164,16 @@ export function completeProviderRetry(binding, turn) {
 export function providerRetryAttemptId(retry) {
     return `provider-retry:${retry.chainId}/${retry.transportSequence + 1}`;
 }
-export function providerRetryPrompt(retry, original) {
+/** Recovery guidance only. User input is delivered separately, once. */
+export function providerRetryContext(retry) {
     if (retry.failedNativeTurnId === undefined)
-        return original;
+        return undefined;
     return [
         "Yui infrastructure recovery, not new user authorization.",
         `Continue the existing input after failed attempt ${retry.failureAttemptId}`,
         `(native Turn ${retry.failedNativeTurnId}; failure ${retry.failureRef}).`,
         "Read current authorized context and the original input. Inspect existing work and receipts first;",
-        "continue only unfinished work. Preserve local changes and do not repeat confirmed side effects.",
-        original
+        "continue only unfinished work. Preserve local changes and do not repeat confirmed side effects."
     ].join("\n");
 }
 /** The same presentation is consumed by explicit detail reads and Web. */
@@ -211,7 +211,7 @@ export function providerRetryProjection(binding) {
 }
 /** Entry-point facts, never accumulated retry history or raw diagnostics.
  * Exact Session retry/show and failureRef retain the original evidence. */
-export function providerRetrySummary(binding) {
+export function providerRetrySummary(binding, detailCommand) {
     const view = providerRetryProjection(binding);
     if (view === null)
         return null;
@@ -224,7 +224,10 @@ export function providerRetrySummary(binding) {
         currentTurn: currentTurn === null ? null : {
             attemptId: currentTurn.attemptId, status: currentTurn.status, nativeTurnId: currentTurn.nativeTurnId
         },
-        historyCount: history.length, detailOmitted: true
+        historyCount: history.length, detailOmitted: true,
+        // This reads current Session evidence, not a frozen Run snapshot. The
+        // returned chain/attempt identities must still be compared by the caller.
+        ...(detailCommand === undefined ? {} : { currentDetailCommand: detailCommand })
     };
 }
 export function controlProviderRetry(binding, action, at) {

package/dist/runtime/providerRuntimeIdentity.js

@@ -462,7 +462,7 @@ function orderedRunTimestamp(run, value, label) {
     }
     return normalized;
 }
-function providerTurnIsActive(run) {
+export function providerTurnIsActive(run) {
     return run !== null && ["submitting", "accepted", "delivery-unknown"]
         .includes(run.status);
 }

package/dist/runtime/structuredProviderHost.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { createNativeTitleSync } from "./nativeTitleSync.js";
 import { Duplex } from "node:stream";
 import { nativeExecutable } from "./nativeExecutable.js";
 import { startMissingCodexSharedDaemon } from "./codexSharedDaemon.js";
@@ -15,6 +16,7 @@ import { JsonLineChannel, PROVIDER_MESSAGE_MAX_BYTES, terminateProcessGroup } fr
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { foldPublicReply } from "./publicReply.js";
 import { createCodexNativeAccess } from "./codexNativeAccess.js";
+import { isNativeContextRecovery } from "./contextRecovery.js";
 const CODEX_PROXY_HANDSHAKE_TIMEOUT_MS = 10_000;
 /**
  * These Session implementations do not expose run-configuration observations.
@@ -31,7 +33,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control.adapterId === "codex" && control.transport === "codex-app-server-proxy") {
         const proxy = await connectCodexProxy(payload, mirror, true);
         try {
-            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, input.onDiagnostic, mirror);
+            const opened = await CodexStructuredProviderSession.open(proxy.child, proxy.exit, proxy.processInstanceId, payload, control, proxy.channel, input.onStarted, input.onTerminal, input.onGoal, input.onInput, input.onActivity, mirror);
             return Object.freeze({
                 session: opened.session,
                 ...(opened.recoveredTerminal === undefined
@@ -238,7 +240,10 @@ class CodexProxyWebSocketChannel {
                 this.#pending.delete(id);
                 reject(new Error(`Provider request timed out: ${method}.`));
             }, PROVIDER_ACCEPT_TIMEOUT_MS);
-            this.#pending.set(id, { resolve: resolvePromise, reject, timer });
+            this.#pending.set(id, {
+                resolve: resolvePromise, reject, timer, method,
+                requestBytes: Buffer.byteLength(JSON.stringify({ id, method, params }), "utf8")
+            });
         });
         try {
             await this.send({ id, method, params });
@@ -282,7 +287,7 @@ class CodexProxyWebSocketChannel {
         if (isBinary || encoded.byteLength > PROVIDER_MESSAGE_MAX_BYTES) {
             this.#close(new Error(isBinary
                 ? "Provider returned an unsupported binary WebSocket message."
-                : "Provider response message exceeds its bound."));
+                : `Provider response message exceeds its bound (receivedBytes=${encoded.byteLength}).`));
             terminateProcessGroup(this.child, "SIGTERM");
             return;
         }
@@ -320,6 +325,15 @@ class CodexProxyWebSocketChannel {
     #close(error) {
         if (this.#closedError !== undefined)
             return;
+        // A rejected WebSocket frame has not reached #receive: its full size and
+        // response/notification identity are unknown. Record pending request
+        // metadata, not parameters or transcript bytes, and never blame a specific
+        // response just because that request was in flight.
+        const pendingMetadata = [...this.#pending].slice(0, 8).map(([id, pending]) => ({
+            id, method: pending.method, requestBytes: pending.requestBytes
+        }));
+        error = new Error(`Codex proxy transport closed: ${error.message}; messageLimitBytes=${PROVIDER_MESSAGE_MAX_BYTES}; `
+            + `pendingRequests=${JSON.stringify(pendingMetadata)}; pendingCount=${this.#pending.size}.`, { cause: error });
         this.#closedError = error;
         if (!this.#ready)
             this.#rejectReady(error);
@@ -384,7 +398,22 @@ class CodexStructuredProviderSession {
     onActivity;
     mirror;
     nativeAccountHome;
+    contextEpoch = 0;
+    async checkQuiescent() {
+        const snapshot = await this.runtime.readConversation(this.conversationId, { includeTurns: false });
+        if (snapshot.threadId !== this.conversationId || snapshot.status !== "idle"
+            || snapshot.activeTurnId !== undefined)
+            return false;
+        const backgrounds = await this.nativeAccess.read("thread/backgroundTerminals/list", {
+            threadId: this.conversationId, limit: 1
+        });
+        if (!Array.isArray(backgrounds.data) || !("nextCursor" in backgrounds)) {
+            throw new Error("Native background execution response is invalid.");
+        }
+        return backgrounds.data.length === 0 && backgrounds.nextCursor === null;
+    }
     appliedGeneratedTitle;
+    #titleSync;
     nativeAccess;
     #turnAttempts = new Map();
     adapterId = "codex";
@@ -410,7 +439,7 @@ class CodexStructuredProviderSession {
         this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
-    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, onDiagnostic, mirror) {
+    static async open(child, exit, processInstanceId, payload, control, channel, onStarted, onTerminal, onGoal, onInput, onActivity, mirror) {
         const openingMessages = [];
         const stopOpeningBuffer = channel.onMessage((message) => openingMessages.push(message));
         const initialized = await channel.request("initialize", codexClientInitialization());
@@ -419,7 +448,6 @@ class CodexStructuredProviderSession {
         let conversationId;
         let nativeConfiguration;
         let resumedActiveTurnId;
-        let resumedTurns = [];
         if (control.mode === "new") {
             const opened = await runtime.openConversation({
                 cwd: payload.cwd,
@@ -437,7 +465,6 @@ class CodexStructuredProviderSession {
                 conversationId = resumed.threadId;
                 nativeConfiguration = resumed.raw;
                 resumedActiveTurnId = resumed.activeTurnId;
-                resumedTurns = resumed.turns;
             }
             catch (error) {
                 if (codexAppServerErrorIsMissing(error)) {
@@ -446,37 +473,15 @@ class CodexStructuredProviderSession {
                 throw error;
             }
         }
-        const threadMetadata = nativeConfiguration.thread;
-        const nativeTitle = typeof threadMetadata === "object" && threadMetadata !== null
-            && !Array.isArray(threadMetadata) ? threadMetadata.name : undefined;
-        // A native rename belongs to the user. Missing metadata is not evidence
-        // that an old title is still ours; leave it alone on resume.
-        let appliedGeneratedTitle;
-        if (control.sessionTitle !== undefined && (control.mode === "new"
-            || (control.previousSessionTitle !== undefined && nativeTitle === control.previousSessionTitle))) {
-            try {
-                await runtime.setConversationName({
-                    conversationId,
-                    name: control.sessionTitle
-                });
-                appliedGeneratedTitle = control.sessionTitle;
-            }
-            catch (error) {
-                onDiagnostic?.({
-                    nativeSessionId: conversationId,
-                    failure: providerDeliveryFailureFrom(error, {
-                        phase: "session-start",
-                        inputDisposition: "not-accepted",
-                        sessionDisposition: "recoverable"
-                    })
-                });
-            }
-        }
+        const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
+        // Keep notifications buffered during paginated recovery. Otherwise a live
+        // terminal can be emitted before open returns and then returned again as a
+        // synthetic recovered terminal, or a newer start can be overwritten.
+        const recoveredOwnedTurn = ownedTurn !== undefined && resumedActiveTurnId !== ownedTurn.turnId
+            ? await runtime.readTurn(conversationId, ownedTurn.turnId) : undefined;
         const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, optionalId(initialized.codexHome));
         session.nativeAccess = createCodexNativeAccess(conversationId, initialized, channel, openingMessages, nativeConfiguration);
-        session.appliedGeneratedTitle = appliedGeneratedTitle;
         session.#activeTurnId = resumedActiveTurnId;
-        const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
         session.#clientOwnedAttemptId = ownedTurn?.attemptId;
         if (ownedTurn !== undefined)
@@ -493,7 +498,7 @@ class CodexStructuredProviderSession {
         });
         if (ownedTurn !== undefined && recoveredTerminal === undefined
             && session.#activeTurnId !== ownedTurn.turnId) {
-            const recovered = resumedTurns.find((turn) => turn.turnId === ownedTurn.turnId);
+            const recovered = recoveredOwnedTurn;
             if (recovered?.status === "completed"
                 || recovered?.status === "interrupted"
                 || recovered?.status === "failed") {
@@ -523,6 +528,15 @@ class CodexStructuredProviderSession {
             }
         }
         const goal = await runtime.readGoal(conversationId);
+        session.#titleSync = createNativeTitleSync(payload, conversationId, session.nativeAccountHome, result => {
+            if (result.status === "confirmed")
+                session.appliedGeneratedTitle = result.title;
+            mirror("stderr", `Native title: ${JSON.stringify(result)}\n`);
+        });
+        void exit.then(() => session.#titleSync?.close());
+        // Fresh Threads may not be persisted until their first accepted input.
+        if (control.mode === "resume")
+            session.#titleSync.notify();
         return Object.freeze({
             session,
             ...(recoveredTerminal === undefined ? {} : { recoveredTerminal }),
@@ -532,6 +546,8 @@ class CodexStructuredProviderSession {
     #observeMessage(message, emit) {
         const method = typeof message.method === "string" ? message.method : "";
         const params = object(message.params) ?? {};
+        if (isNativeContextRecovery("codex", this.conversationId, message))
+            this.contextEpoch += 1;
         const threadId = optionalId(params.threadId);
         if (emit)
             this.publicReply = foldPublicReply(this.publicReply, this.conversationId, method, params);
@@ -541,6 +557,13 @@ class CodexStructuredProviderSession {
             }
             return undefined;
         }
+        if (method === "thread/name/updated") {
+            this.#titleSync?.close();
+            if (params.threadName !== this.appliedGeneratedTitle)
+                this.appliedGeneratedTitle = undefined;
+        }
+        if (method === "turn/started")
+            this.#titleSync?.notify();
         let goal;
         try {
             goal = codexGoalNotification({ method, params });
@@ -665,6 +688,7 @@ class CodexStructuredProviderSession {
                 conversationId: this.conversationId,
                 attemptId: turn.attemptId,
                 text: turn.boundedText,
+                ...(turn.additionalContext === undefined ? {} : { additionalContext: turn.additionalContext }),
                 expectedNoActiveTurn: true,
                 ...(turn.requireQuiescent ? { requireQuiescent: true } : {}),
                 ...(turn.expectedFailedNativeTurnId === undefined ? {} : {
@@ -684,6 +708,7 @@ class CodexStructuredProviderSession {
             this.#clientOwnedTurnId = acceptance.turnId;
             this.#clientOwnedAttemptId = turn.attemptId;
             this.#turnAttempts.set(acceptance.turnId, turn.attemptId);
+            this.#titleSync?.notify();
             return Object.freeze({
                 attemptId: turn.attemptId,
                 conversationId: this.conversationId,
@@ -714,6 +739,7 @@ class CodexStructuredProviderSession {
             conversationId: this.conversationId,
             expectedTurnId: nativeTurnId,
             text: turn.boundedText,
+            ...(turn.additionalContext === undefined ? {} : { additionalContext: turn.additionalContext }),
             clientUserMessageId: turn.attemptId
         });
         if (acceptance.status === "unknown") {
@@ -778,6 +804,7 @@ class CodexStructuredProviderSession {
         return result === "interrupted" ? "requested" : result;
     }
     terminate(signal) {
+        this.#titleSync?.close();
         terminateProcessGroup(this.child, signal);
     }
 }
@@ -789,6 +816,7 @@ class ClaudeStructuredProviderSession {
     channel;
     onGoal;
     mirror;
+    contextEpoch = 0;
     adapterId = "claude";
     get ownedProcessId() { return this.child.pid; }
     #activeAttemptId;
@@ -905,6 +933,8 @@ class ClaudeStructuredProviderSession {
         terminateProcessGroup(this.child, signal);
     }
     #receive(message, onTerminal, onAccepted, onActivity) {
+        if (isNativeContextRecovery("claude", this.conversationId, message))
+            this.contextEpoch += 1;
         const goal = claudeActiveGoal(message, this.conversationId);
         if (goal !== undefined) {
             const key = JSON.stringify(goal === null ? null : {

package/dist/scheduler/wakeupQueue.js

@@ -1,9 +1,15 @@
-import { mergePendingWakeup } from "./pendingWakeup.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
 /** The caller's TaskStore transaction owns this read/merge/write operation. */
 export function queueLeaderWakeup(store, taskId, reason, now) {
     if (store.getTask(taskId)?.status === "archived")
         return null;
-    const pending = mergePendingWakeup(taskId, reason, now, store.getPendingWakeup(taskId));
-    store.savePendingWakeup(pending);
-    return pending;
+    // The scheduler's pending-wakeup projection may expose an already-owned
+    // processing prefix. Append to the actual suffix, never write that read
+    // projection back over independent inputs.
+    const pending = enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, reason, now).pending;
+    return {
+        schemaVersion: 1, taskId, reasons: [...pending.reasons],
+        requestCount: pending.requestCount,
+        firstRequestedAt: pending.firstQueuedAt, lastRequestedAt: pending.lastQueuedAt
+    };
 }

package/dist/storage/sqliteSchema.js

@@ -286,6 +286,35 @@ const MINOR_UPGRADES = Object.freeze([{
         // Optional Role presentation and generated-title provenance. Never infer
         // ownership of historical titles, rewrite frozen profiles, or fill defaults.
         sql: ""
+    }, {
+        fromVersion: "1.25",
+        toVersion: "1.26",
+        name: "codex-workspace-temp-exclusions",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Optional workspace-write permission fields; preserve all existing payloads.
+        sql: ""
+    }, {
+        fromVersion: "1.26",
+        toVersion: "1.27",
+        name: "host-upgrade-lifecycle-signals",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // New versioned signal sources in the existing role-runtime mailbox. No
+        // historical requests are inferred and existing records remain unchanged.
+        sql: ""
+    }, {
+        fromVersion: "1.27",
+        toVersion: "1.28",
+        name: "native-title-effect-receipts",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Additive exact-identity intent/confirmation files under runtime/native-titles.
+        // Never invent native ownership or replay history during migration.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)

package/dist/storage/storageVersions.js

@@ -1,4 +1,4 @@
-export const CURRENT_STORAGE_VERSION = "1.25";
+export const CURRENT_STORAGE_VERSION = "1.28";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/tmux/tmuxManager.js

@@ -62,7 +62,9 @@ export class TmuxManager {
         this.#yuiHome = options.yuiHome ?? process.env.YUI_HOME ?? process.cwd();
         this.#serverName = yuiTmuxServerName(this.#yuiHome);
         this.#onRoleTargetRecorded = options.onRoleTargetRecorded;
-        this.#terminalInput = options.terminalInput ?? process.stdin;
+        // Creating Node's stdin stream can make piped fd 0 nonblocking. Commands
+        // may still need to read that pipe synchronously before any attach.
+        this.#terminalInput = options.terminalInput;
         this.#terminalType = usableInteractiveTerminal(options.terminalType ?? process.env.TERM);
         this.#closeInteractiveInput = options.closeInteractiveInput ?? (() => { });
         this.#readinessTimeoutMs = positiveInteger(options.readinessTimeoutMs, DEFAULT_READINESS_TIMEOUT_MS, "readiness timeout");
@@ -228,7 +230,7 @@ export class TmuxManager {
             }
             if (resolvedAccess === "read-write")
                 options.revalidateWritableAttach?.();
-            handoffTerminal(this.#terminalInput, this.#closeInteractiveInput);
+            handoffTerminal(this.#terminalInput ?? process.stdin, this.#closeInteractiveInput);
             this.run([
                 "attach-session",
                 ...(resolvedAccess === "read-only" ? ["-r"] : []),

package/dist/web/webSettings.js

@@ -276,6 +276,8 @@ const ROLE_FIELDS = {
     model: { set: "--model", clear: "--clear-model" }, effort: { set: "--effort", clear: "--clear-effort" },
     "permission.strategy": { set: "--permission-strategy" }, "permission.sandbox": { set: "--sandbox" },
     "permission.approval": { set: "--approval" }, "permission.mode": { set: "--permission-mode" },
+    "permission.excludeTmpdirEnvVar": { set: "--exclude-tmpdir-env-var", clear: "--clear-exclude-tmpdir-env-var" },
+    "permission.excludeSlashTmp": { set: "--exclude-slash-tmp", clear: "--clear-exclude-slash-tmp" },
     "permission.allowedTools": { set: "--allowed-tool", clear: "--clear-allowed-tools", many: true },
     "permission.disallowedTools": { set: "--disallowed-tool", clear: "--clear-disallowed-tools", many: true },
     search: { set: "--search", clear: "--clear-search" },

package/docs/authorization.md

@@ -20,9 +20,24 @@ authorization for any external effect.
 | May it access an additional resource or irreversible effect? | `CapabilityGrant`, `grant/taskAuthorization.ts`, resource/plugin/release consumers | Task activation does not authorize arbitrary resources |
 
 The full command inventory is generated from the catalog, not maintained as a
-second per-command permissions table: use `yui --json help` and scoped
-`yui --json help task`, or traverse `describeCommandTree(discoveryCommandTree(env))`
-in offline tooling. Complete role hints retain an offline template even without
+second per-command permissions table. `yui --json help` and scoped
+`yui --json help task` return the selected command's full details and all its
+immediate child **summaries**, not a recursively expanded tree. The `discovery`
+field labels this boundary and gives the detail and full-tree commands. Follow
+each child's `path` with `yui --json help <command ...>` for full usage, options,
+values and examples, or use `yui --json help [command ...] --recursive` for the
+complete caller-filtered tree in one call.
+
+This changes the default JSON help shape: consumers that previously traversed
+nested `children` must request `--recursive`; absence of child details in the
+default view is not proof that the child has no options or descendants.
+Focused leaf details are unchanged, with additive discovery metadata.
+Text help still shows immediate children; `--recursive` requires `--json`.
+`config describe --json` and the offline
+`describeCommandTree(discoveryCommandTree(env))` API retain full recursive
+descriptions. Native `yui agent` product help is a separate surface and unchanged.
+
+Complete role hints retain an offline template even without
 a running Home; that is not authentication. Native-ID-only callers are resolved
 from read-only local storage for help/completion; if that read fails the CLI shows
 the restricted `unbound` template. No Controller or provider is started for that