@zq-silk/yui 0.7.0 → 0.8.1

package/dist/commands/configOverview.js

@@ -0,0 +1,60 @@
+import { inspectCompletionStates, renderCompletionStateTable } from "../completion/completionState.js";
+import { usageError } from "../errors/cliError.js";
+import { SYSTEM_ROLE_NAMES } from "../role/systemRoles.js";
+import { runAgentCommand } from "./agentCommands.js";
+import { runConfigCommand } from "./configCommands.js";
+import { runGlobalRoleCommand } from "./globalRoleCommands.js";
+import { runProfileCommand } from "./profileCommands.js";
+import { CONFIG_DOMAINS } from "../config/configCatalog.js";
+/**
+ * One complete projection of every persistent configuration domain. Human and
+ * JSON callers intentionally consume the same store projection; the Operator can
+ * therefore explain what the user sees without reconstructing configuration
+ * from help text or implementation defaults.
+ */
+export function runConfigOverview(args, store, environment, identity, roleOptions) {
+    if (args.length !== 0)
+        throw usageError("Config show usage: yui config show.");
+    const domains = Object.fromEntries(CONFIG_DOMAINS.map((domain) => [
+        domain,
+        runConfigCommand(domain, ["show"], store)
+    ]));
+    const agents = store.listConfiguredAgents();
+    const roles = store.listGlobalRoles();
+    const systemRoles = Object.fromEntries(SYSTEM_ROLE_NAMES.map((name) => [
+        name,
+        store.getGlobalRole(name)
+    ]));
+    const profiles = store.listAgentProfiles();
+    const completion = inspectCompletionStates(store.getConfig(), environment, identity);
+    const roleOutput = runGlobalRoleCommand(["list"], store, roleOptions);
+    if (typeof roleOutput !== "string") {
+        throw new Error("Config overview received an invalid Role control result.");
+    }
+    const profileOutput = runProfileCommand(["list"], store).output;
+    const agentOutput = runAgentCommand(["list"], store);
+    const domainData = Object.fromEntries(CONFIG_DOMAINS.map((domain) => [
+        domain,
+        domains[domain].data
+    ]));
+    return {
+        output: `${[
+            "Yui configuration",
+            ...CONFIG_DOMAINS.map((domain) => domains[domain].output.trimEnd()),
+            agentOutput.trimEnd(),
+            roleOutput.trimEnd(),
+            profileOutput.trimEnd(),
+            renderCompletionStateTable(completion).trimEnd()
+        ].join("\n\n")}\n`,
+        data: {
+            ...domainData,
+            agents,
+            roles: {
+                system: systemRoles,
+                custom: roles.filter(({ name }) => !SYSTEM_ROLE_NAMES.includes(name))
+            },
+            profiles,
+            completion
+        }
+    };
+}

package/dist/commands/deliveryGuardPreflight.js

@@ -1,4 +1,4 @@
-import { resolveLeaderNextActionMode } from "../config/yuiConfig.js";
+import { resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns } from "../config/yuiConfig.js";
 import { usageError } from "../errors/cliError.js";
 import { detectDeliveryDuplicates, evaluateDeliveryGuard, evaluateSemanticBudget, formatDeliveryDuplicate } from "../task/deliveryGuard.js";
 export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
