@zq-silk/yui 0.15.12 → 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/globalRoleCommands.js

@@ -14,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" || command === "session" && rest[0] === "retry") {
-        const env = options.env ?? process.env;
-        const target = command === "message" || command === "session" ? 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);
@@ -551,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.
@@ -563,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: {
@@ -596,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([
@@ -607,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);
@@ -645,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. */

package/dist/commands/projectCommands.js

@@ -8,7 +8,7 @@ import { GitWorkspaceRefreshError, NodeGitWorkspace } from "../repository/gitWor
 import { acquireProjectMaintenanceLock } from "../repository/projectMaintenanceLock.js";
 import { addProjectKnowledge, addKnowledgeProposal, assertProjectActive, decideKnowledgeProposal, createProject, findKnowledgeProposal, findKnowledgeProposalByFingerprint, knowledgeEvidenceDigest, knowledgeProposalFingerprint, managedProjectPath, planKnowledgeAcceptance, retireProject, retireProjectKnowledge, resolveProject, updateProjectKnowledge, updateProjectMetadata, validateProject, validateProjectName } from "../repository/project.js";
 import { managedWorkspacesRoot } from "../storage/homeLayout.js";
-import { projectActor } from "./taskActor.js";
+import { projectActor } from "../task/taskAuthority.js";
 export async function runProjectCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command === "add" || command === "clone") {
@@ -1497,9 +1497,6 @@ function proposeKnowledge(args, store, options) {
  * digest at proposal time, so a later Agent can verify the source record.
  */
 function requireProposalEvidence(store, parsed) {
-    if (store.getTask === undefined) {
-        throw usageError("Knowledge promotion requires Task evidence, which this store does not provide.");
-    }
     const task = store.getTask(parsed.task);
     if (task === null)
         throw usageError(`Task not found: ${parsed.task}.`);
@@ -1511,9 +1508,6 @@ function requireProposalEvidence(store, parsed) {
     };
     let evidence;
     if (parsed.decision !== undefined) {
-        if (store.getDecision === undefined) {
-            throw usageError("Knowledge promotion requires Decision evidence, which this store does not provide.");
-        }
         const decision = store.getDecision(task.id, parsed.decision);
         if (decision === null) {
             throw usageError(`Decision not found: ${parsed.decision} in Task ${task.id}.`);
@@ -1521,9 +1515,6 @@ function requireProposalEvidence(store, parsed) {
         evidence = `${decision.title}\n${decision.rationale}`;
     }
     else if (parsed.milestone !== undefined) {
-        if (store.getMilestone === undefined) {
-            throw usageError("Knowledge promotion requires Milestone evidence, which this store does not provide.");
-        }
         const milestone = store.getMilestone(task.id, parsed.milestone);
         if (milestone === null) {
             throw usageError(`Milestone not found: ${parsed.milestone} in Task ${task.id}.`);

package/dist/commands/resourcesCommands.js

@@ -7,12 +7,11 @@
  * every quarantined resource to its original path.
  */
 import { resolve } from "node:path";
+import { resolveResourcesGcMode, resolveResourcesQuarantineTtlHours } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { applyResourceGc, planResourceGc, purgeResourceQuarantine, restoreAllResourceGc } from "../resources/resourceGc.js";
-import { createResourceRegistryStore } from "../resources/resourceRegistryStore.js";
 import { resourceKindLabel, resourceOwnerLabel } from "../resources/resourceDiscovery.js";
-import { resolveResourcesGcMode, resolveResourcesQuarantineTtlHours } from "../config/yuiConfig.js";
+import { applyResourceGc, planResourceGc, readResourceGcState, purgeResourceQuarantine, restoreAllResourceGc } from "../resources/resourceGc.js";
 export async function runResourcesCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command !== "gc") {
@@ -27,10 +26,7 @@ async function runGcCommand(args, store, options) {
     const now = options.now?.() ?? new Date();
     const home = resolve(store.rootDirectory());
     const mode = resolveGcMode(store);
-    const projects = store.listProjects();
-    const managedWorkspaces = collectManagedWorkspaces(store);
-    const taskStatusById = collectTaskStatuses(store);
-    const activeWorkspaceOwnerPaths = collectActiveWorkspaceOwnerPaths(store);
+    const { projects, managedWorkspaces, taskStatusById, activeWorkspaceOwnerPaths, sessionOwners } = readResourceGcState(store);
     if (action === "restore") {
         const result = await restoreAllResourceGc(home, { now });
         return {
@@ -46,7 +42,7 @@ async function runGcCommand(args, store, options) {
                 data: { mode, action: "purge", skipped: true }
             };
         }
-        const result = await purgeResourceQuarantine(home, { now, ttlHours, managedWorkspaces });
+        const result = await purgeResourceQuarantine(home, { now, ttlHours, managedWorkspaces }, store);
         return {
             output: renderPurgeResult(result),
             data: result
@@ -54,7 +50,7 @@ async function runGcCommand(args, store, options) {
     }
     const plan = await planResourceGc({
         home,
-        registryStore: createResourceRegistryStore(home),
+        sessionOwners,
         projects,
         managedWorkspaces,
         taskStatusById,
@@ -66,7 +62,7 @@ async function runGcCommand(args, store, options) {
     if (action === "apply" && mode === "quarantine") {
         const result = await applyResourceGc({
             home,
-            registryStore: createResourceRegistryStore(home),
+            sessionOwners,
             projects,
             managedWorkspaces,
             taskStatusById,
@@ -74,7 +70,7 @@ async function runGcCommand(args, store, options) {
             now,
             quarantineTtlHours: ttlHours,
             activeWorkspaceOwnerPaths
-        }, plan);
+        }, plan, store);
         return {
             output: renderApplyResult(result),
             data: result
@@ -109,35 +105,6 @@ function parseTtlHours(args, store) {
 function resolveGcMode(store) {
     return resolveResourcesGcMode(store.getConfig().resourcesGcMode);
 }
-function collectManagedWorkspaces(store) {
-    const workspaces = [];
-    for (const task of store.listTasks()) {
-        workspaces.push(...store.listManagedWorkspaces(task.id));
-    }
-    return workspaces;
-}
-function collectTaskStatuses(store) {
-    const statuses = new Map();
-    for (const task of store.listTasks()) {
-        statuses.set(task.id, task.status);
-    }
-    return statuses;
-}
-/** Workspace paths claimed by active durable Jobs (AgentRuns). */
-function collectActiveWorkspaceOwnerPaths(store) {
-    const paths = [];
-    for (const task of store.listTasks()) {
-        for (const run of store.listRuns(task.id)) {
-            if (run.status !== "active")
-                continue;
-            const workspace = run.workspace;
-            if (workspace === undefined)
-                continue;
-            paths.push(workspace.root, ...workspace.entries.map((entry) => entry.path));
-        }
-    }
-    return paths;
-}
 function renderPlan(plan, action) {
     const lines = [];
     const modeNotice = plan.mode === "report" && action === "apply"
@@ -207,6 +174,9 @@ function renderApplyResult(result) {
     if (result.restored.length > 0) {
         lines.push(`Restored ${result.restored.length} resource(s) from quarantine.`);
     }
+    for (const record of result.planned.retained) {
+        lines.push(`Retained ${record.id} ${record.path}: ${record.blocker ?? "current ownership or live reference"}`);
+    }
     if (result.applied.length === 0 && result.failed.length === 0 && result.restored.length === 0) {
         lines.push("No releasable resources.");
     }

package/dist/commands/roleConfiguration.js

@@ -187,12 +187,8 @@ function permissionPatch(binding, parsed) {
     }
     const current = binding.config.permission;
     if (selected !== "configured" && !nativeOptions) {
-        // Nothing about permission was named, so the binding keeps what it already
-        // had. The fallback applies only to a binding that somehow carries no
-        // permission at all, and it must be the adapter's own default rather than a
-        // fixed `bypass`: ACP defaults to `default`, and defaulting it to bypass
-        // here would widen authority the user never granted.
-        return structuredClone(current ?? defaultRoleAgentConfig(binding.adapterId).permission);
+        // The validated binding always has its explicit permission strategy.
+        return structuredClone(current);
     }
     const permission = current?.strategy === "configured"
         ? structuredClone(current)

package/dist/commands/taskActivationCommands.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
-import { usageError } from "../errors/cliError.js";
-import { currentManagedRuntime } from "../runtime/managedCaller.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { usageError } from "../errors/cliError.js";
 import { SYSTEM_LEADER_ROLE } from "../role/systemRoles.js";
+import { currentManagedRuntime } from "../runtime/managedCaller.js";
 import { describeEnvironmentPlan } from "../task/taskActivation.js";
 import { cancelTaskActivation, requestTaskActivation, taskActivationOperationRef } from "../task/taskActivationService.js";
-import { taskLocalActor } from "./taskActor.js";
+import { taskLocalActor } from "../task/taskAuthority.js";
 /**
  * Explicit Activation requests.
  *
@@ -52,10 +52,6 @@ function requestActivation(args, store, options) {
         actorId: caller.actorId,
         authorityRef: caller.authorityRef,
         environmentPlan,
-        // The activation-request command is the explicit activation boundary, so
-        // every request it records carries an explicit provable origin (task-32
-        // §2.4). A develop submission records its own request with `submit-develop`.
-        origin: "explicit",
         ...(caller.planningRunId === undefined ? {} : { callerRunId: caller.planningRunId })
     }, now));
     // An immediate request has nothing left to wait for, so ask the Controller to
@@ -65,7 +61,7 @@ function requestActivation(args, store, options) {
         store.transaction((tx) => {
             enqueueWork(tx, { kind: "task", taskId }, "activation-requested", now, [{ type: "task", id: taskId }]);
         });
-        void options.runtime?.notifyMailboxChanged?.({ kind: "task", taskId });
+        void options.runtime?.notifyMailboxChanged({ kind: "task", taskId });
     }
     const request = result.request;
     const lines = [

package/dist/commands/taskAgentCapabilities.js

@@ -0,0 +1,9 @@
+import { exactPositionals, parseTail } from "./taskCommandSupport.js";
+export function parseTaskAgentCapabilityQuery(args) {
+    const usage = "Usage: yui task role capabilities <task> <role> [--error <event-id>] [--refresh]";
+    const parsed = parseTail(args, new Set(["--error"]), usage, new Set(["--refresh"]));
+    exactPositionals(parsed.positionals, 2, usage);
+    const errorId = parsed.options.get("--error");
+    return { taskId: parsed.positionals[0], roleName: parsed.positionals[1],
+        ...(errorId === undefined ? {} : { errorId }), refresh: parsed.options.has("--refresh") };
+}