@zq-silk/yui 2.21.0 → 2.23.0

package/dist/errors/cliFailure.js

@@ -79,8 +79,17 @@ export function describeCliFailure(error, context = {}) {
                 ? "The Controller returned an error response; it does not prove rollback of earlier effects. " + RECONCILE
                 : RECONCILE;
     const help = error instanceof CliError && error.helpText !== undefined ? clean(error.helpText.trimEnd()) : undefined;
-    const message = [
-        ...chain.map((item, index) => `${index === 0 ? "" : "Caused by: "}${item.code === undefined ? "" : `[${item.code}] `}${item.message}`),
+    const causes = chain.map((item, index) => `${index === 0 ? "" : "Caused by: "}${item.code === undefined ? "" : `[${item.code}] `}${item.message}`);
+    const lines = (parts) => parts.filter((part) => part !== undefined && part.length > 0).join("\n");
+    const jsonMessage = lines([
+        causes[0],
+        effects,
+        guidance,
+        "Use the same Home and CLI in details.diagnostic; its causes retain the full error chain. Recovery commands are not run automatically.",
+        help
+    ]);
+    const message = lines([
+        ...causes,
         diagnostic.operation === undefined ? undefined : `Operation: ${diagnostic.operation}`,
         diagnostic.home === undefined ? undefined : `YUI_HOME: ${diagnostic.home}`,
         diagnostic.cli === undefined ? undefined : `CLI entry: ${diagnostic.cli}`,
@@ -92,9 +101,9 @@ export function describeCliFailure(error, context = {}) {
         guidance,
         "Recovery commands shown as `yui` must use the same Home and matching CLI entry above; they are not run automatically.",
         help
-    ].filter((part) => part !== undefined && part.length > 0).join("\n");
+    ]);
     return {
-        code, exitCode, message,
+        code, exitCode, message, jsonMessage,
         details: {
             ...(error instanceof CliError ? sanitizeFailureDetails(error.details, context) : {}),
             diagnostic
@@ -103,7 +112,7 @@ export function describeCliFailure(error, context = {}) {
 }
 export function renderCliFailure(failure, json, jsonCode = failure.code) {
     return json
-        ? JSON.stringify({ ok: false, code: jsonCode, message: failure.message, details: failure.details })
+        ? JSON.stringify({ ok: false, code: jsonCode, message: failure.jsonMessage, details: failure.details })
         : `${failure.code}: ${failure.message}`;
 }
 function errorCode(error) {

package/dist/execution/codexThreadNaming.js

@@ -2,52 +2,64 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { codexClientInitialization } from "../runtime/codexAppServerRuntime.js";
 const DEFAULT_TIMEOUT_MS = 1_000;
-export async function setCodexThreadName(request) {
-    const timeoutMs = threadNameTimeout(request.timeoutMs);
-    const client = await CodexNamingClient.start(request.command, request.environment, request.baseArgs ?? [], timeoutMs);
-    try {
-        await withTimeout(client.request("thread/name/set", {
-            threadId: requiredText(request.threadId, "Codex thread id"),
-            name: requiredThreadName(request.name)
-        }), timeoutMs, "Timed out setting Codex thread name.");
-    }
-    finally {
-        client.close();
-    }
-}
-class CodexNamingClient {
+export class CodexNamingClient {
     child;
+    accountHome;
+    exited;
     #pending = new Map();
     #stderr = [];
     #nextId = 1;
     #closed = false;
-    constructor(child) {
+    #deadline;
+    constructor(child, timeoutMs) {
         this.child = child;
+        this.exited = new Promise(resolve => child.once("close", () => resolve()));
+        this.#deadline = setTimeout(() => {
+            this.#failAll(new Error("Native title metadata process deadline exceeded; effect may be unknown."));
+            this.close("SIGKILL");
+        }, timeoutMs);
         const output = createInterface({ input: child.stdout });
-        output.on("line", (line) => { this.#receive(line); });
+        output.on("line", (line) => {
+            try {
+                if (Buffer.byteLength(line) > 1_048_576)
+                    throw new Error("Native title reply exceeds its bound.");
+                this.#receive(line);
+            }
+            catch (error) {
+                this.#failAll(error instanceof Error ? error : new Error(String(error)));
+                this.close();
+            }
+        });
+        child.stdout.on("error", error => { this.#failAll(error); this.close(); });
         child.stderr.setEncoding("utf8");
         child.stderr.on("data", (chunk) => {
             this.#stderr.push(chunk);
             if (this.#stderr.join("").length > 16_384)
                 this.#stderr.shift();
         });
-        child.on("error", (error) => { this.#failAll(error); });
+        child.on("error", (error) => { this.#failAll(error); this.close(); });
+        child.stdin.on("error", (error) => { this.#failAll(error); this.close(); });
         child.on("exit", (code, signal) => {
+            clearTimeout(this.#deadline);
             if (this.#closed)
                 return;
+            this.#closed = true;
             const detail = this.#stderr.join("").trim();
             this.#failAll(new Error(`Codex App Server exited (${code ?? signal ?? "unknown"})${detail.length === 0 ? "" : `: ${detail}`}`));
         });
     }
     static async start(command, environment, baseArgs, timeoutMs) {
-        const client = new CodexNamingClient(spawn(command, [...baseArgs, "app-server", "--stdio"], { env: environment, stdio: ["pipe", "pipe", "pipe"] }));
+        const deadlineMs = threadNameTimeout(timeoutMs);
+        const client = new CodexNamingClient(spawn(command, [...baseArgs, "app-server", "--listen", "stdio://"], { env: environment, stdio: ["pipe", "pipe", "pipe"] }), deadlineMs);
         try {
-            await withTimeout(client.request("initialize", codexClientInitialization()), timeoutMs, "Timed out initializing Codex App Server for thread naming.");
+            const initialized = await withTimeout(client.request("initialize", codexClientInitialization()), timeoutMs, "Timed out initializing Codex App Server for thread naming.");
+            client.accountHome = typeof initialized.codexHome === "string" ? initialized.codexHome : undefined;
             client.notify("initialized", {});
             return client;
         }
         catch (error) {
             client.close();
+            await client.exited;
             throw error;
         }
     }
@@ -63,11 +75,19 @@ class CodexNamingClient {
     notify(method, params) {
         this.#write({ method, params });
     }
-    close() {
+    close(signal = "SIGTERM") {
         if (this.#closed)
             return;
         this.#closed = true;
-        this.child.kill("SIGTERM");
+        clearTimeout(this.#deadline);
+        this.child.kill(signal);
+        // An owned metadata process must not survive a lost reply or ignored TERM.
+        const reap = setTimeout(() => {
+            if (this.child.exitCode === null && this.child.signalCode === null)
+                this.child.kill("SIGKILL");
+        }, 250);
+        reap.unref();
+        this.child.once("exit", () => clearTimeout(reap));
         this.#failAll(new Error("Codex App Server closed."));
     }
     #write(value) {
@@ -94,13 +114,20 @@ class CodexNamingClient {
             }
             return;
         }
-        this.#pending.delete(message.id);
-        if (message.error !== undefined) {
-            const error = object(message.error, "Codex App Server error");
-            pending.reject(new Error(typeof error.message === "string" ? error.message : "Codex App Server request failed."));
+        try {
+            if (message.error !== undefined) {
+                const error = object(message.error, "Codex App Server error");
+                pending.reject(new Error(typeof error.message === "string" ? error.message : "Codex App Server request failed."));
+            }
+            else {
+                pending.resolve(object(message.result, "Codex App Server result"));
+            }
+        }
+        catch (error) {
+            pending.reject(error instanceof Error ? error : new Error(String(error)));
         }
-        else {
-            pending.resolve(object(message.result, "Codex App Server result"));
+        finally {
+            this.#pending.delete(message.id);
         }
     }
     #failAll(error) {
@@ -115,22 +142,6 @@ function object(value, label) {
     }
     return value;
 }
-function requiredText(value, label) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new Error(`${label} is invalid.`);
-    }
-    return value;
-}
-function requiredThreadName(value) {
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new Error("Codex thread name is invalid.");
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.length > 1_024) {
-        throw new Error("Codex thread name is invalid.");
-    }
-    return normalized;
-}
 function threadNameTimeout(value) {
     if (value === undefined)
         return DEFAULT_TIMEOUT_MS;

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/executor/fileRoleLaunchPlanner.js

@@ -17,7 +17,7 @@ import { managedRuntimeAdmission } from "../runtime/agentDriver.js";
 import { builtinAgentEndpointImplementation, validateAgentEndpointImplementation } from "../runtime/agentEndpointIdentity.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { assertProviderConversationReplaceable } from "../runtime/providerRuntimeIdentity.js";
-import { globalRoleSessionTitle, resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { globalRoleSessionTitle, taskRoleSessionTitle, resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { planningRuntimeCwd } from "../storage/homeLayout.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
@@ -225,7 +225,11 @@ export class FileRoleLaunchPlanner {
             instanceCode: role.instanceCode,
             generatedTitle: existing?.generatedTitle
         }), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, effective, {
-            purpose
+            purpose,
+            nativeGeneratedTitle: taskRoleSessionTitle(task, role.name, {
+                executionAuthority: (input.mode === "resume" ? existing?.effective : effective)?.executionAuthority,
+                instanceCode: role.instanceCode
+            })
         });
     }
     planGlobalRole(input) {
@@ -258,7 +262,10 @@ export class FileRoleLaunchPlanner {
             : existing?.generatedTitle !== undefined && existing.title === existing.generatedTitle
                 ? globalRoleSessionTitle(role.name, new Date(existing.createdAt), this.store.getConfig().timeZone, role.instanceCode)
                     ?? `Yui ${role.name}`
-                : undefined, input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, effective, { purpose: "execution" });
+                : undefined, input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, effective, { purpose: "execution",
+            nativeGeneratedTitle: globalRoleSessionTitle(role.name, input.mode === "resume" && existing !== undefined ? new Date(existing.createdAt) : this.#now(), this.store.getConfig().timeZone, role.instanceCode)
+                ?? (input.mode === "resume" ? `Yui ${role.name}` : undefined)
+        });
     }
     #compile(role, input, owner, sessionTitle, knownNativeSessionId, effective, sessionPolicy) {
         const launchRole = effectiveRoleForLaunch(role, effective);
@@ -570,6 +577,14 @@ export class FileRoleLaunchPlanner {
                 YUI_DRIVER_ID: driver.id,
                 YUI_WORKSPACE: effectiveWorkspace,
                 YUI_SESSION_MANIFEST: sessionContext.sessionManifestPath,
+                // A proposal only. The independent metadata lane must prove native
+                // ownership; planning never reads/waits on title effects.
+                ...(configured.adapterId !== "codex" || sessionPolicy.nativeGeneratedTitle === undefined ? {} : {
+                    YUI_NATIVE_TITLE_PROPOSAL: sessionPolicy.nativeGeneratedTitle
+                }),
+                ...(configured.adapterId !== "codex" || input.mode !== "resume" || existingSession?.title === undefined ? {} : {
+                    YUI_NATIVE_TITLE_LOCAL: existingSession.title
+                }),
                 ...(configured.adapterId === "codex"
                     ? { YUI_AGENT_BASE_ARGS: JSON.stringify(configured.baseArgs) }
                     : {}),

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/agentEndpoint.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { builtinAgentEndpointImplementation, requireBuiltinAgentEndpointImplementation } from "./agentEndpointIdentity.js";
 import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
 import { CodexPreSubmissionError } from "./codexAppServerRuntime.js";
@@ -80,6 +81,12 @@ function freezeConfiguration(value) {
 class BuiltinAgentEndpoint {
     driver;
     configuration;
+    get contextEpoch() { return this.driver.contextEpoch; }
+    async checkQuiescent() {
+        if (!this.driver.checkQuiescent)
+            throw new Error("This native Endpoint cannot prove background quiescence.");
+        return this.driver.checkQuiescent();
+    }
     get nativeAccess() { return this.driver.nativeAccess; }
     get appliedGeneratedTitle() { return this.driver.appliedGeneratedTitle; }
     get ownedProcessId() { return this.driver.ownedProcessId; }
@@ -147,6 +154,7 @@ class BuiltinAgentEndpoint {
         const previous = this.#attempts.get(input.attemptId);
         if (previous !== undefined) {
             if (previous.input.inputRef !== input.inputRef || previous.input.boundedText !== input.boundedText
+                || !isDeepStrictEqual(previous.input.additionalContext, input.additionalContext)
                 || previous.operation !== operation) {
                 throw new Error("Endpoint attempt identity cannot be reused for different input or operation.");
             }
@@ -160,7 +168,9 @@ class BuiltinAgentEndpoint {
             return { status: "not-submitted", error: new ProviderTurnRejectedError("Endpoint is detached.", input.attemptId) };
         }
         const attempt = {
-            input: Object.freeze({ ...input }),
+            input: Object.freeze({ ...input, ...(input.additionalContext === undefined ? {} : {
+                    additionalContext: structuredClone(input.additionalContext)
+                }) }),
             operation,
             disposition: { status: "pending", reason: "submitting" }
         };

package/dist/runtime/agentEndpointIdentity.js

@@ -35,6 +35,8 @@ const ENDPOINT_CHECKOUT_MODULES = Object.freeze([
     "acpProtocol.js",
     "acpSessionConfiguration.js",
     "agentRunConfiguration.js",
+    "contextRecovery.js",
+    "codexNativeAccess.js",
     "jsonLineChannel.js"
 ]);
 function resolveEndpointGeneration() {