@zq-silk/yui 2.21.0 → 2.22.0

package/dist/executor/agentAdapter.js

@@ -87,7 +87,7 @@ class CodexAdapter extends BaseAdapter {
             throw new Error("Codex permission strategy is required.");
         }
         if (config.permission.strategy === "configured") {
-            exact(config.permission, ["strategy", "sandbox", "approval"], "Codex permission config");
+            exact(config.permission, ["strategy", "sandbox", "approval", "excludeTmpdirEnvVar", "excludeSlashTmp"], "Codex permission config");
             if (config.permission.sandbox !== undefined
                 && !SANDBOXES.includes(config.permission.sandbox)) {
                 throw new Error("Codex sandbox is invalid.");
@@ -96,6 +96,16 @@ class CodexAdapter extends BaseAdapter {
                 && !APPROVALS.includes(config.permission.approval)) {
                 throw new Error("Codex approval is invalid.");
             }
+            for (const key of ["excludeTmpdirEnvVar", "excludeSlashTmp"]) {
+                const value = config.permission[key];
+                if (value === undefined)
+                    continue;
+                if (typeof value !== "boolean")
+                    throw new Error(`Codex ${key} must be boolean.`);
+                if (config.permission.sandbox !== "workspace-write") {
+                    throw new Error(`Codex ${key} requires an explicit workspace-write sandbox.`);
+                }
+            }
             requireConfiguredPermissionOption(config.permission, "Codex");
         }
         else {
@@ -118,7 +128,8 @@ class CodexAdapter extends BaseAdapter {
                         ...(config.permission.sandbox === undefined
                             ? [] : ["--sandbox", config.permission.sandbox]),
                         ...(config.permission.approval === undefined
-                            ? [] : ["--ask-for-approval", config.permission.approval])
+                            ? [] : ["--ask-for-approval", config.permission.approval]),
+                        ...Object.entries(codexWorkspaceWriteOptions(config)).flatMap(([key, value]) => ["--config", `sandbox_workspace_write.${key}=${value}`])
                     ]
                     : []),
             ...(config.search === true ? ["--search"] : []),