@@ -15,7 +15,7 @@ export function runDeliveryGuardPreflight(store, taskId, intent, options = {}) {
             + "Reuse the existing proof, or set leader.nextActionMode=warn to proceed with a warning.");
     }
     if (options.budget === true) {
-        const budget = evaluateSemanticBudget(facts);
+        const budget = evaluateSemanticBudget(facts, resolveLeaderSemanticBudgetTurns(store.getConfig().leaderSemanticBudgetTurns));
         if (budget.exhausted) {
             warnings.push(`Semantic progress budget: ${budget.reason}`);
         }

package/dist/commands/globalRoleCommands.js

@@ -24,13 +24,13 @@ export function runGlobalRoleCommand(args, store, options = {}) {
         default:
             throw usageError(command === undefined
                 ? "Role command is required."
-                : `Unknown command: role ${command}`);
+                : `Unknown command: config role ${command}`);
     }
 }
 function roleContext(args, store, options) {
     const [rawName, ...rest] = args;
     const name = roleName(rawName);
-    assertNoArguments(rest, "Role context usage: yui role context <role>");
+    assertNoArguments(rest, "Session context usage: yui session context <role>");
     const environment = options.env ?? process.env;
     if (environment.YUI_SESSION_SCOPE !== undefined) {
         if (environment.YUI_SESSION_SCOPE !== "global" || environment.YUI_ROLE !== name) {
@@ -125,7 +125,7 @@ function addRole(args, store, options) {
     return presentRole(`Added role ${name}`, created, store);
 }
 function listRoles(args, store) {
-    assertNoArguments(args, "Role list usage: yui role list");
+    assertNoArguments(args, "Role list usage: yui config role list");
     const rows = new Map();
     for (const name of SYSTEM_ROLE_NAMES) {
         const role = store.getGlobalRole(name);
@@ -152,7 +152,7 @@ function listRoles(args, store) {
 function showRole(args, store) {
     const [rawName, ...rest] = args;
     const name = roleName(rawName);
-    assertNoArguments(rest, "Role show usage: yui role show <role>");
+    assertNoArguments(rest, "Role show usage: yui config role show <role>");
     const role = store.getGlobalRole(name);
     if (role === null) {
         if (isSystemRoleName(name))
@@ -218,7 +218,7 @@ function bindRole(args, store) {
     const [rawName, rawAgentId, ...rest] = args;
     const name = roleName(rawName);
     const agentId = required(rawAgentId, "Agent id");
-    assertNoArguments(rest, "Role bind usage: yui role bind <role> <agent-id>");
+    assertNoArguments(rest, "Role bind usage: yui config role bind <role> <agent-id>");
     const now = new Date();
     const result = store.transaction((tx) => {
         const role = requireRole(name, tx);
@@ -269,7 +269,7 @@ function assertOperatorAdapterAvailable(role, agent) {
 function removeRole(args, store) {
     const [rawName, ...rest] = args;
     const name = roleName(rawName);
-    assertNoArguments(rest, "Role remove usage: yui role remove <role>");
+    assertNoArguments(rest, "Role remove usage: yui config role remove <role>");
     if (isSystemRoleName(name))
         throw usageError(`System role cannot be removed: ${name}`);
     store.transaction((tx) => {
@@ -291,7 +291,7 @@ function unbindRole(args, store) {
     const [rawName, rawAgentId, ...rest] = args;
     const name = roleName(rawName);
     const agentId = required(rawAgentId, "Agent id");
-    assertNoArguments(rest, "Role unbind usage: yui role unbind <role> <agent-id>");
+    assertNoArguments(rest, "Role unbind usage: yui config role unbind <role> <agent-id>");
     store.transaction((tx) => {
         const role = requireRole(name, tx);
         try {
@@ -307,14 +307,14 @@ function unbindRole(args, store) {
 function enterRole(args, store) {
     const [rawName, ...rest] = args;
     const name = roleName(rawName);
-    assertNoArguments(rest, "Role enter usage: yui role enter <role>");
+    assertNoArguments(rest, "Role enter usage: yui session enter <role>");
     const role = requireRole(name, store);
     return { kind: "enter", role };
 }
 function roleSession(args, store, options) {
     const [command, rawName, ...tail] = args;
     if (command !== "record" && command !== "replace") {
-        throw usageError("Role session usage: yui role session record|replace <role> --native-id <id> [--reason <reason>].");
+        throw usageError("Session usage: yui session record|replace <role> --native-id <id> [--reason <reason>].");
     }
     const name = roleName(rawName);
     const parsed = parseOptions(tail, new Map([

package/dist/commands/profileCommands.js

@@ -14,11 +14,11 @@ export function runProfileCommand(args, store, now = () => new Date()) {
         default:
             throw usageError(command === undefined
                 ? "Profile command is required."
-                : `Unknown command: profile ${command}`);
+                : `Unknown command: config profile ${command}`);
     }
 }
 function addProfile(args, store, now) {
-    const usage = "Profile add usage: yui profile add <id> [--access <read|write>] [Profile settings].";
+    const usage = "Profile add usage: yui config profile add <id> [--access <read|write>] [Profile settings].";
     const [id, ...tail] = args;
     if (id === undefined || id.startsWith("--"))
         throw usageError("Profile id is required.", usage);
@@ -37,7 +37,7 @@ function addProfile(args, store, now) {
     return { output: `Added Agent Profile ${profile.id}\n`, data: { profile } };
 }
 function listProfiles(args, store) {
-    noArgs(args, "Profile list usage: yui profile list.");
+    noArgs(args, "Profile list usage: yui config profile list.");
     const profiles = store.listAgentProfiles();
     const output = profiles.length === 0
         ? "No Agent Profiles found.\n"
@@ -55,7 +55,7 @@ function listProfiles(args, store) {
     return { output, data: { profiles } };
 }
 function showProfile(args, store) {
-    const profile = requireProfile(store, oneArg(args, "Profile show usage: yui profile show <id>."));
+    const profile = requireProfile(store, oneArg(args, "Profile show usage: yui config profile show <id>."));
     return {
         output: `${[
             `Agent Profile: ${profile.id}`,
@@ -71,7 +71,7 @@ function showProfile(args, store) {
     };
 }
 function updateProfile(args, store, now) {
-    const usage = "Profile update usage: yui profile update <id> [--access <read|write>] [Profile settings].";
+    const usage = "Profile update usage: yui config profile update <id> [--access <read|write>] [Profile settings].";
     const [id, ...tail] = args;
     if (id === undefined || id.startsWith("--"))
         throw usageError("Profile id is required.", usage);
@@ -91,16 +91,16 @@ function updateProfile(args, store, now) {
     };
 }
 function removeProfile(args, store) {
-    const id = oneArg(args, "Profile remove usage: yui profile remove <id>.");
+    const id = oneArg(args, "Profile remove usage: yui config profile remove <id>.");
     if (BUILTIN_PROFILE_IDS.includes(id)) {
-        throw usageError(`Built-in Agent Profile cannot be removed: ${id}. Use profile reset instead.`);
+        throw usageError(`Built-in Agent Profile cannot be removed: ${id}. Use yui config profile reset instead.`);
     }
     if (!store.removeAgentProfile(id))
         throw usageError(`Agent Profile not found: ${id}.`);
     return { output: `Removed Agent Profile ${id}\n`, data: { profileId: id } };
 }
 function resetProfiles(args, store, now) {
-    noArgs(args, "Profile reset usage: yui profile reset.");
+    noArgs(args, "Profile reset usage: yui config profile reset.");
     store.transaction((tx) => {
         for (const desired of builtinAgentProfileInputs()) {
             const existing = tx.getAgentProfile(desired.id);

package/dist/commands/resourcesCommands.js

@@ -12,7 +12,7 @@ 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 } from "../config/yuiConfig.js";
+import { resolveResourcesGcMode, resolveResourcesQuarantineTtlHours } from "../config/yuiConfig.js";
 export async function runResourcesCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command !== "gc") {
@@ -23,7 +23,7 @@ export async function runResourcesCommand(args, store, options = {}) {
 }
 async function runGcCommand(args, store, options) {
     const action = parseGcAction(args);
-    const ttlHours = parseTtlHours(args);
+    const ttlHours = parseTtlHours(args, store);
     const now = options.now?.() ?? new Date();
     const home = resolve(store.rootDirectory());
     const mode = resolveGcMode(store);
@@ -95,10 +95,11 @@ function parseGcAction(args) {
         return "restore";
     return "dry-run";
 }
-function parseTtlHours(args) {
+function parseTtlHours(args, store) {
     const index = args.indexOf("--quarantine-ttl-hours");
-    if (index === -1)
-        return 24;
+    if (index === -1) {
+        return resolveResourcesQuarantineTtlHours(store.getConfig().resourcesQuarantineTtlHours);
+    }
     const value = Number(args[index + 1]);
     if (!Number.isFinite(value) || value < 1 || value > 24 * 30) {
         throw usageError("Quarantine TTL hours must be between 1 and 720.");

package/dist/commands/taskCommands.js

@@ -20,7 +20,6 @@ import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRol
 import { agentRunDeliveryReceiptId, createAgentRun, withAgentRunContextSnapshot } from "../run/agentRun.js";
 import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
-import { providerRetryConfig } from "../run/providerRetryConfig.js";
 import { createReviewRound, createTaskReviewRound, createTaskDeltaReviewRound, attachReviewExecutionGroup, deltaRecheckBlocksAcceptance, finishReviewRound, parseReviewYieldReport, recordReviewWorkspaceDisposition, retryTaskReviewRound, startReviewRound, updateReviewExecutionGroup, validateTaskReviewCandidate } from "../review/reviewRound.js";
 import { buildDeltaRecheckDispatchContext, verifyDeltaRecheckDiff } from "../review/deltaRecheck.js";
 import { buildTaskFinalReviewFindingContext, dispositionReviewFinding, planRepairGroups, reconcileReviewFindings, reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
@@ -2840,7 +2839,7 @@ function requestTaskReviewRound(args, store, options) {
             const reviewConfig = tx.getReviewConfig();
             if (reviewConfig === null || reviewConfig.deltaRecheck !== "enabled") {
                 throw usageError("Delta-recheck is not enabled for this Project's review policy. "
-                    + "Set `yui config set review --role <role> --trigger final --delta-recheck enabled` "
+                    + "Set `yui config workflow set review --role <role> --trigger final --delta-recheck enabled` "
                     + "or request a full Review.");
             }
             if (taskFinalContract !== undefined) {
@@ -4434,9 +4433,7 @@ function buildYieldOutcome(run, inputSummary, options) {
  * for the same outcome, fails closed for a different outcome, or returns
  * `null` to keep the legacy "already terminal" behavior.
  */
-function replayYieldReceipt(run, inputSummary, options, retryConfig) {
-    if (!retryConfig.yieldReceiptReplay)
-        return null;
+function replayYieldReceipt(run, inputSummary, options) {
     if (run.yieldReceipt === undefined)
         return null;
     const outcome = buildYieldOutcome(run, inputSummary, options);
@@ -4492,7 +4489,7 @@ function yieldRun(args, store, options) {
     // transaction; the receipt is immutable once committed.
     const existing = requireRun(store, parsed.positionals[0], options);
     if (existing.status !== "active") {
-        const replayed = replayYieldReceipt(existing, inputSummary, options, providerRetryConfig(store.getConfig()));
+        const replayed = replayYieldReceipt(existing, inputSummary, options);
         if (replayed !== null)
             return replayed;
         throw usageError(`Run ${existing.id} is already terminal: ${existing.status}.`);

package/dist/commands/taskRoleRuntimeStatus.js

@@ -5,6 +5,7 @@ import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunSta
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
+import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
@@ -397,7 +398,8 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, task
     const classification = classifyRuntimeHealth({
         projection,
         semanticProgressAt: semanticProgress.progressAt,
-        now
+        now,
+        policy: resolveRuntimeHealth(store.getConfig().runtimeHealth)
     });
     return {
         driverId,

package/dist/commands/telemetryCommands.js

@@ -2,14 +2,19 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { usageError } from "../errors/cliError.js";
 import { STORAGE_SCHEMA_FILE } from "../storage/storageSchema.js";
+import { CURRENT_CONFIG_SCHEMA_VERSION } from "../storage/taskStore.js";
 import { openTaskStore, SqliteTaskStore } from "../storage/sqliteStore.js";
 import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigration.js";
-import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, resolveRunCap, resolveTelemetryMode, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, resolveRunCap, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
+import { resolveTelemetryEnabled } from "../config/yuiConfig.js";
 import { applyTelemetryCompaction, planTelemetryCompaction } from "../telemetry/telemetryCompaction.js";
 import { SqliteTelemetryStore } from "../telemetry/sqliteTelemetryStore.js";
 /** Read the durable config, falling back to defaults when no store is available. */
 function storeConfig(options) {
-    return options.store?.getConfig() ?? { schemaVersion: 1 };
+    return options.store?.getConfig() ?? { schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION };
+}
+function telemetryMode(config) {
+    return resolveTelemetryEnabled(config.telemetryEnabled) ? "on" : "off";
 }
 export async function runTelemetryCommand(args, options) {
     const [command, ...rest] = args;
@@ -31,7 +36,7 @@ export async function runTelemetryCommand(args, options) {
 // -- status ---------------------------------------------------------------------
 function telemetryStatus(args, options) {
     const flags = parseFlags(args, new Set([]));
-    const mode = resolveTelemetryMode(storeConfig(options).telemetryMode);
+    const mode = telemetryMode(storeConfig(options));
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode,
         terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
@@ -90,7 +95,7 @@ function telemetryPrune(args, options) {
     const cap = resolveRunCap(storeConfig(options).telemetryRunCap);
     const store = requireStore(options);
     const telemetry = new SqliteTelemetryStore(options.home, {
-        mode: resolveTelemetryMode(storeConfig(options).telemetryMode),
+        mode: telemetryMode(storeConfig(options)),
         terminalKeep: keep,
         runCap: cap
     });
@@ -196,7 +201,7 @@ function telemetryCompact(args, options) {
     copyStoreFiles(resolvedFrom, resolvedStaged);
     const store = openTaskStore(resolvedStaged, backend);
     const telemetry = new SqliteTelemetryStore(resolvedStaged, {
-        mode: "bounded",
+        mode: "on",
         terminalKeep: keep,
         runCap: DEFAULT_RUN_CAP
     });
@@ -240,7 +245,7 @@ function telemetryRead(args, options) {
     const limit = integerOption(args, "--limit", 100);
     const offset = integerOption(args, "--offset", 0);
     const telemetry = new SqliteTelemetryStore(options.home, {
-        mode: resolveTelemetryMode(storeConfig(options).telemetryMode),
+        mode: telemetryMode(storeConfig(options)),
         terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
         runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
     });

package/dist/config/configCatalog.js

@@ -0,0 +1,42 @@
+import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
+import { MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
+import { MAX_CONTEXT_BUDGET_TOKENS, MAX_PROVIDER_RETRY_ATTEMPTS, MIN_CONTEXT_BUDGET_TOKENS } from "./yuiConfig.js";
+export const CONFIG_DOMAINS = ["system", "runtime", "workflow", "resources", "tools"];
+/**
+ * Public durable configuration contract. CLI help, completion, config show,
+ * config describe, and Operator guidance all project from this one catalog.
+ * Runtime-only implementation constants deliberately do not appear here.
+ */
+export const CONFIG_DEFINITIONS = Object.freeze([
+    { key: "default-agent", domain: "system", property: "defaultAgent", label: "Default Agent", summary: "Configured Agent used when a Task or Role does not select one explicitly.", takesEffect: "Future Role and Task defaults; existing bindings are unchanged." },
+    { key: "default-workspace", domain: "system", property: "defaultWorkspace", label: "Default workspace", summary: "Absolute workspace root outside YUI_HOME used when no workspace is selected.", takesEffect: "Future workspace selection; existing Roles and worktrees are unchanged." },
+    { key: "time-zone", domain: "system", property: "timeZone", label: "Time zone", summary: "IANA timezone for human-facing timestamps (default: Asia/Shanghai).", takesEffect: "The next human-readable timestamp rendering; durable JSON remains UTC." },
+    { key: "reconciliation-interval-seconds", domain: "runtime", property: "reconciliationIntervalSeconds", label: "Reconciliation interval", summary: "Recovery reconciliation interval, 5-300 seconds (default: 120).", takesEffect: "The running Controller is refreshed after the value is saved." },
+    { key: "controller-task-concurrency", domain: "runtime", property: "controllerTaskConcurrency", label: "Controller Task concurrency", summary: "Maximum Tasks reconciled concurrently, 1-32 (default: 4).", takesEffect: "After the Controller restarts." },
+    { key: "runtime-health", domain: "runtime", property: "runtimeHealth", label: "Runtime health thresholds", summary: "Quiet, diagnostic, and semantic-stall thresholds in seconds; values must be strictly increasing (defaults: 300/600/1800).", takesEffect: "CLI and Web projections immediately; scheduler stall handling after the Controller restarts." },
+    { key: "agent-launch-inactivity-timeout-seconds", domain: "runtime", property: "agentLaunchInactivityTimeoutSeconds", label: "Agent launch inactivity timeout", summary: "Maximum launch silence before startup fails, 15-3600 seconds (default: 300).", takesEffect: "After the Controller restarts." },
+    { key: "delivery-timeout-seconds", domain: "runtime", property: "deliveryTimeoutSeconds", label: "Delivery timeout", summary: "Total control-plane delivery retry budget, 5-600 seconds (default: 120).", takesEffect: "After the Controller restarts; internal retry cadence remains automatic." },
+    { key: "provider-retry-mode", domain: "runtime", property: "providerRetryMode", label: "Provider retry mode", summary: "Provider retry mode: off, shadow, or enforce (default: enforce).", takesEffect: "The next eligible provider-failure decision." },
+    { key: "provider-retry-adapters", domain: "runtime", property: "providerRetryAdapters", label: "Provider retry adapters", summary: `Adapters with in-place retry: all, off, or a comma-separated subset of ${supportedAgentAdapterIds().join(", ")} (default: all).`, takesEffect: "The next eligible provider-failure decision." },
+    { key: "provider-retry-delays-seconds", domain: "runtime", property: "providerRetryDelaysSeconds", label: "Provider retry delays", summary: `Ordered comma-separated retry delays of 1-600 seconds, with 1-${MAX_PROVIDER_RETRY_ATTEMPTS} attempts (default: 2,5,15).`, takesEffect: "The next eligible provider-failure decision; attempt count is the list length." },
+    { key: "provider-retry-max-window-seconds", domain: "runtime", property: "providerRetryMaxWindowSeconds", label: "Provider retry max window", summary: "Positive-integer total retry budget per Run lineage in seconds (default: 600).", takesEffect: "The next retry episode; an active episode keeps its existing deadline." },
+    { key: "leader-next-action", domain: "workflow", property: "leaderNextActionMode", label: "Leader next-action mode", summary: "Leader next-action mode: display, warn, or enforce (default: display).", takesEffect: "The next Leader next-action projection or gate." },
+    { key: "leader-semantic-budget-turns", domain: "workflow", property: "leaderSemanticBudgetTurns", label: "Leader semantic budget", summary: "Consecutive yielded Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
+    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Context budget", summary: `Per-Session context token budget; soft and hard are ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}, with soft below hard (defaults: 100000/120000).`, takesEffect: "The next context-budget evaluation; retained conversation content is unchanged." },
+    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger; optional finding-ledger and delta-recheck controls. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
+    { key: "resources-gc-mode", domain: "resources", property: "resourcesGcMode", label: "Resources GC mode", summary: "Resource GC mode: report or quarantine (default: report).", takesEffect: "The next resource GC operation." },
+    { key: "resources-gc-auto-quarantine", domain: "resources", property: "resourcesGcAutoQuarantine", label: "Resources GC auto-quarantine", summary: "Automatically quarantine eligible terminal Task resources (default: false).", takesEffect: "The next eligible automatic resource GC operation." },
+    { key: "resources-quarantine-ttl-hours", domain: "resources", property: "resourcesQuarantineTtlHours", label: "Resource quarantine TTL", summary: "Default observation window before purge, 1-720 hours (default: 24).", takesEffect: "The next resource GC command without an explicit TTL override." },
+    { key: "tmux-bin", domain: "tools", property: "tmuxBin", label: "Tmux bin", summary: "Command or path to the tmux binary (default: tmux).", takesEffect: "The next CLI-owned tmux invocation; restart the Controller for Controller-owned launches." },
+    { key: "tmux-history-limit", domain: "tools", property: "tmuxHistoryLimit", label: "Tmux history limit", summary: "History lines retained for newly created tmux sessions, 1000-1000000 (default: 100000).", takesEffect: "New tmux sessions; existing sessions report drift until recreated." },
+    { key: "telemetry-enabled", domain: "tools", property: "telemetryEnabled", label: "Diagnostic telemetry", summary: "Enable the optional SQLite diagnostic telemetry projection (default: false); requires a SQLite Home.", takesEffect: "Standalone telemetry commands immediately; scheduler writes after Controller restart." },
+    { key: "telemetry-terminal-keep", domain: "tools", property: "telemetryTerminalKeep", label: "Telemetry terminal keep", summary: "Positive-integer rows retained per terminal Run generation (default: 200).", takesEffect: "Explicit retention immediately; automatic retention after the Controller restarts." },
+    { key: "telemetry-run-cap", domain: "tools", property: "telemetryRunCap", label: "Telemetry Run cap", summary: `Positive-integer maximum rows retained per Run, at most ${MAX_RUN_CAP} (default: 50000).`, takesEffect: "Explicit retention immediately; automatic write-time capping after the Controller restarts." }
+]);
+export const CONFIG_KEYS = Object.freeze(CONFIG_DEFINITIONS.map(({ key }) => key));
+export function configDefinitionsForDomain(domain) {
+    return CONFIG_DEFINITIONS.filter((definition) => definition.domain === domain);
+}
+export function configDefinition(key) {
+    return CONFIG_DEFINITIONS.find((definition) => definition.key === key);
+}

package/dist/config/yuiConfig.js

@@ -1,10 +1,13 @@
 import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
-import { PROVIDER_RETRY_MAX_WINDOW_MS } from "../run/providerRetry.js";
-import { DEFAULT_RUN_CAP, DEFAULT_TELEMETRY_MODE, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_RUNTIME_HEALTH_POLICY } from "../runtime/runtimeHealthPolicy.js";
 export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 120;
 export const MIN_RECONCILIATION_INTERVAL_SECONDS = 5;
 export const MAX_RECONCILIATION_INTERVAL_SECONDS = 300;
 export const DEFAULT_RESOURCES_GC_MODE = "report";
+export const DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS = 24;
+export const MIN_RESOURCES_QUARANTINE_TTL_HOURS = 1;
+export const MAX_RESOURCES_QUARANTINE_TTL_HOURS = 720;
 /**
  * Resolves the Resource GC mode. `report` (default) only reports candidates;
  * `quarantine` allows `yui resources gc --apply` to quarantine releasable
@@ -29,6 +32,9 @@ export function resolveResourcesGcAutoQuarantine(value) {
         return value;
     throw new TypeError("resourcesGcAutoQuarantine must be a boolean.");
 }
+export function resolveResourcesQuarantineTtlHours(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, MIN_RESOURCES_QUARANTINE_TTL_HOURS, MAX_RESOURCES_QUARANTINE_TTL_HOURS, "resourcesQuarantineTtlHours");
+}
 /**
  * Resolves the durable Yui setting used for low-frequency recovery
  * reconciliation. Normal durable state changes wake the Controller through
@@ -72,6 +78,9 @@ export function resolveLeaderNextActionMode(value) {
 // ── Issue 01: Provider retry ──────────────────────────────────────────────
 export const PROVIDER_RETRY_MODES = ["off", "shadow", "enforce"];
 export const DEFAULT_PROVIDER_RETRY_MODE = "enforce";
+export const DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS = Object.freeze([2, 5, 15]);
+export const DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS = 600;
+export const MAX_PROVIDER_RETRY_ATTEMPTS = 10;
 export function resolveProviderRetryMode(value) {
     if (value === undefined || value === null)
         return DEFAULT_PROVIDER_RETRY_MODE;
@@ -122,21 +131,27 @@ export function resolveProviderRetryAdapters(value) {
     }
     return adapters;
 }
-export function resolveProviderRetryMaxWindowMs(value) {
+export function resolveProviderRetryDelaysSeconds(value) {
     if (value === undefined || value === null)
-        return PROVIDER_RETRY_MAX_WINDOW_MS;
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        throw new TypeError("providerRetryMaxWindowMs must be a positive integer.");
+        return [...DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS];
+    if (!Array.isArray(value) || value.length < 1 || value.length > MAX_PROVIDER_RETRY_ATTEMPTS) {
+        throw new TypeError(`providerRetryDelaysSeconds must contain 1-${MAX_PROVIDER_RETRY_ATTEMPTS} positive integers.`);
     }
-    return value;
-}
-export function resolveYieldReceiptReplay(value) {
-    if (value === undefined || value === null)
-        return true;
-    if (typeof value !== "boolean") {
-        throw new TypeError("yieldReceiptReplay must be a boolean.");
+    const delays = value.map((entry) => {
+        if (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 1 || entry > 600) {
+            throw new TypeError("providerRetryDelaysSeconds entries must be integers from 1 to 600.");
+        }
+        return entry;
+    });
+    for (let index = 1; index < delays.length; index += 1) {
+        if (delays[index] < delays[index - 1]) {
+            throw new TypeError("providerRetryDelaysSeconds must be ordered from shortest to longest.");
+        }
     }
-    return value;
+    return delays;
+}
+export function resolveProviderRetryMaxWindowSeconds(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, 1, Number.MAX_SAFE_INTEGER, "providerRetryMaxWindowSeconds");
 }
 // ── Executable paths ──────────────────────────────────────────────────────
 export function resolveTmuxBin(value) {
@@ -147,29 +162,13 @@ export function resolveTmuxBin(value) {
     }
     return value.trim();
 }
-export function resolveGitBin(value) {
-    if (value === undefined || value === null)
-        return "git";
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new TypeError("gitBin must be a non-empty string.");
-    }
-    return value.trim();
-}
 // ── Telemetry ─────────────────────────────────────────────────────────────
-const TELEMETRY_MODES = ["legacy", "dual", "bounded"];
-export function resolveTelemetryMode(value) {
+export function resolveTelemetryEnabled(value) {
     if (value === undefined || value === null)
-        return DEFAULT_TELEMETRY_MODE;
-    if (typeof value !== "string") {
-        throw new TypeError("telemetryMode must be legacy, dual, or bounded.");
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0)
-        return DEFAULT_TELEMETRY_MODE;
-    if (!TELEMETRY_MODES.includes(normalized)) {
-        throw new TypeError(`telemetryMode must be one of ${TELEMETRY_MODES.join(", ")}; got ${JSON.stringify(normalized)}.`);
-    }
-    return normalized;
+        return false;
+    if (typeof value !== "boolean")
+        throw new TypeError("telemetryEnabled must be a boolean.");
+    return value;
 }
 export function resolveTelemetryTerminalKeep(value) {
     if (value === undefined || value === null)
@@ -190,6 +189,43 @@ export function resolveTelemetryRunCap(value) {
     }
     return value;
 }
+// ── Runtime and workflow policy ───────────────────────────────────────────
+export const DEFAULT_CONTROLLER_TASK_CONCURRENCY = 4;
+export const MAX_CONTROLLER_TASK_CONCURRENCY = 32;
+export const DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS = 300;
+export const DEFAULT_DELIVERY_TIMEOUT_SECONDS = 120;
+export const DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS = 3;
+export const DEFAULT_TMUX_HISTORY_LIMIT = 100_000;
+export function resolveRuntimeHealth(configured) {
+    if (configured === undefined || configured === null)
+        return DEFAULT_RUNTIME_HEALTH_POLICY;
+    if (typeof configured !== "object" || Array.isArray(configured)) {
+        throw new TypeError("runtimeHealth must be an object.");
+    }
+    const value = configured;
+    const quietAfterMs = resolveBoundedPositiveInteger(value.quietAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.quietAfterMs / 1_000, 30, 86_400, "runtimeHealth.quietAfterSeconds") * 1_000;
+    const diagnosticAfterMs = resolveBoundedPositiveInteger(value.diagnosticAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.diagnosticAfterMs / 1_000, 30, 86_400, "runtimeHealth.diagnosticAfterSeconds") * 1_000;
+    const stallWindowMs = resolveBoundedPositiveInteger(value.stallAfterSeconds, DEFAULT_RUNTIME_HEALTH_POLICY.stallWindowMs / 1_000, 60, 604_800, "runtimeHealth.stallAfterSeconds") * 1_000;
+    if (!(quietAfterMs < diagnosticAfterMs && diagnosticAfterMs < stallWindowMs)) {
+        throw new TypeError("runtimeHealth thresholds must be ordered quietAfterSeconds < diagnosticAfterSeconds < stallAfterSeconds.");
+    }
+    return Object.freeze({ quietAfterMs, diagnosticAfterMs, stallWindowMs });
+}
+export function resolveControllerTaskConcurrency(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_CONTROLLER_TASK_CONCURRENCY, 1, MAX_CONTROLLER_TASK_CONCURRENCY, "controllerTaskConcurrency");
+}
+export function resolveAgentLaunchInactivityTimeoutSeconds(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, 15, 3_600, "agentLaunchInactivityTimeoutSeconds");
+}
+export function resolveDeliveryTimeoutSeconds(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_DELIVERY_TIMEOUT_SECONDS, 5, 600, "deliveryTimeoutSeconds");
+}
+export function resolveLeaderSemanticBudgetTurns(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, 1, 20, "leaderSemanticBudgetTurns");
+}
+export function resolveTmuxHistoryLimit(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");
+}
 /**
  * Issue 04 (context token budget): thresholds for one native Session
  * generation's observed per-request input peak, measured in tokens. When the
@@ -231,3 +267,12 @@ export function resolveContextBudget(configured) {
     }
     return { softTokens, hardTokens };
 }
+function resolveBoundedPositiveInteger(value, fallback, minimum, maximum, label) {
+    if (value === undefined || value === null)
+        return fallback;
+    if (typeof value !== "number" || !Number.isSafeInteger(value)
+        || value < minimum || value > maximum) {
+        throw new TypeError(`${label} must be an integer from ${minimum} to ${maximum}.`);
+    }
+    return value;
+}

package/dist/context/sessionBootstrapManifest.js

@@ -53,7 +53,7 @@ export function materializeSessionBootstrap(input) {
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
         contextProtocol: input.owner.scope === "global"
             ? {
-                loadCommand: `\"${sessionCliPath}\" role context \"$YUI_ROLE\" --json`
+                loadCommand: `\"${sessionCliPath}\" session context \"$YUI_ROLE\" --json`
             }
             : {
                 loadCommand: `\"${sessionCliPath}\" task run context \"$YUI_TASK_ID/<run-id>\" --json`,

package/dist/controller/clientRuntime.js

@@ -29,8 +29,6 @@ const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     // rr13/test: Forward the liveness seam so an integration test's Controller
     // subprocess does not reap a saved active Leader Run without a real tmux role.
     "YUI_TEST_ROLE_LIVENESS_PRESENT",
-    // Issue 02: agent-signal-driven launch monitoring is Controller-owned.
-    "YUI_LAUNCH_INACTIVITY_TIMEOUT_MS",
     ...EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES
 ];
 /**