@zq-silk/yui 2.20.0 → 2.22.0

package/dist/commands/inboxCommands.js

@@ -9,6 +9,8 @@ import { nonReplayableMessageWake, isLeaderSteer, pinMessageRevisions, releasedN
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isTaskRecordRetired, retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
 import { blocksInboxOrder, inboxEntryCategory, inboxSettled } from "../message/inboxTurn.js";
+import { recoveredMessageContinuation } from "../controller/taskRunRecovery.js";
+import { taskWakeInspectionCommand } from "./taskCommands.js";
 const target = (address) => ({ kind: "role", taskId: address.taskId, roleName: address.roleName });
 const source = (address) => `inbox:${address.scope}:${address.taskId ?? ""}:${address.roleName}`;
 const pendingId = (pending) => `pending-${readDigest(pending)}`;
@@ -38,6 +40,16 @@ function currentTurn(store, address) {
     return binding?.conversations.find(c => c.epoch === binding.currentConversationEpoch)?.conversationId === address.nativeSessionId
         ? binding?.run : undefined;
 }
+function isRecoveredMessage(store, address, entry) {
+    if (address.scope !== "task" || address.runId === undefined || isWake(entry))
+        return false;
+    const run = store.getRun(address.taskId, address.runId);
+    return run !== null && recoveredMessageContinuation(store, entry, run);
+}
+function entryCategory(store, address, entry) {
+    return isRecoveredMessage(store, address, entry) ? "current"
+        : inboxEntryCategory(entry, address, currentTurn(store, address));
+}
 function ownsMessage(store, address, message) {
     if (address.roleName === "leader" && message.taskId === address.taskId && isLeaderSteer(message))
         return true;
@@ -138,7 +150,8 @@ function blocker(store, address, entry) {
     }
     else {
         const message = entry;
-        if (message.continuation?.runId !== undefined && message.continuation.runId !== address.runId) {
+        if (message.continuation?.runId !== undefined && message.continuation.runId !== address.runId
+            && !isRecoveredMessage(store, address, message)) {
             return "continuation-already-dispatched";
         }
         if (!accepted && message.inputControl?.expectedSessionId !== undefined
@@ -163,7 +176,7 @@ function checkMutation(store, address) {
 }
 function summary(store, address, entry) {
     return { id: entry.id, kind: isWake(entry) ? "notification-window" : "message",
-        category: inboxEntryCategory(entry, address, currentTurn(store, address)),
+        category: entryCategory(store, address, entry),
         createdAt: entry.createdAt, summary: summaryText(isWake(entry) ? entry.reasons.join(", ") : entry.body),
         blocked: blocker(store, address, entry) ?? null, inbox: summaryMetadata(entry.inbox ?? null),
         handling: inboxHandlingState(entry.inbox),
@@ -178,9 +191,14 @@ function summary(store, address, entry) {
         read: `yui inbox show ${entry.id}`, ...(isWake(entry)
             ? { originals: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {}) };
 }
-function receipt(entry) {
+function receipt(entry, requestedId) {
+    // Pending-window inspection has no fixed originals yet. An existing wake
+    // can already have been read completely through inbox show; offer refresh
+    // without implying that claim invalidated those bodies or proved a read.
+    const originalRead = isWake(entry)
+        ? { [requestedId.startsWith("pending-") ? "originals" : "refreshOriginals"]: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {};
     return { id: entry.id, inbox: entry.inbox,
-        ...(isWake(entry) ? { originals: `yui task wake show ${entry.taskId} ${entry.id} --json` } : {}) };
+        ...originalRead };
 }
 /** Own-address command: there is deliberately no --role, --task or --session.
  * Reads do not claim. Exact claim precedes semantic handling; exact ack follows
@@ -198,8 +216,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
         const selected = address.scope === "global" ? pendingGlobalInboxMessages(store.listGlobalRoleMessages(address.roleName))
             : entries(store, address).filter(entry => (isWake(entry) || !retired.has(entry.id))
                 && !inboxSettled(entry.inbox));
-        const turn = currentTurn(store, address);
-        const categories = selected.map(entry => ({ entry, category: inboxEntryCategory(entry, address, turn) }));
+        const categories = selected.map(entry => ({ entry, category: entryCategory(store, address, entry) }));
         const rank = { current: 0, available: 1, history: 2 };
         categories.sort((a, b) => rank[a.category] - rank[b.category]);
         const items = categories.filter(item => view === "all"
@@ -230,7 +247,17 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 note: "Claim this exact window before processing; claim returns its durable wake and original-read command." }, `${source(address)}/${id}`, parsed.cursor);
         }
         const entry = getEntry(store, address, id);
-        const value = !isWake(entry) && address.scope === "task"
+        if (isWake(entry)) {
+            // Own-inbox authorization above remains the boundary. Reuse the existing
+            // bounded focused originals rather than reconstructing a second view or
+            // making a claim mutation depend on a subsequent read succeeding.
+            const focused = taskWakeInspectionCommand(["show", entry.taskId, entry.id], store);
+            if (focused.kind !== "output")
+                throw new Error("Wake inspection did not return a read result.");
+            const { wake: _wake, ...originalContext } = focused.data;
+            return boundedDocument({ ...entry, originalContext }, `${source(address)}/${id}`, parsed.cursor);
+        }
+        const value = address.scope === "task"
             ? expandTaskMessageResult(entry, (task, run) => store.getRun(task, run)) : entry;
         return boundedDocument(value, `${source(address)}/${id}`, parsed.cursor);
     }
@@ -262,7 +289,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                 if (existing.inboxPendingId !== id) {
                     throw new Error("Inbox request id was reused for a different window.");
                 }
-                return receipt(existing);
+                return receipt(existing, id);
             }
             const mailbox = tx.getWorkMailbox(target(current));
             if (!mailbox?.pending || pendingId(mailbox.pending) !== id)
@@ -310,7 +337,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                     if (saved.requestId !== requestId || saved.reason !== reason || !sameSession(saved.actor, current)) {
                         throw new Error("Conflicting retirement; original disposition retained.");
                     }
-                    return receipt(entry);
+                    return receipt(entry, id);
                 }
                 // A retained attempt in an older conversation is still evidence of
                 // submission; changing the active Session cannot erase that boundary.
@@ -336,7 +363,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                         throw new Error("Claim belongs to a previous Session; read the original and prior effects, then explicitly acknowledge only after finishing its handling.");
                     if (entry.inbox.claim.requestId !== requestId)
                         throw new Error("Entry already claimed; retain the original request id.");
-                    return receipt(entry);
+                    return receipt(entry, id);
                 }
                 const blocked = blocker(tx, current, entry);
                 if (blocked !== undefined)
@@ -398,7 +425,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
                     if (entry.inbox.ack.requestId !== requestId || entry.inbox.ack.reason !== reason
                         || !sameSession(entry.inbox.ack.actor, current))
                         throw new Error("Conflicting acknowledgement; original disposition retained.");
-                    return receipt(entry);
+                    return receipt(entry, id);
                 }
                 const inbox = { ...entry.inbox,
                     ack: { requestId, actor: current, at: now.toISOString(), reason: reason } };
@@ -415,7 +442,7 @@ export function runInboxCommand(args, store, env, now = new Date()) {
             }
         }
         save(tx, current, entry);
-        return receipt(entry);
+        return receipt(entry, id);
     });
     if (ids.length === 1)
         return apply(ids[0]);

package/dist/commands/operatorCommands.js

@@ -136,11 +136,8 @@ function submit(rest, store, options) {
     if (requestId !== undefined && requestId.length === 0) {
         throw usageError("--request-id is required.", usage);
     }
-    const body = readCommandText(positionals[0], bodyFile, "--body", usage);
-    return {
-        kind: "output",
-        output: submitOperatorMessage(body, taskId, store, options, intent, requestId)
-    };
+    const body = readCommandText(positionals[0], bodyFile, "--body", usage, { preserveFileWhitespace: true });
+    return submitOperatorMessage(body, taskId, store, options, intent, requestId);
 }
 function listSessions(args, store, options) {
     if (args.length !== 0)

package/dist/commands/releaseCommands.js

@@ -5,6 +5,7 @@
 import { spawn, spawnSync } from "node:child_process";
 import { chmodSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync, } from "node:fs";
 import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { callController, ControllerClientError } from "../core/controllerClient.js";
 import { processGenerationIsLive } from "../core/fileLockOwner.js";
 import { activateRelease, ControllerStartUnconfirmedError } from "../release/releaseHandover.js";
@@ -346,10 +347,23 @@ export function createReleaseActivatePorts(overrides = {}) {
                 }
             }),
         runPreflight: overrides.runPreflight ?? ((releaseDir, home) => {
-            const cli = join(releaseDir, "dist", "cli.js");
+            assertReleaseIsNotWorktreeOrLinked(releaseDir);
+            const manifest = verifyReleaseIntegrity(releaseDir);
+            if (resolve(releaseDir) !== resolve(releaseDirectoryFor(home, manifest))
+                || !hasMatchingSmokeReceipt(releaseDir, manifest)) {
+                throw new Error("Release preflight requires this Home's verified installed target and matching smoke receipt.");
+            }
             // The target owns current-record and database integrity validation.
             // Activation never migrates; a valid but older Home still blocks here.
-            const result = spawnSync(process.execPath, [cli, "--json", "upgrade", "--update-preflight"], {
+            // Invoke its read-only primitive, not an ordinary inactive CLI command:
+            // the Home's CLI fence must remain closed until handover completes.
+            const module = pathToFileURL(join(releaseDir, "dist", "storage", "upgrade", "upgradeOrchestrator.js")).href;
+            const result = spawnSync(process.execPath, ["--input-type=module", "-e", `
+        const { runStorageUpgrade } = await import(process.argv[1]);
+        const data = await runStorageUpgrade({ home: process.argv[2], mode: "update-preflight" });
+        process.stdout.write(JSON.stringify({ ok: true, data }));
+        process.exitCode = data.outcome === "update-preflight" ? 0 : 5;
+      `, module, home], {
                 env: { ...process.env, YUI_HOME: home, NO_COLOR: "1" },
                 encoding: "utf8",
                 timeout: 60_000

package/dist/commands/roleConfiguration.js

@@ -24,6 +24,8 @@ const AGENT_VALUE_OPTIONS = [
     ["--permission-strategy", "value"],
     ["--sandbox", "value"],
     ["--approval", "value"],
+    ["--exclude-tmpdir-env-var", "value"],
+    ["--exclude-slash-tmp", "value"],
     ["--permission-mode", "value"],
     ["--search", "value"]
 ];
@@ -37,6 +39,8 @@ const AGENT_CLEAR_OPTIONS = [
     ["--clear-allowed-tools", "flag"],
     ["--clear-disallowed-tools", "flag"],
     ["--clear-search", "flag"],
+    ["--clear-exclude-tmpdir-env-var", "flag"],
+    ["--clear-exclude-slash-tmp", "flag"],
     ["--clear-agent-config", "flag"]
 ];
 const AGENT_CONFIG_OPTIONS = new Set([
@@ -196,6 +200,8 @@ function permissionPatch(binding, parsed) {
         : undefined;
     const nativeOptions = [
         "--sandbox", "--approval", "--permission-mode",
+        "--exclude-tmpdir-env-var", "--exclude-slash-tmp",
+        "--clear-exclude-tmpdir-env-var", "--clear-exclude-slash-tmp",
         "--allowed-tool", "--clear-allowed-tools",
         "--disallowed-tool", "--clear-disallowed-tools"
     ].some((option) => parsed.has(option));
@@ -219,6 +225,19 @@ function permissionPatch(binding, parsed) {
             permission.sandbox = requiredText(parsed.one("--sandbox"));
         if (parsed.has("--approval"))
             permission.approval = requiredText(parsed.one("--approval"));
+        for (const [option, key] of [
+            ["exclude-tmpdir-env-var", "excludeTmpdirEnvVar"],
+            ["exclude-slash-tmp", "excludeSlashTmp"]
+        ]) {
+            if (parsed.has(`--${option}`)) {
+                const value = parsed.one(`--${option}`);
+                if (value !== "true" && value !== "false")
+                    throw usageError(`--${option} requires true or false.`);
+                permission[key] = value === "true";
+            }
+            if (parsed.has(`--clear-${option}`))
+                delete permission[key];
+        }
     }
     else if (binding.adapterId === "acp") {
         // An ACP Session's configured permission is exactly one mode id, matched
@@ -263,7 +282,9 @@ function assertAgentOptionConflicts(parsed) {
         ["--effort", "--clear-effort"],
         ["--allowed-tool", "--clear-allowed-tools"],
         ["--disallowed-tool", "--clear-disallowed-tools"],
-        ["--search", "--clear-search"]
+        ["--search", "--clear-search"],
+        ["--exclude-tmpdir-env-var", "--clear-exclude-tmpdir-env-var"],
+        ["--exclude-slash-tmp", "--clear-exclude-slash-tmp"]
     ]);
     if (parsed.has("--clear-agent-config")
         && [...parsed.seen].some((option) => option !== "--clear-agent-config" && AGENT_CONFIG_OPTIONS.has(option))) {
@@ -271,7 +292,9 @@ function assertAgentOptionConflicts(parsed) {
     }
 }
 function assertAdapterOptions(adapterId, parsed) {
-    const codex = ["--sandbox", "--approval", "--search", "--clear-search"];
+    const codex = ["--sandbox", "--approval", "--search", "--clear-search",
+        "--exclude-tmpdir-env-var", "--exclude-slash-tmp",
+        "--clear-exclude-tmpdir-env-var", "--clear-exclude-slash-tmp"];
     const tools = [
         "--allowed-tool", "--clear-allowed-tools",
         "--disallowed-tool", "--clear-disallowed-tools"

package/dist/commands/sessionCommands.js

@@ -27,7 +27,10 @@ export async function runSessionStopCommand(input) {
         // Leader dispatch. The explicit full pass settles pending runtime inbox and
         // lifecycle work that may exist without a current Session candidate.
         await input.runtime.drainController();
-        await input.runtime.stopController();
+        const stoppedController = await input.runtime.stopController();
+        if (stoppedController.stopped !== true && stoppedController.alreadyStopped !== true) {
+            throw new Error("Controller stop was not confirmed; no Session was stopped.");
+        }
         // Re-read the authoritative facts after the drain because a AgentRun that was
         // already inside a pass may have changed state meanwhile.
         const settled = input.runtime.snapshot();
@@ -80,7 +83,7 @@ function blockedSessions(input) {
     });
 }
 function blockedStopResult(blocked) {
-    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (an active AgentRun or lifecycle operation is still pending)`));
+    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (native execution, an active AgentRun or lifecycle operation is still pending)`));
     return {
         output: [
             `Cannot stop managed Sessions: ${blocked.length} Session(s) are still busy.`,