@zq-silk/yui 0.7.0 → 0.8.1

package/dist/commands/configCommands.js

@@ -1,82 +1,97 @@
+import { mkdirSync, realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_CONTEXT_HARD_TOKENS, DEFAULT_CONTEXT_SOFT_TOKENS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_PROVIDER_RETRY_MODE, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, LEADER_NEXT_ACTION_MODES, PROVIDER_RETRY_MODES, reconciliationIntervalMilliseconds, resolveContextBudget, resolveGitBin, resolveLeaderNextActionMode, resolveProviderRetryAdapters, resolveProviderRetryMaxWindowMs, resolveProviderRetryMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveTelemetryMode, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveYieldReceiptReplay } from "../config/yuiConfig.js";
+import { DEFAULT_CONTEXT_HARD_TOKENS, DEFAULT_CONTEXT_SOFT_TOKENS, DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, DEFAULT_PROVIDER_RETRY_MODE, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, PROVIDER_RETRY_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveProviderRetryAdapters, resolveProviderRetryDelaysSeconds, resolveProviderRetryMaxWindowSeconds, resolveProviderRetryMode, 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 { defaultTableWidth, renderTable } from "../output/table.js";
 import { DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES, DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES, REVIEW_FINDING_LEDGER_MODES, REVIEW_DELTA_RECHECK_MODES, REVIEW_TRIGGERS } from "../review/reviewConfig.js";
 /**
- * One uniform key model for every durable Yui setting. `config show` displays
- * each key's effective value, `config set <key> <value...>` updates one key,
- * and `config clear <key>` resets it to its documented default. Strategy
- * settings such as `review` and `leader-next-action` are keys like any other;
- * they deliberately have no separate command trees. The stored YuiConfig
- * shape is unchanged, so existing Homes keep working without migration.
+ * 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.
  */
-export const CONFIG_KEYS = [
-    "time-zone",
-    "reconciliation-interval-seconds",
-    "leader-next-action",
-    "context-budget",
-    "resources-gc-mode",
-    "resources-gc-auto-quarantine",
-    "provider-retry-mode",
-    "provider-retry-adapters",
-    "provider-retry-max-window-ms",
-    "yield-receipt-replay",
-    "tmux-bin",
-    "git-bin",
-    "telemetry-mode",
-    "telemetry-terminal-keep",
-    "telemetry-run-cap",
-    "review"
-];
-const CONFIG_USAGE = "Config usage: yui config show | yui config set <key> <value...> | yui config clear <key>.";
-const CONFIG_SET_USAGE = `Config set usage: yui config set <key> <value...>; keys: ${CONFIG_KEYS.join(", ")}.`;
-const CONFIG_CLEAR_USAGE = `Config clear usage: yui config clear <key>; keys: ${CONFIG_KEYS.join(", ")}.`;
-const TIME_ZONE_SET_USAGE = "Config set usage: yui config set time-zone <IANA timezone>.";
-const RECONCILIATION_SET_USAGE = "Config set usage: yui config set reconciliation-interval-seconds <5-300>.";
-const RESOURCES_GC_MODE_SET_USAGE = "Config set usage: yui config set resources-gc-mode <report|quarantine>.";
-const RESOURCES_GC_AUTO_QUARANTINE_SET_USAGE = "Config set usage: yui config set resources-gc-auto-quarantine <true|false>.";
-const LEADER_NEXT_ACTION_SET_USAGE = `Config set usage: yui config set leader-next-action <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
-const CONTEXT_BUDGET_SET_USAGE = "Config set usage: yui config set context-budget [--soft-tokens <n>] [--hard-tokens <n>].";
-const REVIEW_SET_USAGE = "Config set usage: yui config set review --role <global-role> --trigger <always|leader|final> "
+export { CONFIG_KEYS } from "../config/configCatalog.js";
+const CONFIG_PROPERTIES = Object.fromEntries(CONFIG_DEFINITIONS.map(({ key, property }) => [
+    key,
+    property
+]));
+const TIME_ZONE_SET_USAGE = "System config set usage: yui config system set time-zone <IANA timezone>.";
+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 CONTEXT_BUDGET_SET_USAGE = "Workflow config set usage: yui config workflow set context-budget [--soft-tokens <n>] [--hard-tokens <n>].";
+const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final> "
     + "[--finding-ledger <shadow|enforce>] [--delta-recheck <enabled|disabled>] "
     + "[--delta-recheck-max-lines <n>] [--delta-recheck-max-files <n>].";
-export function runConfigCommand(args, store) {
+export function runConfigCommand(domain, args, store) {
+    const keys = configDefinitionsForDomain(domain).map(({ key }) => key);
+    const usage = `${capitalize(domain)} config usage: yui config ${domain} show | yui config ${domain} set <key> <value...> | yui config ${domain} clear <key>.`;
     const [command, ...rest] = args;
     if (command === "show") {
         if (rest.length !== 0)
-            throw usageError("Config show usage: yui config show.");
+            throw usageError(`${capitalize(domain)} config show usage: yui config ${domain} show.`);
         const config = store.getConfig();
         reconciliationIntervalMilliseconds(config.reconciliationIntervalSeconds);
-        return { output: renderConfigShow(config), data: effectiveConfigData(config) };
+        return { output: renderConfigShow(domain, config), data: effectiveConfigData(config, domain) };
     }
     if (command === "set")
-        return { output: runConfigSet(rest, store) };
+        return { output: runConfigSet(domain, keys, rest, store) };
     if (command === "clear")
-        return { output: runConfigClear(rest, store) };
-    throw usageError(command === undefined ? "Config command is required." : `Unknown command: config ${command}`, CONFIG_USAGE);
+        return { output: runConfigClear(domain, keys, rest, store) };
+    throw usageError(command === undefined ? `${capitalize(domain)} config command is required.` : `Unknown command: config ${domain} ${command}`, usage);
 }
 /**
- * `config show` is row/column data, so it renders through the shared
+ * A domain `show` is row/column data, so it renders through the shared
  * `renderTable` like every other list command. The column contract follows
  * the shared rules: left-aligned cells, widths fitted between min/max,
  * terminal width from `defaultTableWidth()`, and empty values as empty cells.
  */
-function renderConfigShow(config) {
-    return renderTable("Yui configuration", [
+function renderConfigShow(domain, config) {
+    return renderTable(`Yui ${domain} configuration`, [
         { header: "Setting", minWidth: 20, maxWidth: 32 },
         { header: "Value", minWidth: 10, maxWidth: 60 }
-    ], CONFIG_KEY_HANDLERS.map((handler) => [handler.showLabel, handler.showValue(config)]), defaultTableWidth());
+    ], CONFIG_KEY_HANDLERS
+        .filter(({ key }) => configDefinition(key)?.domain === domain)
+        .map((handler) => [handler.showLabel, handler.showValue(config)]), defaultTableWidth());
 }
-/** Effective values under the same field names as the stored YuiConfig. */
-function effectiveConfigData(config) {
-    return {
+/** Effective values for every user-configurable system field. */
+export function effectiveConfigData(config, domain) {
+    const budget = resolveContextBudget(config.contextBudget);
+    const health = resolveRuntimeHealth(config.runtimeHealth);
+    const all = {
+        schemaVersion: config.schemaVersion,
+        defaultAgent: config.defaultAgent ?? null,
+        defaultWorkspace: config.defaultWorkspace ?? null,
         timeZone: resolveTimeZone(config.timeZone),
+        currentTaskId: config.currentTaskId ?? null,
+        lastTaskId: config.lastTaskId ?? null,
         reconciliationIntervalSeconds: config.reconciliationIntervalSeconds
             ?? DEFAULT_RECONCILIATION_INTERVAL_SECONDS,
         leaderNextActionMode: resolveLeaderNextActionMode(config.leaderNextActionMode),
+        contextBudget: { softTokens: budget.softTokens, hardTokens: budget.hardTokens },
         resourcesGcMode: resolveResourcesGcMode(config.resourcesGcMode),
         resourcesGcAutoQuarantine: resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine),
+        resourcesQuarantineTtlHours: resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours),
+        providerRetryMode: resolveProviderRetryMode(config.providerRetryMode),
+        providerRetryAdapters: resolveProviderRetryAdapters(config.providerRetryAdapters),
+        providerRetryDelaysSeconds: resolveProviderRetryDelaysSeconds(config.providerRetryDelaysSeconds),
+        providerRetryMaxWindowSeconds: resolveProviderRetryMaxWindowSeconds(config.providerRetryMaxWindowSeconds),
+        runtimeHealth: {
+            quietAfterSeconds: health.quietAfterMs / 1_000,
+            diagnosticAfterSeconds: health.diagnosticAfterMs / 1_000,
+            stallAfterSeconds: health.stallWindowMs / 1_000
+        },
+        controllerTaskConcurrency: resolveControllerTaskConcurrency(config.controllerTaskConcurrency),
+        agentLaunchInactivityTimeoutSeconds: resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds),
+        deliveryTimeoutSeconds: resolveDeliveryTimeoutSeconds(config.deliveryTimeoutSeconds),
+        leaderSemanticBudgetTurns: resolveLeaderSemanticBudgetTurns(config.leaderSemanticBudgetTurns),
+        tmuxBin: resolveTmuxBin(config.tmuxBin),
+        tmuxHistoryLimit: resolveTmuxHistoryLimit(config.tmuxHistoryLimit),
+        telemetryEnabled: resolveTelemetryEnabled(config.telemetryEnabled),
+        telemetryTerminalKeep: resolveTelemetryTerminalKeep(config.telemetryTerminalKeep),
+        telemetryRunCap: resolveTelemetryRunCap(config.telemetryRunCap),
         review: config.review === undefined
             ? null
             : {
@@ -88,31 +103,48 @@ function effectiveConfigData(config) {
                     ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_LINES,
                 deltaRecheckMaxChangedFiles: config.review.deltaRecheckMaxChangedFiles
                     ?? DEFAULT_DELTA_RECHECK_MAX_CHANGED_FILES
-            }
+            },
+        completionInstallations: config.completionInstallations ?? {}
+    };
+    const definitions = configDefinitionsForDomain(domain);
+    return {
+        ...Object.fromEntries(definitions.map(({ property }) => [property, all[property]])),
+        valueSources: Object.fromEntries(definitions.map(({ key }) => {
+            const typedKey = key;
+            return [
+                key,
+                config[CONFIG_PROPERTIES[typedKey]] === undefined ? "default" : "stored"
+            ];
+        }))
     };
 }
-function runConfigSet(args, store) {
+function runConfigSet(domain, keys, args, store) {
     const [key, ...values] = args;
+    const usage = `${capitalize(domain)} config set usage: yui config ${domain} set <key> <value...>; keys: ${keys.join(", ")}.`;
     if (key === undefined)
-        throw usageError(CONFIG_SET_USAGE);
+        throw usageError(usage);
     const handler = CONFIG_KEY_HANDLERS.find((entry) => entry.key === key);
-    if (handler === undefined) {
-        throw usageError(`Unknown config key: ${key}`, CONFIG_SET_USAGE);
+    if (handler === undefined || !keys.includes(key)) {
+        throw usageError(`Unknown ${domain} config key: ${key}`, usage);
     }
     return handler.set(values, store);
 }
-function runConfigClear(args, store) {
+function runConfigClear(domain, keys, args, store) {
     const [key, ...rest] = args;
+    const usage = `${capitalize(domain)} config clear usage: yui config ${domain} clear <key>; keys: ${keys.join(", ")}.`;
     if (key === undefined)
-        throw usageError(CONFIG_CLEAR_USAGE);
+        throw usageError(usage);
     if (rest.length !== 0)
-        throw usageError(`Config clear usage: yui config clear ${key}.`);
+        throw usageError(`${capitalize(domain)} config clear usage: yui config ${domain} clear ${key}.`);
     const handler = CONFIG_KEY_HANDLERS.find((entry) => entry.key === key);
-    if (handler === undefined) {
-        throw usageError(`Unknown config key: ${key}`, CONFIG_CLEAR_USAGE);
+    if (handler === undefined || !keys.includes(key)) {
+        throw usageError(`Unknown ${domain} config key: ${key}`, usage);
     }
     return handler.clear(store);
 }
+function capitalize(value) {
+    return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
 function saveConfigKey(store, update) {
     store.transaction((tx) => {
         tx.saveConfig(update(tx.getConfig()));
@@ -152,6 +184,49 @@ function parsePositiveIntegerOption(value, usage) {
     return Number(value);
 }
 const CONFIG_KEY_HANDLERS = [
+    {
+        key: "default-agent",
+        showLabel: "Default Agent",
+        showValue: (config) => config.defaultAgent ?? "not configured",
+        set(args, store) {
+            if (args.length !== 1 || args[0].trim().length === 0) {
+                throw usageError("System config set usage: yui config system set default-agent <agent-id>.");
+            }
+            const defaultAgent = args[0].trim();
+            if (store.getConfiguredAgent?.(defaultAgent) === null) {
+                throw usageError(`Configured Agent not found: ${defaultAgent}.`);
+            }
+            saveConfigKey(store, (config) => ({ ...config, defaultAgent }));
+            return `Default Agent set to ${defaultAgent}\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { defaultAgent: _removed, ...rest } = config;
+                return rest;
+            });
+            return "Default Agent cleared\n";
+        }
+    },
+    {
+        key: "default-workspace",
+        showLabel: "Default workspace",
+        showValue: (config) => config.defaultWorkspace ?? "not configured",
+        set(args, store) {
+            if (args.length !== 1 || !isAbsolute(args[0])) {
+                throw usageError("System config set usage: yui config system set default-workspace <absolute-path>.");
+            }
+            const defaultWorkspace = resolveDefaultWorkspace(args[0], store);
+            saveConfigKey(store, (config) => ({ ...config, defaultWorkspace }));
+            return `Default workspace set to ${defaultWorkspace}\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { defaultWorkspace: _removed, ...rest } = config;
+                return rest;
+            });
+            return "Default workspace cleared\n";
+        }
+    },
     {
         key: "time-zone",
         showLabel: "Time zone",
@@ -216,6 +291,26 @@ const CONFIG_KEY_HANDLERS = [
             return `Leader next-action mode reset to ${DEFAULT_LEADER_NEXT_ACTION_MODE}\n`;
         }
     },
+    {
+        key: "leader-semantic-budget-turns",
+        showLabel: "Leader semantic budget",
+        showValue: (config) => `${resolveLeaderSemanticBudgetTurns(config.leaderSemanticBudgetTurns)} turns`,
+        set(args, store) {
+            const usage = "Workflow config set usage: yui config workflow set leader-semantic-budget-turns <1-20>.";
+            if (args.length !== 1)
+                throw usageError(usage);
+            const leaderSemanticBudgetTurns = validatedConfigValue(() => resolveLeaderSemanticBudgetTurns(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, leaderSemanticBudgetTurns }));
+            return `Leader semantic budget set to ${leaderSemanticBudgetTurns} turns\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { leaderSemanticBudgetTurns: _removed, ...rest } = config;
+                return rest;
+            });
+            return `Leader semantic budget reset to ${DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS} turns\n`;
+        }
+    },
     {
         key: "context-budget",
         showLabel: "Context budget",
@@ -296,14 +391,135 @@ const CONFIG_KEY_HANDLERS = [
             return "Resources GC auto-quarantine reset to off\n";
         }
     },