@@ -158,7 +169,12 @@ class CodexAdapter extends BaseAdapter {
         // A managed Codex thread is an ordinary user thread. Its Yui guidance is
         // part of the durable Task message, not a developer_instructions override
         // that would shadow the user's native project/developer configuration.
-        const argv = withoutCodexConfigOverride(launch.argv, "developer_instructions");
+        let argv = withoutCodexConfigOverride(launch.argv, "developer_instructions");
+        // Managed exclusions belong to thread/start and thread/resume configuration,
+        // never the shared daemon/proxy startup defaults.
+        for (const key of Object.keys(codexWorkspaceWriteOptions(config))) {
+            argv = withoutCodexConfigOverride(argv, `sandbox_workspace_write.${key}`);
+        }
         if (config.model !== undefined) {
             const modelFlag = argv.findIndex((value, index) => (value === "--model" && argv[index + 1] === config.model));
             if (modelFlag < 0)
@@ -475,7 +491,10 @@ function codexThreadOptions(input, config) {
         // Keep the trust override on this thread instead of mutating global config.
         projects: { [resolve(input.workspace)]: { trust_level: "trusted" } },
         ...(config.effort === undefined ? {} : { model_reasoning_effort: config.effort }),
-        ...(config.search === true ? { web_search: "live" } : {})
+        ...(config.search === true ? { web_search: "live" } : {}),
+        ...(Object.keys(codexWorkspaceWriteOptions(config)).length === 0 ? {} : {
+            sandbox_workspace_write: codexWorkspaceWriteOptions(config)
+        })
     };
     const permission = config.permission.strategy === "bypass"
         ? { approvalPolicy: "never", sandbox: "danger-full-access" }
@@ -496,6 +515,15 @@ function codexThreadOptions(input, config) {
         ...(Object.keys(threadConfig).length === 0 ? {} : { config: threadConfig })
     };
 }
+function codexWorkspaceWriteOptions(config) {
+    if (config.permission.strategy !== "configured")
+        return {};
+    const { excludeTmpdirEnvVar, excludeSlashTmp } = config.permission;
+    return {
+        ...(excludeTmpdirEnvVar === undefined ? {} : { exclude_tmpdir_env_var: excludeTmpdirEnvVar }),
+        ...(excludeSlashTmp === undefined ? {} : { exclude_slash_tmp: excludeSlashTmp })
+    };
+}
 function codexSessionInstructions(input) {
     if (input.sessionManifestPath !== undefined) {
         return sessionContextInstructions(input.sessionManifestPath, input.sessionManifestDigest);

package/dist/executor/agentConfigurationFields.js

@@ -15,6 +15,8 @@ export function staticAgentConfigurationFields(id) {
             ...fields,
             staticField("permission.sandbox", CODEX_SANDBOXES, false),
             staticField("permission.approval", CODEX_APPROVALS, false, "Native versions may retire values accepted by the adapter."),
+            staticField("permission.excludeTmpdirEnvVar", ["true", "false"], false, "Requires explicit workspace-write; omission follows the native default."),
+            staticField("permission.excludeSlashTmp", ["true", "false"], false, "Requires explicit workspace-write; omission follows the native default."),
             staticField("search", ["true"], false),
             staticField("profile", [], true),
             staticField("additionalDirectories", [], true)

package/dist/integration/gitIntegrationService.js

@@ -79,7 +79,7 @@ export class GitIntegrationService {
     #targetCheckout(attempt) {
         return taskIntegrationTargetCheckout(this.store, this.environment, attempt.taskId, attempt.projectId, attempt.targetRef);
     }
-    async integrate(taskId, integrationId, signal) {
+    async integrate(taskId, integrationId, signal, intent) {
         let initial = requireIntegration(this.store, taskId, integrationId);
         this.#targetCheckout(initial);
         if (!["running", "conflicted", "blocked", "validating"].includes(initial.status)) {
@@ -185,7 +185,8 @@ export class GitIntegrationService {
             try {
                 current = await applyIntegrationSource({
                     attempt: current, workspace, remoteUrl: project.remoteUrl,
-                    git: this.git, store: this.store, now: this.now
+                    git: this.git, store: this.store, now: this.now,
+                    continueOwnedOperation: intent === "continue"
                 });
                 if (current.status === "conflicted" || current.status === "blocked") {
                     return { status: current.status, attempt: current, workspace };

package/dist/integration/integrationSourceApplication.js

@@ -135,7 +135,18 @@ export async function applyIntegrationSource(input) {
                 return pause(unresolved, kind);
             }
             if (!fresh && current.status !== "conflicted") {
-                throw new Error("Git operation is present but no paused conflict is recorded; inspect its execution before continuing.");
+                if (input.continueOwnedOperation !== true) {
+                    throw new Error("Git operation is present but no paused conflict is recorded; inspect its execution before continuing.");
+                }
+                // Git can have stopped before the transaction recording its conflict
+                // failed. Existing progress and assertOperation above bind this exact
+                // operation; explicit intent may continue only a staged resolution.
+                // Do not manufacture a conflict record or restart the source command.
+                if (!await succeeds(path, ["diff", "--quiet"])
+                    || await succeeds(path, ["diff", "--cached", "--quiet"])
+                    || (await command(path, ["ls-files", "--others", "--exclude-standard"])).trim() !== "") {
+                    throw new Error("Owned Git recovery requires a fully staged resolution with no unstaged or untracked files.");
+                }
             }
             try {
                 if (operation !== undefined) {

package/dist/interaction/notificationPresentation.js

@@ -63,32 +63,27 @@ export function taskNotificationPresentation(wake, store) {
         `Changes: ${labels.slice(0, 4).join("; ")}${labels.length > 4 ? "; more in wake" : ""}.`,
         ...messages.slice(0, 4).map(message => {
             const item = taskMessagePresentation(message, (task, run) => store.getRun(task, run));
-            return `- ${message.id} [${message.author.type}${message.author.type === "role" ? `:${message.author.roleName}` : ""}]: ${item.fact}.`
-                + (item.summary === undefined ? "" : ` Author summary (${item.summarySource}): ${JSON.stringify(item.summary)}`);
+            // Keep failure/disposition facts here. Authored summaries remain in the
+            // mandatory wake/original reads, not a second copy in every delivery.
+            return `- ${message.id} [${message.author.type}${message.author.type === "role" ? `:${message.author.roleName}` : ""}]: ${item.fact}.`;
         }),
         ...(messages.length > 4 ? [`${messages.length - 4} more messages in the fixed wake.`] : []),
         `Refresh: yui task context ${wake.taskId} --json`,
-        `Read inputs/results: yui task wake show ${wake.taskId} ${wake.id} --json`,
-        `Handling: claim exact inbox entry ${wake.id}; after disposition, ack it with a concrete reason before ending this turn.`,
-        "Use yui inbox list --view current --json for current inputs. Historical missing receipts are not new work; never replay effects to repair an ACK.",
+        // Match Runtime's receiving-entry -> claim -> originals order. The claim
+        // returns the exact focused read; do not suggest reading it once beforehand.
+        `Read receiving entry: yui inbox show ${wake.id} --json`,
+        `Inbox: ${wake.id}; follow Runtime claim → original → disposition → ACK.`,
         ...(wake.reasons.includes("session-replaced") ? [
-            "Session replacement is initialization, not replay or completion of earlier input.",
-            "Read yui inbox list --view history --json; inspect retained originals, prior effects and current authority before explicit settlement.",
-            "Preserve original claims and delivery targets. Unknown external effects require evidence, not another execution."
-        ] : []),
-        "Check current Skills each turn: yui session skills --json. Apply current yui-leader; read relevant originals in full and advance authorized work."
+            "Session replaced: yui inbox list --view history --json; follow Runtime inbox recovery before settling retained claims. Do not replay unknown effects."
+        ] : [])
     ].join("\n");
 }
 export function globalMessagePresentation(roleName, messageId, message) {
-    const summary = authoredNotificationSummary(message?.body);
     return [
         `Yui Global Message: role=${roleName} message=${messageId}.`,
         `Changes: ${message?.author.type ?? "Recorded"} input received.`,
-        ...(summary === undefined ? [] : [`Author summary (message-body): ${JSON.stringify(summary)}`]),
         "Refresh Session Context using the current Manifest's loadCommand.",
-        `Read original: yui role message show ${roleName} ${messageId} --json`,
-        `Handling: claim exact inbox entry ${messageId}; after disposition, ack it with a concrete reason before ending this turn.`,
-        "Routing to a Task or asking a necessary user question can settle this input without completing the Task. Missing ACK is not permission to repeat effects.",
-        `The Global loadCommand checks current Skill versions each turn. Apply current ${roleName === "operator" ? "yui-operator" : "yui-runtime"} within existing authority.`
+        `Original: reuse the complete matching currentOriginals record from Context; if absent, yui inbox show ${messageId} --json.`,
+        `Inbox: ${messageId}; follow Runtime claim → original → disposition → ACK.`
     ].join("\n");
 }

package/dist/interaction/operatorPresentation.js

@@ -10,7 +10,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         receiptId: `operator-batch:${batchId}`,
         text: [
             "[Yui updates]",
-            "Check current Skills each turn via the Global Manifest's loadCommand. Apply current yui-operator; inspect these originals and present material changes or decisions.",
+            "Apply current yui-operator and refresh Global Context; inspect these originals and present material changes or decisions.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/message/messageContinuation.js

@@ -12,6 +12,7 @@ import { sourceRunContextValue } from "../context/sourceRunContext.js";
 import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { recoveredMessageContinuation } from "../controller/taskRunRecovery.js";
 export function resolveMessageRecipient(store, taskId, roleName, scope) {
     if (scope.reviewRoundId !== undefined) {
         const round = store.getReviewRound(taskId, scope.reviewRoundId);
@@ -80,7 +81,8 @@ export function messageAssignmentBlocker(store, message) {
     const latest = store.listRuns(message.taskId).filter((run) => run.workItemId === owner.workItemId && run.reviewRoundId === owner.reviewRoundId
         && run.roleName === owner.roleName).at(-1);
     if (latest !== undefined && latest.id !== owner.id
-        && latest.inputs[0]?.input.source.channel !== "message-continuation")
+        && latest.inputs[0]?.input.source.channel !== "message-continuation"
+        && !recoveredMessageContinuation(store, message, latest))
         return "assignment-changed";
     if (target.reviewRoundId !== undefined) {
         const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });

package/dist/output/boundedRead.js

@@ -35,10 +35,17 @@ export function readDigest(value) {
 }
 /** A save receipt is not another read of the submitted body. Keep the exact
  * delivery/control facts and identity; body/history are read on demand.
+ * bodySha256 hashes the saved string's UTF-8 bytes, not its JSON encoding or
+ * record metadata. It permits transport comparison, not semantic read credit.
  */
 export function messageReceipt(message) {
     const { body: _body, ...facts } = message;
-    return { ...facts, digest: readDigest(message), bodyBytes: Buffer.byteLength(message.body) };
+    return {
+        ...facts,
+        digest: readDigest(message),
+        bodyBytes: Buffer.byteLength(message.body, "utf8"),
+        bodySha256: createHash("sha256").update(message.body, "utf8").digest("hex")
+    };
 }
 export function encodeReadCursor(cursor) {
     return Buffer.from(JSON.stringify(cursor)).toString("base64url");
@@ -117,15 +124,37 @@ export function boundedDocument(value, source, cursor) {
     const offset = cursor === undefined ? 0 : decodeReadCursor(cursor, source, digest);
     if (offset >= text.length && offset !== 0)
         throw usageError("Read cursor exceeds this document.");
-    let end = Math.min(offset + 4096, text.length);
-    // Never cut between UTF-16 surrogate halves.
-    if (end < text.length && /[\uD800-\uDBFF]/u.test(text[end - 1]))
-        end--;
-    return { contentPage: {
+    const boundary = (end) => end < text.length && /[\uD800-\uDBFF]/u.test(text[end - 1])
+        ? end - 1 : end;
+    const page = (end) => ({ contentPage: {
             source, digest, encoding: "json", offset, totalCharacters: text.length,
             totalBytes, text: text.slice(offset, end), complete: end === text.length,
             nextCursor: end < text.length ? encodeReadCursor({ source, digest, offset: end }) : null
-        } };
+        } });
+    // A code unit costs at least one encoded byte. Bound each trial independently
+    // of document size, and budget the entire response including escaped identity.
+    const upper = boundary(Math.min(offset + READ_PAGE_BYTES, text.length));
+    const largest = page(upper);
+    if (fitsReadBudget(largest))
+        return largest;
+    // The terminal page drops its cursor: test it above, separately from the
+    // monotone non-terminal search. Raw indices advance even at surrogate pairs.
+    let low = offset + 1;
+    let high = upper - 1;
+    let end = offset;
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const candidate = boundary(middle);
+        if (fitsReadBudget(page(candidate))) {
+            end = candidate;
+            low = middle + 1;
+        }
+        else
+            high = middle - 1;
+    }
+    if (end === offset)
+        throw usageError("Read identity and text exceed the response budget.");
+    return page(end);
 }
 /** Shared parser for list/detail command tails; no options reach mutations. */
 export function readOptions(args, flags = ["--cursor", "--limit"]) {

package/dist/output/rolePresentation.js

@@ -122,7 +122,9 @@ function permission(binding) {
             return "bypass";
         return [
             permission.sandbox === undefined ? undefined : `sandbox=${permission.sandbox}`,
-            permission.approval === undefined ? undefined : `approval=${permission.approval}`
+            permission.approval === undefined ? undefined : `approval=${permission.approval}`,
+            permission.excludeTmpdirEnvVar === undefined ? undefined : `excludeTmpdirEnvVar=${permission.excludeTmpdirEnvVar}`,
+            permission.excludeSlashTmp === undefined ? undefined : `excludeSlashTmp=${permission.excludeSlashTmp}`
         ].filter((value) => value !== undefined).join("; ");
     }
     // ACP's strategy decides the Session mode Yui requests over the protocol. It

package/dist/runtime/agentHost.js

@@ -4,7 +4,7 @@ import { createConnection, createServer } from "node:net";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import { withSessionContextPointer } from "../context/sessionBootstrapManifest.js";
+import { createSessionSkillNotice } from "../context/sessionSkillNotice.js";
 import { publishStructuredConversationRecoverability, publishStructuredProviderAccepted, publishStructuredProviderActivity, publishStructuredProviderAttachmentExit, publishStructuredProviderConnection, publishStructuredProviderDiagnostic, publishStructuredProviderGoal, publishStructuredProviderInputObserved, publishStructuredProviderInputSettlement, publishStructuredProviderOpened, publishStructuredProviderStarted, publishStructuredProviderTerminal, replayStructuredProviderPersistence, structuredProviderEventDelivery } from "../controller/structuredProviderObservation.js";
 import { callController, controllerCallMayHaveApplied, ControllerClientError } from "../core/controllerClient.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
@@ -82,6 +82,7 @@ export async function runAgentHost(input) {
         return runCodexInteractiveHost(input.home, payload, openAgentHostControl);
     }
     let session;
+    const skillNotice = createSessionSkillNotice(input.home);
     // This process really holds the Endpoint code its Session runs on. The lease
     // spans the Session's Turns, so installing a newer generation does not change
     // the implementation under a Session that is still using this one.
@@ -405,6 +406,7 @@ export async function runAgentHost(input) {
                     throw new Error("Codex client reconnect lost its Endpoint implementation lease.");
                 }
                 const started = await endpointLease.resume(reconnectPayload);
+                skillNotice.invalidate();
                 session = started.session;
                 sessionPayload = currentPayload;
                 started.session.events((event) => {
@@ -660,6 +662,7 @@ export async function runAgentHost(input) {
                 session = started.session;
                 sessionPayload = next;
                 await recordProviderConnection(input.home, next, started.session);
+                skillNotice.invalidate();
                 lastTerminalPayload = undefined;
                 lastTerminal = undefined;
                 directObservation = undefined;
@@ -909,9 +912,10 @@ export async function runAgentHost(input) {
         try {
             // beginDurableProviderTurn validated current execution-environment,
             // authority and Session identity before this native write.
+            const notice = skillNotice.prepare(recoveryInput?.text ?? request.run.boundedText, activeRunPayload.environment, session.nativeSessionId, { recovery: recoveryInput !== undefined });
             const receipt = endpointReceipt(await session.submit({
                 ...request.run,
-                boundedText: withSessionContextPointer(recoveryInput?.text ?? request.run.boundedText, activeRunPayload.environment),
+                boundedText: notice.text,
                 ...(recoveryInput === undefined ? {} : { requireQuiescent: true }),
                 ...(recoveryInput?.expectedFailedNativeTurnId === undefined ? {} : {
                     expectedFailedNativeTurnId: recoveryInput.expectedFailedNativeTurnId
@@ -920,6 +924,8 @@ export async function runAgentHost(input) {
             }), request.run.attemptId);
             transportAccepted = true;
             providerAccepted = receipt.acceptance === "provider";
+            if (providerAccepted)
+                notice.commit();
             activeNativeTurnId = receipt.nativeTurnId;
             try {
                 await publishStructuredProviderAccepted({
@@ -1029,14 +1035,17 @@ export async function runAgentHost(input) {
         }
         try {
             await assertHostExecutionEnvironment(input.home, sessionPayload, session.nativeSessionId);
+            const notice = skillNotice.prepare(request.run.boundedText, sessionPayload.environment, session.nativeSessionId);
             const receipt = endpointReceipt(await session.steer({
                 ...request.run,
-                boundedText: withSessionContextPointer(request.run.boundedText, sessionPayload.environment),
+                boundedText: notice.text,
                 inputRef: request.run.attemptId
             }), request.run.attemptId);
             if (receipt.nativeTurnId !== request.nativeTurnId) {
                 throw new ProviderDeliveryUnknownError("Provider accepted steer against an unexpected native Turn.", request.run.attemptId);
             }
+            if (receipt.acceptance === "provider")
+                notice.commit();
         }
         catch (error) {
             const unknown = error instanceof ProviderDeliveryUnknownError;

package/dist/runtime/codexAppServerRuntime.js

@@ -49,9 +49,10 @@ export class CodexAppServerRuntime {
         const result = await this.transport.request("thread/resume", {
             threadId: id,
             ...(options.cwd === undefined ? {} : { cwd: text(options.cwd, "Codex thread cwd") }),
-            ...threadOptions(options)
+            ...threadOptions(options),
+            excludeTurns: true
         });
-        return parseThreadSnapshot(result, id, true);
+        return this.withLatestTurn(parseThreadSnapshot(result, id, true));
     }
     async setConversationName(input) {
         await this.transport.request("thread/name/set", {
@@ -63,9 +64,81 @@ export class CodexAppServerRuntime {
         const id = text(conversationId, "Codex thread id");
         const result = await this.transport.request("thread/read", {
             threadId: id,
-            includeTurns: options.includeTurns ?? true
+            includeTurns: false
         });
-        return parseThreadSnapshot(result, id, "unknown");
+        const snapshot = parseThreadSnapshot(result, id, "unknown");
+        return options.includeTurns === false ? snapshot : this.withLatestTurn(snapshot);
+    }
+    /** Current execution metadata, never an unbounded transcript hydration. */
+    async withLatestTurn(snapshot) {
+        const page = await this.transport.request("thread/turns/list", {
+            threadId: snapshot.threadId, limit: 1, sortDirection: "desc", itemsView: "notLoaded"
+        });
+        const records = codexPage(page, new Set()).data;
+        if (records.length > 1)
+            throw new Error("Codex latest Turn page exceeded its requested bound.");
+        const turns = records.map(parseTurnSnapshot);
+        const latest = turns[0];
+        return {
+            ...snapshot,
+            // The metadata response may contain no Turns. Do not carry an old active
+            // identity over a separately observed latest Turn.
+            activeTurnId: latest?.status === "inProgress" ? latest.turnId : undefined,
+            latestTurnStatus: latest?.status,
+            turns
+        };
+    }
+    /** Recover only the persisted owned Turn. Scan metadata, then its items,
+     * newest first, stopping at the last nonempty assistant message. A malformed
+     * page or oversized individual item remains an error, never guessed success. */
+    async readTurn(conversationId, turnId) {
+        const threadId = text(conversationId, "Codex thread id");
+        const expectedTurnId = text(turnId, "Codex owned Turn id");
+        const seen = new Set();
+        let cursor;
+        for (;;) {
+            const page = codexPage(await this.transport.request("thread/turns/list", {
+                threadId, limit: 50, sortDirection: "desc", itemsView: "notLoaded",
+                ...(cursor === undefined ? {} : { cursor })
+            }), seen);
+            if (page.data.length > 50)
+                throw new Error("Codex Turn page exceeded its requested bound.");
+            const found = page.data.map(parseTurnSnapshot).find(turn => turn.turnId === expectedTurnId);
+            if (found !== undefined) {
+                if (found.status === "inProgress")
+                    return found;
+                const output = await this.readTurnOutput(threadId, expectedTurnId);
+                return { ...found, ...(output === undefined ? {} : { output }) };
+            }
+            if (page.nextCursor === null)
+                return undefined;
+            cursor = page.nextCursor;
+        }
+    }
+    async readTurnOutput(threadId, turnId) {
+        const seen = new Set();
+        let cursor;
+        for (;;) {
+            const page = codexPage(await this.transport.request("thread/items/list", {
+                threadId, turnId, limit: 1, sortDirection: "desc",
+                ...(cursor === undefined ? {} : { cursor })
+            }), seen);
+            if (page.data.length > 1)
+                throw new Error("Codex item page exceeded its requested bound.");
+            for (const value of page.data) {
+                const entry = object(value);
+                const item = object(entry?.item);
+                if (entry?.turnId !== turnId || item === null) {
+                    throw new Error("Codex item page does not belong to the owned Turn.");
+                }
+                if (item.type === "agentMessage" && typeof item.text === "string" && item.text.trim().length > 0) {
+                    return item.text;
+                }
+            }
+            if (page.nextCursor === null)
+                return undefined;
+            cursor = page.nextCursor;
+        }
     }
     async readGoal(conversationId) {
         const id = text(conversationId, "Codex thread id");
@@ -330,26 +403,7 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         throw new Error("Codex thread status is missing or unsupported.");
     if (!Array.isArray(thread.turns))
         throw new Error("Codex thread turns are missing or invalid.");
-    const turnSnapshots = thread.turns.map((value) => {
-        const turn = object(value);
-        if (turn === null)
-            throw new Error("Codex thread contains an invalid Turn.");
-        const turnId = text(optionalId(turn.id), "Codex response Turn id");
-        const status = optionalTurnStatus(turn.status);
-        if (status === undefined)
-            throw new Error("Codex Turn status is missing or unsupported.");
-        const output = codexTurnOutput(turn);
-        const error = providerError(turn.error);
-        return {
-            turnId,
-            status,
-            ...(output === undefined ? {} : { output }),
-            ...(error === undefined ? {} : { error }),
-            ...(turn.error === undefined || turn.error === null ? {} : {
-                rawError: serializeAgentErrorRaw(turn.error)
-            })
-        };
-    });
+    const turnSnapshots = thread.turns.map(parseTurnSnapshot);
     const active = [...turnSnapshots].reverse().find((turn) => turn.status === "inProgress");
     const latestStatus = turnSnapshots.at(-1)?.status;
     return {
@@ -365,6 +419,38 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         raw: result
     };
 }
+function parseTurnSnapshot(value) {
+    const turn = object(value);
+    if (turn === null)
+        throw new Error("Codex thread contains an invalid Turn.");
+    const turnId = text(optionalId(turn.id), "Codex response Turn id");
+    const status = optionalTurnStatus(turn.status);
+    if (status === undefined)
+        throw new Error("Codex Turn status is missing or unsupported.");
+    const output = codexTurnOutput(turn);
+    const error = providerError(turn.error);
+    return {
+        turnId,
+        status,
+        ...(output === undefined ? {} : { output }),
+        ...(error === undefined ? {} : { error }),
+        ...(turn.error === undefined || turn.error === null ? {} : {
+            rawError: serializeAgentErrorRaw(turn.error)
+        })
+    };
+}
+function codexPage(page, seen) {
+    if (!Array.isArray(page.data)
+        || !(page.nextCursor === null || typeof page.nextCursor === "string" && page.nextCursor.length > 0)) {
+        throw new Error("Codex history page is missing data or its continuation boundary.");
+    }
+    if (typeof page.nextCursor === "string") {
+        if (seen.has(page.nextCursor))
+            throw new Error("Codex history cursor repeated.");
+        seen.add(page.nextCursor);
+    }
+    return { data: page.data, nextCursor: page.nextCursor };
+}
 /** Extract the last assistant message from one native Codex Turn without rewriting it. */
 export function codexTurnOutput(turn) {
     for (const value of [...arrayMember(turn, "items")].reverse()) {

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);
 }