@zq-silk/yui 0.7.1 → 0.8.2

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

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { createRunAssignment } from "../context/runContextContract.js";
 import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -7,7 +7,8 @@ import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageErr
 import { createTaskEvent } from "../event/taskEvent.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { readCommandText } from "./textInput.js";
-import { createRoleSessionSet, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
+import { createRoleSessionSet, roleAgentSessionResumeMode, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { currentProviderActivation, transferProviderAuthority } from "../runtime/providerRuntimeIdentity.js";
 import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
@@ -16,11 +17,10 @@ import { createTaskMessage, taskMessageAuthorLabel } from "../message/message.js
 import { cancelInputRequest } from "../input/inputRequest.js";
 import { recoverExactAgentRun, terminalizeExactTaskRun, validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
 import { resetTaskRoleSessionGeneration } from "../lifecycle/taskRoleSessionReset.js";
-import { activeRoleAgentBinding, copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
+import { copyGlobalRoleToTaskRole, createRole, createRoleAgentBinding, switchActiveRoleAgent, unbindRoleAgent, updateRole, updateRoleStatus } from "../role/role.js";
 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";
@@ -241,7 +241,6 @@ export function runTaskCommand(args, store, options = {}) {
         case "milestone": return taskMilestoneCommand(rest, store, options);
         case "event": return taskEventCommand(rest, store);
         case "continuation": return taskContinuationCommand(rest, store);
-        case "enter": return enterTaskRoleAlias(rest, store, options);
         default:
             throw usageError(command === undefined
                 ? "Task command is required."
@@ -430,8 +429,8 @@ function updateTaskCommand(args, store, options) {
 /** Compatibility helper for call sites that cannot yet handle foreground enter. */
 export function runTaskOutputCommand(args, store, options = {}) {
     const execution = runTaskCommand(args, store, options);
-    if (execution.kind === "enter") {
-        throw runtimeError("Task role enter requires foreground tmux handoff by the CLI.");
+    if (execution.kind !== "output") {
+        throw runtimeError("Task Role foreground runtime control requires the CLI.");
     }
     return execution.output;
 }
@@ -1193,8 +1192,12 @@ function taskRoleCommand(args, store, options) {
         return output(unbindTaskRole(rest, store, options));
     if (command === "reset")
         return resetTaskRole(rest, store, options);
-    if (command === "enter")
-        return enterTaskRole(rest, store, options);
+    if (command === "view")
+        return viewTaskRole(rest, store);
+    if (command === "takeover")
+        return transferTaskRoleAuthority(rest, store, options, "takeover");
+    if (command === "release")
+        return transferTaskRoleAuthority(rest, store, options, "release");
     throw usageError(command === undefined
         ? "Task role command is required."
         : `Unknown command: task role ${command}`);
@@ -1507,60 +1510,111 @@ function unbindTaskRole(args, store, options) {
     });
     return `Unbound Agent ${args[2]} from ${result.taskId}/${result.name}\n`;
 }
-function enterTaskRole(args, store, _options) {
-    const usage = "Task role enter usage: yui task role enter <task> <role> "
-        + "[--read-only | --read-write].";
-    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
-    exactPositionals(parsed.positionals, 2, usage);
-    if (parsed.options.has("--read-only") && parsed.options.has("--read-write")) {
-        throw usageError("--read-only and --read-write are mutually exclusive.", usage);
-    }
-    const task = requireTask(store, parsed.positionals[0]);
+function viewTaskRole(args, store) {
+    const usage = "Task role view usage: yui task role view <task> <role>.";
+    exactPositionals(args, 2, usage);
+    const task = requireTask(store, args[0]);
     if (task.status !== "active") {
-        throw usageError(inactiveTaskMessage(task, "entering a role session"));
+        throw usageError(inactiveTaskMessage(task, "viewing a role session"));
     }
-    const role = requireRole(store, task.id, parsed.positionals[1]);
-    const access = parsed.options.has("--read-write") ? "read-write" : "read-only";
-    if (access === "read-write") {
-        assertTaskRoleWritableAttachAvailable(store, task.id, role.name);
+    const role = requireRole(store, task.id, args[1]);
+    const session = store.getRoleSession(task.id, role.name);
+    if (session === null || session.status === "stopped" || session.status === "broken") {
+        throw usageError(`Task Role has no live Provider view: ${task.id}/${role.name}.`);
     }
     return {
-        kind: "enter",
+        kind: "view",
         taskId: task.id,
         roleName: role.name,
-        access,
-        output: `Attaching to ${role.name} for ${task.id} (${access})\n`
+        access: "read-only",
+        output: `Viewing ${role.name} for ${task.id} (read-only)\n`
     };
 }
-/** Re-run after the tmux writer lease exists to close attach/launch races. */
-export function assertTaskRoleWritableAttachAvailable(store, taskId, roleName, options = {}) {
-    const role = requireRole(store, taskId, roleName);
-    if (store.getActiveAgentRun(taskId, roleName) !== null) {
-        throw usageError(`Role has an active managed Run; writable attach is unavailable: ${taskId}/${roleName}.`);
-    }
-    const session = store.getRoleSession(taskId, roleName);
-    if (activeRoleAgentBinding(role).adapterId === "claude"
-        && ((session !== null
-            && session.status !== "stopped"
-            && session.status !== "broken")
-            || options.isManagedProcessRunning?.() === true)) {
-        throw usageError(`A managed Claude process is still running; writable attach is unavailable: ${taskId}/${roleName}.`);
-    }
-}
-function enterTaskRoleAlias(args, store, options) {
-    const usage = "Task enter usage: yui task enter <task> [role] "
-        + "[--read-only | --read-write].";
-    const parsed = parseTail(args, new Set(), usage, new Set(["--read-only", "--read-write"]));
-    if (parsed.positionals.length < 1 || parsed.positionals.length > 2
-        || parsed.positionals.some((value) => value.trim().length === 0)) {
-        throw usageError(usage);
+function transferTaskRoleAuthority(args, store, options, action) {
+    const usage = `Task role ${action} usage: yui task role ${action} <task> <role>.`;
+    exactPositionals(args, 2, usage);
+    const now = clock(options);
+    try {
+        return store.transaction((tx) => {
+            const task = requireTask(tx, args[0]);
+            if (task.status !== "active") {
+                throw usageError(inactiveTaskMessage(task, `${action} Provider authority`));
+            }
+            const role = requireRole(tx, task.id, args[1]);
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            const session = sessions?.sessions[role.activeAgentId];
+            const binding = sessions?.providerBinding;
+            if (sessions === null || sessions === undefined || session === undefined
+                || binding === null || binding === undefined
+                || session.launchId === undefined
+                || session.status === "stopped" || session.status === "broken") {
+                throw new Error(`Task Role has no live managed Provider: ${task.id}/${role.name}.`);
+            }
+            const activation = currentProviderActivation(binding);
+            if (activation === null) {
+                throw new Error(`Provider Activation is not live: ${task.id}/${role.name}.`);
+            }
+            if (action === "takeover") {
+                const activeRun = tx.getActiveAgentRun(task.id, role.name);
+                if (sessions.inFlight === null || activeRun?.id !== sessions.inFlight.runId) {
+                    throw new Error(`Task Role has no active managed Run for takeover: ${task.id}/${role.name}.`);
+                }
+            }
+            if (action === "takeover"
+                && binding.authority.owner !== "controller"
+                && binding.authority.owner !== "human") {
+                throw new Error(`Provider authority is not Controller-owned: ${task.id}/${role.name}.`);
+            }
+            if (action === "release"
+                && binding.authority.owner !== "human"
+                && binding.authority.owner !== "controller") {
+                throw new Error(`Provider authority is not human-owned: ${task.id}/${role.name}.`);
+            }
+            const desiredOwner = action === "takeover" ? "human" : "controller";
+            const unchanged = binding.authority.owner === desiredOwner;
+            const updatedBinding = unchanged
+                ? binding
+                : transferProviderAuthority(binding, {
+                    expectedEpoch: binding.authority.epoch,
+                    expectedOwner: binding.authority.owner,
+                    owner: desiredOwner,
+                    holderId: action === "takeover" ? `human:${randomUUID()}` : activation.activationId,
+                    changedAt: now.toISOString()
+                });
+            const authority = updatedBinding.authority;
+            if (authority.owner !== "controller" && authority.owner !== "human") {
+                throw new Error("Provider authority transfer did not produce a writer.");
+            }
+            if (!unchanged) {
+                tx.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updatedBinding, now));
+                recordTaskEvent(tx, task.id, "runtime.provider-authority-transferred", {
+                    role: role.name,
+                    owner: authority.owner,
+                    holderId: authority.holderId,
+                    epoch: String(authority.epoch)
+                }, now);
+            }
+            return {
+                kind: "authority",
+                action,
+                taskId: task.id,
+                roleName: role.name,
+                launchId: session.launchId,
+                nativeSessionId: session.nativeSessionId,
+                authority: {
+                    epoch: authority.epoch,
+                    owner: authority.owner,
+                    holderId: authority.holderId
+                },
+                output: action === "takeover"
+                    ? `Human authority ${unchanged ? "replayed" : "acquired"} for ${task.id}/${role.name} at epoch ${authority.epoch}.\n`
+                    : `Controller authority ${unchanged ? "replayed" : "restored"} for ${task.id}/${role.name} at epoch ${authority.epoch}.\n`
+            };
+        });
+    }
+    catch (error) {
+        throw usageError(messageOf(error), usage);
     }
-    return enterTaskRole([
-        parsed.positionals[0],
-        parsed.positionals[1] ?? LEADER_ROLE,
-        ...(parsed.options.has("--read-only") ? ["--read-only"] : []),
-        ...(parsed.options.has("--read-write") ? ["--read-write"] : [])
-    ], store, options);
 }
 function taskWorkCommand(args, store, options) {
     const [command, ...rest] = args;
@@ -2840,7 +2894,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 +4488,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 +4544,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);
+}