+    {
+        key: "resources-quarantine-ttl-hours",
+        showLabel: "Resource quarantine TTL",
+        showValue: (config) => `${resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours)} hours`,
+        set(args, store) {
+            const usage = "Resources config set usage: yui config resources set resources-quarantine-ttl-hours <1-720>.";
+            if (args.length !== 1)
+                throw usageError(usage);
+            const resourcesQuarantineTtlHours = validatedConfigValue(() => resolveResourcesQuarantineTtlHours(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, resourcesQuarantineTtlHours }));
+            return `Resource quarantine TTL set to ${resourcesQuarantineTtlHours} hours\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { resourcesQuarantineTtlHours: _removed, ...rest } = config;
+                return rest;
+            });
+            return `Resource quarantine TTL reset to ${DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS} hours\n`;
+        }
+    },
+    {
+        key: "controller-task-concurrency",
+        showLabel: "Controller Task concurrency",
+        showValue: (config) => String(resolveControllerTaskConcurrency(config.controllerTaskConcurrency)),
+        set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set controller-task-concurrency <1-32>.";
+            if (args.length !== 1)
+                throw usageError(usage);
+            const controllerTaskConcurrency = validatedConfigValue(() => resolveControllerTaskConcurrency(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, controllerTaskConcurrency }));
+            return `Controller Task concurrency set to ${controllerTaskConcurrency}\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { controllerTaskConcurrency: _removed, ...rest } = config;
+                return rest;
+            });
+            return `Controller Task concurrency reset to ${DEFAULT_CONTROLLER_TASK_CONCURRENCY}\n`;
+        }
+    },
+    {
+        key: "runtime-health",
+        showLabel: "Runtime health thresholds",
+        showValue: (config) => {
+            const health = resolveRuntimeHealth(config.runtimeHealth);
+            return `quiet ${health.quietAfterMs / 1_000}s / diagnostic ${health.diagnosticAfterMs / 1_000}s / stall ${health.stallWindowMs / 1_000}s`;
+        },
+        set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set runtime-health --quiet-after-seconds <n> --diagnostic-after-seconds <n> --stall-after-seconds <n>.";
+            if (args.length !== 6)
+                throw usageError(usage);
+            const options = new Map();
+            for (let index = 0; index < args.length; index += 2) {
+                const name = args[index];
+                const value = Number(args[index + 1]);
+                if (!["--quiet-after-seconds", "--diagnostic-after-seconds", "--stall-after-seconds"].includes(name)
+                    || options.has(name))
+                    throw usageError(usage);
+                options.set(name, value);
+            }
+            const resolved = validatedConfigValue(() => resolveRuntimeHealth({
+                quietAfterSeconds: options.get("--quiet-after-seconds"),
+                diagnosticAfterSeconds: options.get("--diagnostic-after-seconds"),
+                stallAfterSeconds: options.get("--stall-after-seconds")
+            }), usage);
+            const runtimeHealth = {
+                quietAfterSeconds: resolved.quietAfterMs / 1_000,
+                diagnosticAfterSeconds: resolved.diagnosticAfterMs / 1_000,
+                stallAfterSeconds: resolved.stallWindowMs / 1_000
+            };
+            saveConfigKey(store, (config) => ({ ...config, runtimeHealth }));
+            return `Runtime health thresholds set to quiet ${runtimeHealth.quietAfterSeconds}s / diagnostic ${runtimeHealth.diagnosticAfterSeconds}s / stall ${runtimeHealth.stallAfterSeconds}s\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { runtimeHealth: _removed, ...rest } = config;
+                return rest;
+            });
+            return "Runtime health thresholds reset to quiet 300s / diagnostic 600s / stall 1800s\n";
+        }
+    },
+    {
+        key: "agent-launch-inactivity-timeout-seconds",
+        showLabel: "Agent launch inactivity timeout",
+        showValue: (config) => `${resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds)} seconds`,
+        set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set agent-launch-inactivity-timeout-seconds <15-3600>.";
+            if (args.length !== 1)
+                throw usageError(usage);
+            const agentLaunchInactivityTimeoutSeconds = validatedConfigValue(() => resolveAgentLaunchInactivityTimeoutSeconds(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, agentLaunchInactivityTimeoutSeconds }));
+            return `Agent launch inactivity timeout set to ${agentLaunchInactivityTimeoutSeconds} seconds\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { agentLaunchInactivityTimeoutSeconds: _removed, ...rest } = config;
+                return rest;
+            });
+            return `Agent launch inactivity timeout reset to ${DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS} seconds\n`;
+        }
+    },
+    {
+        key: "delivery-timeout-seconds",
+        showLabel: "Delivery timeout",
+        showValue: (config) => `${resolveDeliveryTimeoutSeconds(config.deliveryTimeoutSeconds)} seconds`,
+        set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set delivery-timeout-seconds <5-600>.";
+            if (args.length !== 1)
+                throw usageError(usage);
+            const deliveryTimeoutSeconds = validatedConfigValue(() => resolveDeliveryTimeoutSeconds(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, deliveryTimeoutSeconds }));
+            return `Delivery timeout set to ${deliveryTimeoutSeconds} seconds\n`;
+        },
+        clear(store) {
+            saveConfigKey(store, (config) => {
+                const { deliveryTimeoutSeconds: _removed, ...rest } = config;
+                return rest;
+            });
+            return `Delivery timeout reset to ${DEFAULT_DELIVERY_TIMEOUT_SECONDS} seconds\n`;
+        }
+    },
     {
         key: "provider-retry-mode",
         showLabel: "Provider retry mode",
         showValue: (config) => resolveProviderRetryMode(config.providerRetryMode),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError(`Config set usage: yui config set provider-retry-mode <${PROVIDER_RETRY_MODES.join("|")}>.`);
-            const mode = validatedConfigValue(() => resolveProviderRetryMode(args[0]), `Config set usage: yui config set provider-retry-mode <${PROVIDER_RETRY_MODES.join("|")}>.`);
+                throw usageError(`Runtime config set usage: yui config runtime set provider-retry-mode <${PROVIDER_RETRY_MODES.join("|")}>.`);
+            const mode = validatedConfigValue(() => resolveProviderRetryMode(args[0]), `Runtime config set usage: yui config runtime set provider-retry-mode <${PROVIDER_RETRY_MODES.join("|")}>.`);
             saveConfigKey(store, (config) => ({ ...config, providerRetryMode: mode }));
             return `Provider retry mode set to ${mode}\n`;
         },
