@zq-silk/yui 0.15.11 → 0.16.0

package/dist/commands/agentCommands.js

@@ -1,11 +1,11 @@
 import { isDeepStrictEqual } from "node:util";
-import { agentNotFound, usageError } from "../errors/cliError.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
 import { isAgentAdapterId, supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
-import { adapterIdForExecutionComponent, agentExecutionComponentLabel, defaultExecutionComponentForAdapter, isAgentExecutionComponentId, supportedAgentExecutionComponentIds } from "../agent/executionComponents.js";
 import { createConfiguredAgent, validateConfiguredAgent } from "../agent/agent.js";
-import { LIVE_SESSION_ACKNOWLEDGEMENT_OPTION } from "./roleRuntimeGuard.js";
+import { adapterIdForExecutionComponent, agentExecutionComponentLabel, defaultExecutionComponentForAdapter, isAgentExecutionComponentId, supportedAgentExecutionComponentIds } from "../agent/executionComponents.js";
+import { agentNotFound, usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { LIVE_SESSION_ACKNOWLEDGEMENT_OPTION } from "./roleRuntimeGuard.js";
 export function runAgentCommand(args, store) {
     const [command, ...rest] = args;
     switch (command) {

package/dist/commands/capabilityCommands.js

@@ -1,5 +1,5 @@
 import { usageError } from "../errors/cliError.js";
-import { resolveJobCaller } from "./taskActor.js";
+import { resolveJobCaller } from "../task/taskAuthority.js";
 import { callFileTaskController } from "../controller/clientRuntime.js";
 export async function runCapabilityCommand(args, home, environment) {
     const [action, ...rest] = args;

package/dist/commands/configCommands.js

@@ -1,15 +1,14 @@
 import { mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
-import { usageError } from "../errors/cliError.js";
-import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetRuns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { CONFIG_DEFINITIONS, CONFIG_KEYS, configDefinition, configDefinitionsForDomain } from "../config/configCatalog.js";
-import { resolveTimeZone } from "../output/timePresentation.js";
+import { resolveTimeZone } from "../config/timeZone.js";
+import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { REVIEW_TRIGGERS } from "../review/reviewConfig.js";
 /**
  * One uniform key model for every durable setting. Each catalog domain uses
- * the same show/set/clear contract; strategy settings such as `review` and
- * `leader-next-action` are keys like any other.
+ * the same show/set/clear contract, including the explicit review policy.
  */
 export { CONFIG_KEYS } from "../config/configCatalog.js";
 const CONFIG_PROPERTIES = Object.fromEntries(CONFIG_DEFINITIONS.map(({ key, property }) => [
@@ -20,7 +19,6 @@ const TIME_ZONE_SET_USAGE = "System config set usage: yui config system set time
 const RECONCILIATION_SET_USAGE = "Runtime config set usage: yui config runtime set reconciliation-interval-seconds <5-300>.";
 const RESOURCES_GC_MODE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-mode <report|quarantine>.";
 const RESOURCES_GC_AUTO_QUARANTINE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-auto-quarantine <true|false>.";
-const LEADER_NEXT_ACTION_SET_USAGE = `Workflow config set usage: yui config workflow set leader-next-action <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
 const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final>.";
 export function runConfigCommand(domain, args, store) {
     const keys = configDefinitionsForDomain(domain).map(({ key }) => key);
@@ -65,7 +63,6 @@ export function effectiveConfigData(config, domain) {
         lastTaskId: config.lastTaskId ?? null,
         reconciliationIntervalSeconds: config.reconciliationIntervalSeconds
             ?? DEFAULT_RECONCILIATION_INTERVAL_SECONDS,
-        leaderNextActionMode: resolveLeaderNextActionMode(config.leaderNextActionMode),
         resourcesGcMode: resolveResourcesGcMode(config.resourcesGcMode),
         resourcesGcAutoQuarantine: resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine),
         resourcesQuarantineTtlHours: resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours),
@@ -77,7 +74,6 @@ export function effectiveConfigData(config, domain) {
         controllerTaskConcurrency: resolveControllerTaskConcurrency(config.controllerTaskConcurrency),
         agentLaunchInactivityTimeoutSeconds: resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds),
         deliveryTimeoutSeconds: resolveDeliveryTimeoutSeconds(config.deliveryTimeoutSeconds),
-        leaderSemanticBudgetRuns: resolveLeaderSemanticBudgetRuns(config.leaderSemanticBudgetRuns),
         tmuxBin: resolveTmuxBin(config.tmuxBin),
         tmuxHistoryLimit: resolveTmuxHistoryLimit(config.tmuxHistoryLimit),
         telemetryEnabled: resolveTelemetryEnabled(config.telemetryEnabled),
@@ -164,7 +160,7 @@ const CONFIG_KEY_HANDLERS = [
                 throw usageError("System config set usage: yui config system set default-agent <agent-id>.");
             }
             const defaultAgent = args[0].trim();
-            if (store.getConfiguredAgent?.(defaultAgent) === null) {
+            if (store.getConfiguredAgent(defaultAgent) === null) {
                 throw usageError(`Configured Agent not found: ${defaultAgent}.`);
             }
             saveConfigKey(store, (config) => ({ ...config, defaultAgent }));
@@ -237,51 +233,6 @@ const CONFIG_KEY_HANDLERS = [
             return `Reconciliation interval reset to ${DEFAULT_RECONCILIATION_INTERVAL_SECONDS} seconds\n`;
         }
     },
-    {
-        key: "leader-next-action",
-        showLabel: "Leader next-action mode",
-        showValue: (config) => resolveLeaderNextActionMode(config.leaderNextActionMode),
-        set(args, store) {
-            if (args.length !== 1)
-                throw usageError(LEADER_NEXT_ACTION_SET_USAGE);
-            let mode;
-            try {
-                mode = resolveLeaderNextActionMode(args[0]);
-            }
-            catch (error) {
-                throw usageError(error instanceof Error ? error.message : String(error), LEADER_NEXT_ACTION_SET_USAGE);
-            }
-            saveConfigKey(store, (config) => ({ ...config, leaderNextActionMode: mode }));
-            return `Leader next-action mode set to ${mode}\n`;
-        },
-        clear(store) {
-            saveConfigKey(store, (config) => {
-                const { leaderNextActionMode: _removed, ...rest } = config;
-                return rest;
-            });
-            return `Leader next-action mode reset to ${DEFAULT_LEADER_NEXT_ACTION_MODE}\n`;
-        }
-    },
-    {
-        key: "leader-semantic-budget-runs",
-        showLabel: "Leader semantic budget",
-        showValue: (config) => `${resolveLeaderSemanticBudgetRuns(config.leaderSemanticBudgetRuns)} runs`,
-        set(args, store) {
-            const usage = "Workflow config set usage: yui config workflow set leader-semantic-budget-runs <1-20>.";
-            if (args.length !== 1)
-                throw usageError(usage);
-            const leaderSemanticBudgetRuns = validatedConfigValue(() => resolveLeaderSemanticBudgetRuns(Number(args[0])), usage);
-            saveConfigKey(store, (config) => ({ ...config, leaderSemanticBudgetRuns }));
-            return `Leader semantic budget set to ${leaderSemanticBudgetRuns} runs\n`;
-        },
-        clear(store) {
-            saveConfigKey(store, (config) => {
-                const { leaderSemanticBudgetRuns: _removed, ...rest } = config;
-                return rest;
-            });
-            return `Leader semantic budget reset to ${DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS} runs\n`;
-        }
-    },
     {
         key: "resources-gc-mode",
         showLabel: "Resources GC mode",
@@ -565,7 +516,7 @@ const CONFIG_KEY_HANDLERS = [
                 || !REVIEW_TRIGGERS.includes(rawTrigger)) {
                 throw usageError(REVIEW_SET_USAGE);
             }
-            if (store.getGlobalRole?.(roleName) === null) {
+            if (store.getGlobalRole(roleName) === null) {
                 throw usageError(`Global Role not found: ${roleName}.`);
             }
             const trigger = rawTrigger;
@@ -598,8 +549,6 @@ if (missingConfigHandlers.length > 0 || duplicateConfigHandlers.length > 0) {
 }
 function resolveDefaultWorkspace(value, store) {
     const requested = resolve(value);
-    if (store.rootDirectory === undefined)
-        return requested;
     const requestedHome = resolve(store.rootDirectory());
     assertWorkspaceOutsideHome(requested, requestedHome);
     mkdirSync(requested, { recursive: true, mode: 0o700 });

package/dist/commands/configOverview.js

@@ -12,7 +12,7 @@ import { CONFIG_DOMAINS } from "../config/configCatalog.js";
  * therefore explain what the user sees without reconstructing configuration
  * from help text or implementation defaults.
  */
-export function runConfigOverview(args, store, environment, identity, roleOptions) {
+export function runConfigOverview(args, store, environment, roleOptions) {
     if (args.length !== 0)
         throw usageError("Config show usage: yui config show.");
     const domains = Object.fromEntries(CONFIG_DOMAINS.map((domain) => [
@@ -27,7 +27,7 @@ export function runConfigOverview(args, store, environment, identity, roleOption
     ]));
     const profileResult = runProfileCommand(["list"], store);
     const profiles = profileResult.data.profiles;
-    const completion = inspectCompletionStates(store.getConfig(), environment, identity);
+    const completion = inspectCompletionStates(store.getConfig(), environment);
     const roleOutput = runGlobalRoleCommand(["list"], store, roleOptions);
     if (typeof roleOutput !== "string") {
         throw new Error("Config overview received an invalid Role control result.");

package/dist/commands/durableJobCommands.js

@@ -1,7 +1,7 @@
 import { usageError } from "../errors/cliError.js";
 import { ensureFileTaskController } from "../controller/clientRuntime.js";
 import { acknowledgeDurableJob, cancelDurableJob, getDurableJob, startDurableJob } from "../controller/jobClient.js";
-import { resolveJobCaller, taskLocalActor } from "./taskActor.js";
+import { resolveJobCaller, taskLocalActor } from "../task/taskAuthority.js";
 /**
  * The textual `--owner` forms accepted by `job start`. The public help text in
  * the command catalog must document exactly these forms.
@@ -25,7 +25,7 @@ export async function runDurableJobCommand(args, options) {
     throw usageError(command === undefined
         ? "Job command is required: start, get, cancel, or acknowledge."
         : `Unknown command: job ${command}`, "yui job start --task <id> --project <project> --head <sha> --workspace <dir> "
-        + "--step <name>=<command> [--step ...] [--env K=V ...] "
+        + "--request-id <id> --step <name>=<command> [--step ...] [--env K=V ...] "
         + `[--owner ${JOB_OWNER_USAGE}] [--retry-of <job-id>]\n`
         + "yui job get --task <id> --job <job-id>\n"
         + "yui job cancel --task <id> --job <job-id>\n"
@@ -36,6 +36,7 @@ async function startJob(args, options) {
     await ensureFileTaskController(options.home, { environment: options.environment });
     const caller = resolveJobCaller(options.environment, parsed.taskId);
     const params = {
+        requestId: parsed.requestId,
         taskId: parsed.taskId,
         owner: parsed.owner,
         projectId: parsed.projectId,
@@ -54,8 +55,9 @@ async function startJob(args, options) {
 }
 async function getJob(args, options) {
     const ref = parseRefArgs(args, "get");
+    const caller = resolveJobCaller(options.environment, ref.taskId);
     await ensureFileTaskController(options.home, { environment: options.environment });
-    const job = await getDurableJob(options.home, ref.taskId, ref.jobId);
+    const job = await getDurableJob(options.home, ref.taskId, ref.jobId, caller);
     if (options.json === true)
         return `${JSON.stringify(job, null, 2)}\n`;
     const lines = [
@@ -111,6 +113,7 @@ async function acknowledgeJob(args, options) {
 }
 function parseStartArgs(args) {
     let taskId;
+    let requestId;
     let projectId;
     let head;
     let workspace;
@@ -129,6 +132,9 @@ function parseStartArgs(args) {
             case "--task":
                 taskId = value;
                 break;
+            case "--request-id":
+                requestId = value;
+                break;
             case "--project":
                 projectId = value;
                 break;
@@ -165,10 +171,10 @@ function parseStartArgs(args) {
         }
     }
     if (taskId === undefined || projectId === undefined || head === undefined
-        || workspace === undefined || steps.length === 0) {
-        throw usageError("job start requires --task, --project, --head, --workspace, and at least one --step.", "yui job start ...");
+        || workspace === undefined || requestId === undefined || requestId.trim().length === 0 || steps.length === 0) {
+        throw usageError("job start requires --request-id, --task, --project, --head, --workspace, and at least one --step.", "yui job start ...");
     }
-    return { taskId, owner, projectId, head, workspace, env, steps, retryOf };
+    return { taskId, requestId, owner, projectId, head, workspace, env, steps, retryOf };
 }
 export function parseJobOwner(value) {
     if (value === "task")

package/dist/commands/executionAuditCommands.js

@@ -7,6 +7,7 @@
  */
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
+import { formatUsageMetric } from "../runtime/taskUsageMetrics.js";
 import { runExecutionAudit } from "../observability/executionAudit.js";
 export function parseExecutionAuditOptions(args) {
     const options = {};
@@ -246,6 +247,15 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("orchestration", report));
     }
+    if (report.usage.status === "ok" && report.usage.data !== undefined) {
+        lines.push("", "Observed usage — Task lifetime, observed sources only (audit time window not applied):");
+        for (const usage of report.usage.data) {
+            lines.push(`  ${usage.taskId}: tokens=${formatUsageMetric(usage.tokens)}; tools=${formatUsageMetric(usage.toolCalls)}; elapsed=${formatUsageMetric(usage.elapsedSeconds, "s")}; native execution sum=${formatUsageMetric(usage.executionSeconds, "s")}`);
+        }
+    }
+    else {
+        lines.push("", ...sectionError("usage", report));
+    }
     if (report.storage.status === "ok" && report.storage.data !== undefined) {
         const storage = report.storage.data;
         lines.push("", `Storage: backend ${storage.backend} · state.json ${formatBytes(storage.stateJsonBytes)} · yui.db ${formatBytes(storage.databaseBytes)}`

package/dist/commands/globalRoleCommands.js

@@ -1,4 +1,6 @@
 import { roleNotFound, usageError } from "../errors/cliError.js";
+import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
+import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { createRoleSessionSet, recordRoleAgentSession } from "../executor/agentExecutor.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { managedGlobalRoleWorkspace } from "../storage/homeLayout.js";
@@ -12,30 +14,41 @@ import { isSystemRoleName, SYSTEM_ROLE_NAMES, systemRoleDescription } from "../r
 import { hasAgentConfigOptions, hasNoRoleMutation, parseRoleOptions, patchRoleAgentBinding, roleOptionSpecs, roleProfileFrom, roleProfilePatch } from "./roleConfiguration.js";
 import { hasRoleLaunchContextOptions, validateConfiguredRoleSkills } from "./roleSkillValidation.js";
 import { assertLiveRoleSessionAcknowledged, assertRoleRuntimeMutationAllowed, LIVE_SESSION_ACKNOWLEDGEMENT_OPTION } from "./roleRuntimeGuard.js";
-export function runGlobalRoleCommand(args, store, options = {}) {
-    const [command, ...rest] = args;
-    if (command === "message" || command === "interrupt") {
-        const env = options.env ?? process.env;
-        const target = command === "message" ? rest[1] : rest[0];
-        if (env.YUI_SESSION_SCOPE !== undefined && env.YUI_SESSION_SCOPE !== "global"
-            || env.YUI_SESSION_SCOPE === "global" && env.YUI_ROLE !== "operator"
-                && env.YUI_ROLE !== target) {
-            throw usageError("Global input mutation is outside the exact Session authority.");
-        }
-        if (env.YUI_SESSION_SCOPE === "global") {
-            const caller = store.getGlobalRoleSessionSet(env.YUI_ROLE ?? "");
-            const session = caller?.sessions[caller.activeAgentId];
-            if (session === undefined || session.status !== "active" || env.YUI_AGENT_ID !== session.agentId
-                || env.YUI_ADAPTER_ID !== session.adapterId
-                || (env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID) !== session.nativeSessionId) {
-                throw usageError("Global input mutation requires the current native caller Session.");
-            }
-        }
-        else if (env.YUI_ROLE !== undefined || env.YUI_AGENT_ID !== undefined
-            || env.YUI_NATIVE_SESSION_ID !== undefined) {
-            throw usageError("Incomplete managed identity cannot acquire user authority.");
+export function applyGlobalInputControl(name, input, store, options = {}) {
+    assertGlobalInputAuthority(store, options, name);
+    return input.action === "interrupt"
+        ? interruptGlobalInput(name, input, store)
+        : messageGlobalInput(name, input, store, options);
+}
+function inputOutput(output, data) {
+    return { kind: "output", output, data };
+}
+function renderGlobalInput(result, options) {
+    return result.kind === "output" ? jsonOrText(options, result.output, result.data) : result;
+}
+function assertGlobalInputAuthority(store, options, target) {
+    const env = options.env ?? process.env;
+    if (env.YUI_SESSION_SCOPE !== undefined && env.YUI_SESSION_SCOPE !== "global"
+        || env.YUI_SESSION_SCOPE === "global" && env.YUI_ROLE !== "operator" && env.YUI_ROLE !== target) {
+        throw usageError("Global input mutation is outside the exact Session authority.");
+    }
+    if (env.YUI_SESSION_SCOPE === "global") {
+        const caller = store.getGlobalRoleSessionSet(env.YUI_ROLE ?? "");
+        const session = caller?.sessions[caller.activeAgentId];
+        if (session === undefined || session.status !== "active" || env.YUI_AGENT_ID !== session.agentId
+            || env.YUI_ADAPTER_ID !== session.adapterId
+            || (env.CODEX_THREAD_ID ?? env.YUI_NATIVE_SESSION_ID) !== session.nativeSessionId) {
+            throw usageError("Global input mutation requires the current native caller Session.");
         }
     }
+    else if (env.YUI_ROLE !== undefined || env.YUI_AGENT_ID !== undefined || env.YUI_NATIVE_SESSION_ID !== undefined) {
+        throw usageError("Incomplete managed identity cannot acquire user authority.");
+    }
+}
+export function runGlobalRoleCommand(args, store, options = {}) {
+    const [command, ...rest] = args;
+    if (command === "session" && rest[0] === "retry")
+        assertGlobalInputAuthority(store, options, rest[1]);
     switch (command) {
         case "add": return addRole(rest, store, options);
         case "list": return listRoles(rest, store);
@@ -126,6 +139,7 @@ function roleContext(args, store, options) {
         pendingMessages: pendingQueue,
         messages: store.listGlobalRoleMessages(name),
         nativeTurn: sessions?.providerBinding?.run ?? null,
+        retry: providerRetryProjection(sessions?.providerBinding),
         interrupts: sessions?.interrupts ?? {},
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
         cliCommand: "yui"
@@ -382,6 +396,28 @@ function enterRole(args, store) {
 }
 function roleSession(args, store, options) {
     const [command, rawName, ...tail] = args;
+    if (command === "retry") {
+        const name = roleName(rawName);
+        const [action = "show", ...extra] = tail;
+        if (extra.length > 0 || !["show", "cancel", "disable", "enable"].includes(action)) {
+            throw usageError("Usage: yui session retry <role> [show|cancel|disable|enable]");
+        }
+        return store.transaction(tx => {
+            requireRole(name, tx);
+            const sessions = tx.getGlobalRoleSessionSet(name);
+            let binding = sessions?.providerBinding ?? null;
+            if (action !== "show") {
+                if (sessions === null || binding === null)
+                    throw usageError("No current Provider Session.");
+                binding = controlProviderRetry(binding, action, Date.now());
+                tx.saveGlobalRoleSessionSet({ ...sessions, providerBinding: binding });
+                settleGlobalRetryInput(tx, name, binding, new Date());
+            }
+            return options.jsonOutput ? JSON.stringify({
+                roleName: name, retry: providerRetryProjection(binding), disabled: binding?.retryDisabled ?? false
+            }) + "\n" : renderProviderRetry(binding) + "\n";
+        });
+    }
     if (command !== "record" && command !== "replace") {
         throw usageError("Session usage: yui session record|replace <role> --native-id <id> [--reason <reason>].");
     }
@@ -526,6 +562,13 @@ function globalRoleMessage(args, store, options) {
     const expectedTarget = action === "steer"
         ? required(parsed.one("--expected-target"), "--expected-target")
         : undefined;
+    return renderGlobalInput(applyGlobalInputControl(name, action === "steer"
+        ? { action, body, requestId, expectedTarget: expectedTarget, to: name }
+        : { action, body, requestId }, store, options), options);
+}
+function messageGlobalInput(name, input, store, options) {
+    const { action, body, requestId } = input;
+    const expectedTarget = input.action === "steer" ? input.expectedTarget : undefined;
     const now = new Date();
     // The durable Global input is authored as an operator input: a Global Role has
     // no Task Leader, and the operator is the human authority over Global Roles.
@@ -538,14 +581,14 @@ function globalRoleMessage(args, store, options) {
     });
     if (action === "queue") {
         const state = persisted.idempotentReplay ? "idempotent-replay" : "queued";
-        return jsonOrText(options, `Queued Global message ${persisted.message.id} to ${name} (${state}).\n`, { roleName: name, message: persisted.message, delivery: { state } });
+        return inputOutput(`Queued Global message ${persisted.message.id} to ${name} (${state}).\n`, { roleName: name, message: persisted.message, delivery: { state } });
     }
     if (persisted.idempotentReplay) {
-        return jsonOrText(options, `Steer Global message ${persisted.message.id} already recorded (idempotent-replay).\n`, { roleName: name, message: persisted.message, steer: { state: "idempotent-replay" } });
+        return inputOutput(`Steer Global message ${persisted.message.id} already recorded (idempotent-replay).\n`, { roleName: name, message: persisted.message, steer: { state: "idempotent-replay" } });
     }
     const resolution = resolveGlobalInputControl(store, name, "steer", expectedTarget);
     if (resolution.outcome !== "ready") {
-        return jsonOrText(options, `Steer Global message ${persisted.message.id} saved but not delivered (${resolution.code}: ${resolution.detail}).\n`, { roleName: name, message: persisted.message,
+        return inputOutput(`Steer Global message ${persisted.message.id} saved but not delivered (${resolution.code}: ${resolution.detail}).\n`, { roleName: name, message: persisted.message,
             steer: { state: "not-steered", code: resolution.code, detail: resolution.detail } });
     }
     store.updateGlobalRoleMessage({ ...persisted.message, control: {
@@ -571,7 +614,6 @@ function globalRoleMessage(args, store, options) {
  * fourth action and not an auto-fallback (decision-3 §4).
  */
 function globalRoleInterrupt(args, store, options) {
-    const usage = "Role interrupt usage: yui role interrupt <role> --expected-target <turn> [--then-message <global-message-id>] [--request-id <id>].";
     const [rawName, ...tail] = args;
     const name = roleName(rawName);
     const parsed = parseOptions(tail, new Map([
@@ -582,12 +624,19 @@ function globalRoleInterrupt(args, store, options) {
     const expectedTarget = required(parsed.one("--expected-target"), "--expected-target");
     const thenMessageId = trimmed(parsed.one("--then-message"));
     const requestId = trimmed(parsed.one("--request-id")) ?? `cancel:${encodeURIComponent(expectedTarget)}`;
+    return renderGlobalInput(applyGlobalInputControl(name, {
+        action: "interrupt", role: name, expectedTarget, thenMessage: thenMessageId, requestId
+    }, store, options), options);
+}
+function interruptGlobalInput(name, input, store) {
+    const { expectedTarget, thenMessage: thenMessageId } = input;
+    const requestId = input.requestId ?? `cancel:${encodeURIComponent(expectedTarget)}`;
     const fingerprint = JSON.stringify({ expectedTarget, thenMessageId });
     const prior = store.getGlobalRoleSessionSet(name)?.interrupts?.[requestId];
     if (prior !== undefined) {
         if (prior.fingerprint !== fingerprint)
             throw usageError("Interrupt requestId already names another control.");
-        return jsonOrText(options, `Interrupt ${requestId} already recorded; no native control repeated.\n`, { roleName: name, interrupt: prior.receipt ?? { state: "interrupt-unknown" }, idempotentReplay: true });
+        return inputOutput(`Interrupt ${requestId} already recorded; no native control repeated.\n`, { roleName: name, interrupt: prior.receipt ?? { state: "interrupt-unknown" }, idempotentReplay: true });
     }
     const resolved = store.transaction((tx) => {
         requireRole(name, tx);
@@ -620,10 +669,10 @@ function globalRoleInterrupt(args, store, options) {
         return resolution;
     });
     if (resolved.outcome === "then-conflict") {
-        return jsonOrText(options, `Interrupt not delivered (${resolved.code}: ${resolved.detail}).\n`, { roleName: name, interrupt: { state: "not-interrupted", code: resolved.code, detail: resolved.detail } });
+        return inputOutput(`Interrupt not delivered (${resolved.code}: ${resolved.detail}).\n`, { roleName: name, interrupt: { state: "not-interrupted", code: resolved.code, detail: resolved.detail } });
     }
     if (resolved.outcome !== "ready") {
-        return jsonOrText(options, `Interrupt not delivered (${resolved.code}: ${resolved.detail}).\n`, { roleName: name, interrupt: { state: "not-interrupted", code: resolved.code, detail: resolved.detail } });
+        return inputOutput(`Interrupt not delivered (${resolved.code}: ${resolved.detail}).\n`, { roleName: name, interrupt: { state: "not-interrupted", code: resolved.code, detail: resolved.detail } });
     }
     return {
         kind: "input-interrupt",

package/dist/commands/grantCommands.js

@@ -286,9 +286,6 @@ function requireTask(store, taskId) {
 function recordTaskEvent(store, taskId, type, payload, now) {
     store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now));
 }
-function requiredOption(options, name) {
-    return requiredText(options.get(name), name);
-}
 function optionalOption(options, name) {
     if (!options.has(name))
         return undefined;

package/dist/commands/jobCommands.js

@@ -93,9 +93,6 @@ function retryJob(args, store, options) {
         enqueueWork(tx, { kind: "role", taskId: task.id, roleName: "leader" }, "recovery-retry", now, [{ type: "task", id: task.id }]);
     });
     const target = { kind: "role", taskId, roleName: "leader" };
-    if (runtime.notifyMailboxChanged !== undefined)
-        runtime.notifyMailboxChanged(target);
-    else
-        runtime.notifyStateChanged(taskId);
+    runtime.notifyMailboxChanged(target);
     return `Retry requested for ${id}\n`;
 }

package/dist/commands/operatorCommands.js

@@ -1,11 +1,11 @@
-import { usageError } from "../errors/cliError.js";
 import { agentAdapterLabel as adapterLabel } from "../agent/adapterCatalog.js";
+import { usageError } from "../errors/cliError.js";
 import { createRoleSessionSet } from "../executor/agentExecutor.js";
-import { listOperatorSessions, projectOperatorStatus, prepareOperatorNewSession, prepareOperatorResumeSession } from "../operator/operatorSessionHistory.js";
+import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
+import { listOperatorSessions, prepareOperatorNewSession, prepareOperatorResumeSession, projectOperatorStatus } from "../operator/operatorSessionHistory.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatRelativeTimestamp } from "../output/timePresentation.js";
 import { updateGlobalRole } from "../role/role.js";
-import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
 import { submitOperatorMessage } from "./taskCommands.js";
 import { readCommandText } from "./textInput.js";
 /** Operator command parsing never launches or attaches a native process. */