@zq-silk/yui 2.20.0 → 2.22.0

package/dist/runtime/codexInteractiveHost.js

@@ -4,6 +4,7 @@ import { once } from "node:events";
 import WebSocket, { WebSocketServer } from "ws";
 import { AGENT_HOST_CONTROL_PROTOCOL } from "./agentHostProtocol.js";
 import { openCodexInteractiveConnection } from "./structuredProviderHost.js";
+import { createSessionSkillNotice } from "../context/sessionSkillNotice.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
@@ -15,6 +16,8 @@ import { openCodexInteractiveConnection } from "./structuredProviderHost.js";
  */
 export async function runCodexInteractiveHost(home, payload, openAgentHostControl) {
     const environment = payload.environment;
+    const skillNotice = createSessionSkillNotice(home);
+    const pendingNotices = new Map();
     if (environment.YUI_SESSION_SCOPE !== "global" || environment.YUI_ADAPTER_ID !== "codex"
         || payload.providerControl !== undefined) {
         throw new Error("Interactive Codex Host requires a global native TUI launch.");
@@ -106,6 +109,23 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
                         startupRequestId = message.id;
                         message.params = codexInteractiveStartupParameters(payload, params);
                     }
+                    if (message.method === "turn/start" || message.method === "turn/steer") {
+                        if (snapshot.nativeSessionId === undefined)
+                            throw new Error("Skill check requires the reserved native Thread.");
+                        if (typeof message.id !== "string" && typeof message.id !== "number"
+                            || pendingNotices.has(message.id))
+                            throw new Error("Turn input requires a unique correlation id.");
+                        const params = jsonObject(message.params);
+                        if (params.threadId !== snapshot.nativeSessionId)
+                            throw new Error("Turn input targets another Thread.");
+                        const prepared = codexInteractiveSkillInput(skillNotice, environment, snapshot.nativeSessionId, params);
+                        message.params = prepared.params;
+                        pendingNotices.set(message.id, {
+                            commit: prepared.commit,
+                            ...(message.method === "turn/steer" && typeof params.expectedTurnId === "string"
+                                ? { expectedTurnId: params.expectedTurnId } : {})
+                        });
+                    }
                     void connection.send(message).catch(fail);
                 }
                 catch (error) {
@@ -115,6 +135,17 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         });
         connection.onMessage((message) => {
             try {
+                if (message.method === undefined && (typeof message.id === "string" || typeof message.id === "number")) {
+                    const pending = pendingNotices.get(message.id);
+                    if (pending !== undefined) {
+                        pendingNotices.delete(message.id);
+                        const result = message.result;
+                        const turnId = result?.turn?.id ?? result?.turnId;
+                        if (message.error === undefined && typeof turnId === "string" && turnId.length > 0
+                            && (pending.expectedTurnId === undefined || pending.expectedTurnId === turnId))
+                            pending.commit();
+                    }
+                }
                 let nativeSessionId;
                 if (startupRequestId !== undefined && message.id === startupRequestId
                     && message.method === undefined) {
@@ -183,6 +214,21 @@ export async function runCodexInteractiveHost(home, payload, openAgentHostContro
         await control.close();
     }
 }
+/** Preserve all native content parts (including images), adding only Host metadata. */
+export function codexInteractiveSkillInput(notice, environment, nativeSessionId, params) {
+    if (!Array.isArray(params.input))
+        throw new Error("Turn input must be an array.");
+    const prepared = notice.prepare("", environment, nativeSessionId);
+    return {
+        params: {
+            ...params,
+            input: prepared.text.length === 0 ? params.input : [
+                { type: "text", text: prepared.text.trimEnd(), text_elements: [] }, ...params.input
+            ]
+        },
+        commit: prepared.commit
+    };
+}
 /** 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. */

package/dist/runtime/providerRetry.js

@@ -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

@@ -31,7 +31,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 +238,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 +285,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 +323,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);
@@ -410,7 +422,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 +431,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 +448,6 @@ class CodexStructuredProviderSession {
                 conversationId = resumed.threadId;
                 nativeConfiguration = resumed.raw;
                 resumedActiveTurnId = resumed.activeTurnId;
-                resumedTurns = resumed.turns;
             }
             catch (error) {
                 if (codexAppServerErrorIsMissing(error)) {
@@ -446,37 +456,25 @@ 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"
-                    })
-                });
-            }
+        if (control.sessionTitle !== undefined) {
+            // The native title mutation can persist without replying and stall later
+            // Goal/Turn requests, even through a separate metadata connection. Keep
+            // Yui's launch title, but do not put that optional mutation on a managed
+            // Session's execution path. Reconnect must not replay it either.
+            // This is an intentional omission, not a failed delivery or unavailable
+            // observer. Keep it in the Host log without waking an Agent to recover
+            // an operation that was never attempted.
+            mirror("stderr", "Native title synchronization was not submitted; Yui retains its Session title without blocking native Goal/Turn control.\n");
         }
+        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 +491,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") {

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,15 @@ 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: ""
     }]);
 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.26";
 export const MIN_SUPPORTED_STORAGE_VERSION = "1.0";
 export const STORAGE_FORMAT = "yui-home";
 export function isStorageVersion(value) {

package/dist/task/taskAuthority.js

@@ -146,10 +146,14 @@ export function projectActor(environment) {
     }
     return "user";
 }
+/** Read-only Job requests carry the original identity, not the record's owner.
+ * The Controller authenticates it; mutations keep resolveJobCaller's target check. */
+export function resolveJobReadCaller(environment, taskId) {
+    return resolveJobCaller(environment, environment?.YUI_SESSION_SCOPE === "task" ? environment.YUI_TASK_ID ?? "" : taskId);
+}
 /**
- * Resolve the caller's Task, Role and native Session identity. The Controller
- * verifies it against durable state and supplies the current AgentRun. A Task
- * caller cannot control another Task; an incomplete identity is not a user.
+ * Resolve execution identity. The Controller verifies it against durable state;
+ * a Task caller cannot control another Task or infer user authority.
  */
 export function resolveJobCaller(environment, taskId) {
     const env = environment ?? {};

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