@@ -321,11 +537,11 @@ const CONFIG_KEY_HANDLERS = [
         showValue: (config) => resolveProviderRetryAdapters(config.providerRetryAdapters).join(", ") || "none",
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set provider-retry-adapters <all|claude,codex|off>.");
+                throw usageError("Runtime config set usage: yui config runtime set provider-retry-adapters <all|claude,codex|off>.");
             const raw = args[0].trim().toLowerCase();
             const adapters = raw === "off" || raw === "" || raw === "0"
                 ? []
-                : validatedConfigValue(() => resolveProviderRetryAdapters(raw.split(",")), "Config set usage: yui config set provider-retry-adapters <all|claude,codex|off>.");
+                : validatedConfigValue(() => resolveProviderRetryAdapters(raw.split(",")), "Runtime config set usage: yui config runtime set provider-retry-adapters <all|claude,codex|off>.");
             saveConfigKey(store, (config) => ({ ...config, providerRetryAdapters: adapters }));
             return `Provider retry adapters set to ${adapters.join(", ") || "none"}\n`;
         },
@@ -338,41 +554,43 @@ const CONFIG_KEY_HANDLERS = [
         }
     },
     {
-        key: "provider-retry-max-window-ms",
-        showLabel: "Provider retry max window",
-        showValue: (config) => `${resolveProviderRetryMaxWindowMs(config.providerRetryMaxWindowMs)} ms`,
+        key: "provider-retry-delays-seconds",
+        showLabel: "Provider retry delays",
+        showValue: (config) => `${resolveProviderRetryDelaysSeconds(config.providerRetryDelaysSeconds).join(", ")} seconds`,
         set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set provider-retry-delays-seconds <comma-separated-seconds>.";
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set provider-retry-max-window-ms <milliseconds>.");
-            const maxWindowMs = validatedConfigValue(() => resolveProviderRetryMaxWindowMs(Number(args[0])), "Config set usage: yui config set provider-retry-max-window-ms <milliseconds>.");
-            saveConfigKey(store, (config) => ({ ...config, providerRetryMaxWindowMs: maxWindowMs }));
-            return `Provider retry max window set to ${maxWindowMs} ms\n`;
+                throw usageError(usage);
+            const providerRetryDelaysSeconds = validatedConfigValue(() => resolveProviderRetryDelaysSeconds(args[0].split(",").map(Number)), usage);
+            saveConfigKey(store, (config) => ({ ...config, providerRetryDelaysSeconds }));
+            return `Provider retry delays set to ${providerRetryDelaysSeconds.join(", ")} seconds\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { providerRetryMaxWindowMs: _removed, ...rest } = config;
+                const { providerRetryDelaysSeconds: _removed, ...rest } = config;
                 return rest;
             });
-            return "Provider retry max window reset to default\n";
+            return `Provider retry delays reset to ${DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS.join(", ")} seconds\n`;
         }
     },
     {
-        key: "yield-receipt-replay",
-        showLabel: "Yield receipt replay",
-        showValue: (config) => (resolveYieldReceiptReplay(config.yieldReceiptReplay) ? "on" : "off"),
+        key: "provider-retry-max-window-seconds",
+        showLabel: "Provider retry max window",
+        showValue: (config) => `${resolveProviderRetryMaxWindowSeconds(config.providerRetryMaxWindowSeconds)} seconds`,
         set(args, store) {
+            const usage = "Runtime config set usage: yui config runtime set provider-retry-max-window-seconds <positive-seconds>.";
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set yield-receipt-replay <true|false>.");
-            const yieldReceiptReplay = validatedConfigValue(() => resolveYieldReceiptReplay(parseBooleanConfigValue(args[0])), "Config set usage: yui config set yield-receipt-replay <true|false>.");
-            saveConfigKey(store, (config) => ({ ...config, yieldReceiptReplay }));
-            return `Yield receipt replay set to ${yieldReceiptReplay ? "on" : "off"}\n`;
+                throw usageError(usage);
+            const providerRetryMaxWindowSeconds = validatedConfigValue(() => resolveProviderRetryMaxWindowSeconds(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, providerRetryMaxWindowSeconds }));
+            return `Provider retry max window set to ${providerRetryMaxWindowSeconds} seconds\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { yieldReceiptReplay: _removed, ...rest } = config;
+                const { providerRetryMaxWindowSeconds: _removed, ...rest } = config;
                 return rest;
             });
-            return "Yield receipt replay reset to on\n";
+            return `Provider retry max window reset to ${DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS} seconds\n`;
         }
     },
     {
@@ -381,8 +599,8 @@ const CONFIG_KEY_HANDLERS = [
         showValue: (config) => resolveTmuxBin(config.tmuxBin),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set tmux-bin <path>.");
-            const tmuxBin = validatedConfigValue(() => resolveTmuxBin(args[0]), "Config set usage: yui config set tmux-bin <path>.");
+                throw usageError("Tools config set usage: yui config tools set tmux-bin <path>.");
+            const tmuxBin = validatedConfigValue(() => resolveTmuxBin(args[0]), "Tools config set usage: yui config tools set tmux-bin <path>.");
             saveConfigKey(store, (config) => ({ ...config, tmuxBin }));
             return `Tmux bin set to ${tmuxBin}\n`;
         },
@@ -395,41 +613,43 @@ const CONFIG_KEY_HANDLERS = [
         }
     },
     {
-        key: "git-bin",
-        showLabel: "Git bin",
-        showValue: (config) => resolveGitBin(config.gitBin),
+        key: "tmux-history-limit",
+        showLabel: "Tmux history limit",
+        showValue: (config) => String(resolveTmuxHistoryLimit(config.tmuxHistoryLimit)),
         set(args, store) {
+            const usage = "Tools config set usage: yui config tools set tmux-history-limit <1000-1000000>.";
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set git-bin <path>.");
-            const gitBin = validatedConfigValue(() => resolveGitBin(args[0]), "Config set usage: yui config set git-bin <path>.");
-            saveConfigKey(store, (config) => ({ ...config, gitBin }));
-            return `Git bin set to ${gitBin}\n`;
+                throw usageError(usage);
+            const tmuxHistoryLimit = validatedConfigValue(() => resolveTmuxHistoryLimit(Number(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, tmuxHistoryLimit }));
+            return `Tmux history limit set to ${tmuxHistoryLimit}\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { gitBin: _removed, ...rest } = config;
+                const { tmuxHistoryLimit: _removed, ...rest } = config;
                 return rest;
             });
-            return "Git bin reset to git\n";
+            return `Tmux history limit reset to ${DEFAULT_TMUX_HISTORY_LIMIT}\n`;
         }
     },
     {
-        key: "telemetry-mode",
-        showLabel: "Telemetry mode",
-        showValue: (config) => resolveTelemetryMode(config.telemetryMode),
+        key: "telemetry-enabled",
+        showLabel: "Diagnostic telemetry",
+        showValue: (config) => (resolveTelemetryEnabled(config.telemetryEnabled) ? "on" : "off"),
         set(args, store) {
+            const usage = "Tools config set usage: yui config tools set telemetry-enabled <true|false>.";
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set telemetry-mode <legacy|dual|bounded>.");
-            const telemetryMode = validatedConfigValue(() => resolveTelemetryMode(args[0]), "Config set usage: yui config set telemetry-mode <legacy|dual|bounded>.");
-            saveConfigKey(store, (config) => ({ ...config, telemetryMode }));
-            return `Telemetry mode set to ${telemetryMode}\n`;
+                throw usageError(usage);
+            const telemetryEnabled = validatedConfigValue(() => resolveTelemetryEnabled(parseBooleanConfigValue(args[0])), usage);
+            saveConfigKey(store, (config) => ({ ...config, telemetryEnabled }));
+            return `Diagnostic telemetry set to ${telemetryEnabled ? "on" : "off"}\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { telemetryMode: _removed, ...rest } = config;
+                const { telemetryEnabled: _removed, ...rest } = config;
                 return rest;
             });
-            return "Telemetry mode reset to legacy\n";
+            return "Diagnostic telemetry reset to off\n";
         }
     },
     {
@@ -438,8 +658,8 @@ const CONFIG_KEY_HANDLERS = [
         showValue: (config) => String(resolveTelemetryTerminalKeep(config.telemetryTerminalKeep)),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set telemetry-terminal-keep <n>.");
-            const telemetryTerminalKeep = validatedConfigValue(() => resolveTelemetryTerminalKeep(Number(args[0])), "Config set usage: yui config set telemetry-terminal-keep <n>.");
+                throw usageError("Tools config set usage: yui config tools set telemetry-terminal-keep <n>.");
+            const telemetryTerminalKeep = validatedConfigValue(() => resolveTelemetryTerminalKeep(Number(args[0])), "Tools config set usage: yui config tools set telemetry-terminal-keep <n>.");
             saveConfigKey(store, (config) => ({ ...config, telemetryTerminalKeep }));
             return `Telemetry terminal keep set to ${telemetryTerminalKeep}\n`;
         },
@@ -457,8 +677,8 @@ const CONFIG_KEY_HANDLERS = [
         showValue: (config) => String(resolveTelemetryRunCap(config.telemetryRunCap)),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Config set usage: yui config set telemetry-run-cap <n>.");
-            const telemetryRunCap = validatedConfigValue(() => resolveTelemetryRunCap(Number(args[0])), "Config set usage: yui config set telemetry-run-cap <n>.");
+                throw usageError("Tools config set usage: yui config tools set telemetry-run-cap <n>.");
+            const telemetryRunCap = validatedConfigValue(() => resolveTelemetryRunCap(Number(args[0])), "Tools config set usage: yui config tools set telemetry-run-cap <n>.");
             saveConfigKey(store, (config) => ({ ...config, telemetryRunCap }));
             return `Telemetry run cap set to ${telemetryRunCap}\n`;
         },
@@ -548,3 +768,30 @@ const CONFIG_KEY_HANDLERS = [
         }
     }
 ];
+const configuredHandlerKeys = new Set(CONFIG_KEY_HANDLERS.map(({ key }) => key));
+const missingConfigHandlers = CONFIG_KEYS.filter((key) => !configuredHandlerKeys.has(key));
+const duplicateConfigHandlers = CONFIG_KEY_HANDLERS
+    .map(({ key }) => key)
+    .filter((key, index, keys) => keys.indexOf(key) !== index);
+if (missingConfigHandlers.length > 0 || duplicateConfigHandlers.length > 0) {
+    throw new Error(`Config handler/catalog drift: missing=${missingConfigHandlers.join(",") || "none"}; `
+        + `duplicate=${duplicateConfigHandlers.join(",") || "none"}.`);
+}
+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 });
+    const workspace = realpathSync(requested);
+    const home = realpathSync(requestedHome);
+    assertWorkspaceOutsideHome(workspace, home);
+    return workspace;
+}
+function assertWorkspaceOutsideHome(workspace, home) {
+    const fromHome = relative(home, workspace);
+    if (fromHome === "" || (!fromHome.startsWith("..") && !isAbsolute(fromHome))) {
+        throw usageError("Default workspace must be outside YUI_HOME.");
+    }
+}