@zq-silk/yui 0.13.8 → 0.13.9

package/README.md

@@ -48,7 +48,7 @@ behavior, then apply only changes the user confirms.
 
 Durable settings are grouped by responsibility: `config system` for Home
 defaults and presentation, `config runtime` for Controller health, concurrency,
-launch, delivery, and Provider retry, `config workflow` for Leader/context/review
+launch, and delivery mechanics, `config workflow` for Leader/context/review
 policy, `config resources` for quarantine and GC, and `config tools` for tmux
 and diagnostic telemetry. Configured Agents, global Roles, Profiles, and shell
 completion remain the sibling `config agent|role|profile|completion` domains.
@@ -892,8 +892,9 @@ creates a fresh proxy attachment.
 If the proxy disconnects, the Host may attach a bounded replacement client and
 reconcile the exact owned Turn from native history. A failed fresh attachment
 is released instead of becoming a cleanup prerequisite for later Runs.
-Claude Code keeps its independent stream-json process with exact
-user-message replay acknowledgement. A timeout or uncertain write becomes
+Claude Code keeps its independent stream-json process. Agent Host is the sole
+writer to that process, so a completed stream write accepts the Turn; the
+later provider `result` event settles it. An uncertain write becomes
 `delivery-unknown` and is never automatically retried.
 
 Task Role observation and takeover are explicit:
@@ -912,11 +913,11 @@ backpressure for Yui rather than a failed Run.
 AgentRun is the only durable Role scheduling state. Conversation state does not
 carry a second current-Run pointer; each Provider Turn records a Run id only to
 correlate its receipt and terminal event. If an Agent finishes a Yui Run before
-the native Turn terminal arrives, the next mailbox batch may already become a
-new AgentRun, but Agent Host keeps its input pending and submits it only after
-the old Turn settles. TaskRole itself stores identity and desired launch
-configuration, not runtime status; Role status shown by CLI/Web is derived from
-the active AgentRun plus Session/Driver lifecycle facts.
+the native Turn terminal arrives, the next mailbox intent remains pending until
+that Turn settles. Yui then claims the new AgentRun and submits it through the
+same Session. TaskRole itself stores identity and desired launch configuration,
+not runtime status; Role status shown by CLI/Web is derived from the active
+AgentRun plus Session/Driver lifecycle facts.
 
 Global Operator and global Role sessions remain native interactive CLIs:
 

package/dist/cli/commandCatalog.js

@@ -48,7 +48,7 @@ const CONFIG_KEY_VALUES = CONFIG_DEFINITIONS.map((definition) => ({
 }));
 const CONFIG_DOMAIN_SUMMARIES = {
     system: "Configure Home-wide defaults and human-facing presentation.",
-    runtime: "Configure Controller recovery, concurrency, health, launch, delivery, and Provider retry policy.",
+    runtime: "Configure Controller recovery, concurrency, health, launch, and delivery mechanics.",
     workflow: "Configure Leader convergence, context, and optional review policy.",
     resources: "Configure resource garbage collection and quarantine policy.",
     tools: "Configure tmux and optional diagnostic telemetry."
@@ -559,7 +559,7 @@ const taskChildren = [
         summary: "Manage Roles within a Task.",
         sections: [{ id: "manage", title: "Commands", entries: [
                     "add", "list", "status", "show", "update", "remove", "bind", "unbind",
-                    "view", "takeover", "release"
+                    "session", "view", "takeover", "release"
                 ] }],
         children: [
             {
@@ -587,6 +587,25 @@ const taskChildren = [
             { name: "remove", summary: "Remove a Task Role.", usage: "yui task role remove <task> <role>" },
             { name: "bind", summary: "Bind and activate an Agent for a Task Role.", usage: "yui task role bind <task> <role> <agent-id>" },
             { name: "unbind", summary: "Unbind a dormant Agent from a Task Role.", usage: "yui task role unbind <task> <role> <agent-id>" },
+            {
+                name: "session",
+                summary: "Inspect or stop one Task Role's native Session.",
+                executable: true,
+                sections: [{ id: "manage", title: "Commands", entries: ["inspect", "stop"] }],
+                children: [
+                    {
+                        name: "inspect",
+                        summary: "Read the current Session, Host activation, and Turn facts.",
+                        usage: "yui task role session inspect <task> <role>"
+                    },
+                    {
+                        name: "stop",
+                        summary: "Stop one idle Session and its exact Host activation.",
+                        usage: "yui task role session stop <task> <role> --reason <text>",
+                        options: ["--reason"]
+                    }
+                ]
+            },
             {
                 name: "view",
                 summary: "Attach read-only to an independent Provider presentation surface.",

package/dist/cli.js

@@ -366,7 +366,16 @@ export async function main() {
             return;
         }
         if (args[1] === "runtime-hook" && args.length === 2) {
-            await runRuntimeObservationHookCommand(readFileSync(0, "utf8"), process.env);
+            // Provider lifecycle Hooks are observation channels, never execution
+            // gates. A late/stale Hook must not make Claude reject an otherwise
+            // valid Session or Turn; its exact fence is revalidated before any
+            // inbox fact is written, so dropping an invalid observation is safe.
+            try {
+                await runRuntimeObservationHookCommand(readFileSync(0, "utf8"), process.env);
+            }
+            catch {
+                return;
+            }
             return;
         }
         throw usageError("Internal lifecycle callback usage is invalid.");
@@ -1402,6 +1411,30 @@ export async function main() {
             if (jsonOutput) {
                 throw usageError("Task Role view/takeover requires an interactive terminal.");
             }
+            if (result.kind === "session-stop") {
+                await ensureFileTaskController(home, { environment: process.env });
+                try {
+                    await runtime.stopExactTaskRoleSession({
+                        taskId: result.taskId,
+                        roleName: result.roleName,
+                        agentId: result.agentId,
+                        adapterId: result.adapterId,
+                        nativeSessionId: result.nativeSessionId,
+                        ...(result.launchId === undefined ? {} : { launchId: result.launchId }),
+                        sessionUpdatedAt: result.sessionUpdatedAt
+                    });
+                }
+                catch (error) {
+                    throw runtimeError(`Session stop was requested but physical Host cleanup did not complete: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                emit(result.output, false, {
+                    taskId: result.taskId,
+                    roleName: result.roleName,
+                    stopped: true,
+                    reason: result.reason
+                });
+                return;
+            }
             if (result.kind === "view") {
                 if (result.output !== undefined)
                     emit(result.output);
@@ -1604,17 +1637,14 @@ async function preflightManagedTaskControlPlane() {
         && process.env.YUI_DRIVER_ID !== undefined
         ? builtinAgentDriverRegistry().require(process.env.YUI_DRIVER_ID)
         : undefined;
-    const preallocatedDriverCallback = runtimeDriverCallback
-        ?.capabilities.observation.sessionBootstrap === "preallocated";
     const verifiedStore = openCompatibleFileTaskStore(control.yuiHome);
-    assertExactTaskRuntimeState(runtime, verifiedStore, preallocatedDriverCallback
-        ? {
-            preallocatedDriverSessionReservation: {
-                yuiHome: control.yuiHome,
-                adapterId: runtimeDriverCallback.adapterId
-            }
-        }
-        : {});
+    // Runtime Hooks have their own event-aware fence, including the valid case
+    // where a Provider terminal arrives after its Yui Run has yielded and a
+    // later wake is pending. Ordinary managed commands still require the exact
+    // current mutable runtime before routing.
+    if (runtimeDriverCallback === undefined) {
+        assertExactTaskRuntimeState(runtime, verifiedStore);
+    }
     const request = taskFinalReviewInvocation.request;
     if (request === undefined) {
         return {
@@ -2334,8 +2364,7 @@ async function executeOperatorSessionControl(control, home, store, runtime, tmux
     await ensureFileTaskController(home, { environment: process.env });
     if (paneRunning
         || (active !== undefined
-            && active.status !== "stopped"
-            && active.status !== "broken")) {
+            && active.status === "active")) {
         await runtime.stopGlobalRoleSession(role.name);
     }
     applyOperatorSessionControl(control, store);

package/dist/commands/agentCommands.js

@@ -244,7 +244,7 @@ function findNonStoppedSessionReference(store, agentId) {
 }
 function sessionReference(set, agentId, reference) {
     const session = set.sessions[agentId];
-    if (session === undefined || session.status === "stopped")
+    if (session === undefined || session.status === "ended")
         return null;
     return { ...reference, status: session.status };
 }

package/dist/commands/configCommands.js

@@ -1,7 +1,7 @@
 import { mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_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 { 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_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, 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";
@@ -73,10 +73,6 @@ export function effectiveConfigData(config, domain) {
         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,
@@ -498,87 +494,6 @@ const CONFIG_KEY_HANDLERS = [
             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(`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`;
-        },
-        clear(store) {
-            saveConfigKey(store, (config) => {
-                const { providerRetryMode: _removed, ...rest } = config;
-                return rest;
-            });
-            return `Provider retry mode reset to ${DEFAULT_PROVIDER_RETRY_MODE}\n`;
-        }
-    },
-    {
-        key: "provider-retry-adapters",
-        showLabel: "Provider retry adapters",
-        showValue: (config) => resolveProviderRetryAdapters(config.providerRetryAdapters).join(", ") || "none",
-        set(args, store) {
-            if (args.length !== 1)
-                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(",")), "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`;
-        },
-        clear(store) {
-            saveConfigKey(store, (config) => {
-                const { providerRetryAdapters: _removed, ...rest } = config;
-                return rest;
-            });
-            return "Provider retry adapters reset to all supported\n";
-        }
-    },
-    {
-        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(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 { providerRetryDelaysSeconds: _removed, ...rest } = config;
-                return rest;
-            });
-            return `Provider retry delays reset to ${DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS.join(", ")} seconds\n`;
-        }
-    },
-    {
-        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(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 { providerRetryMaxWindowSeconds: _removed, ...rest } = config;
-                return rest;
-            });
-            return `Provider retry max window reset to ${DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS} seconds\n`;
-        }
-    },
     {
         key: "tmux-bin",
         showLabel: "Tmux bin",

package/dist/commands/executionAuditCommands.js

@@ -183,29 +183,30 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("events", report));
     }
-    if (report.providerRetries.status === "ok" && report.providerRetries.data !== undefined) {
-        const retries = report.providerRetries.data;
-        if (retries.total > 0) {
-            lines.push("", `Provider retries: ${retries.total} run(s) retried in place · ${retries.terminal} terminal`);
-            lines.push(renderTable("Provider retry lineages", [
+    if (report.agentErrors.status === "ok" && report.agentErrors.data !== undefined) {
+        const errors = report.agentErrors.data;
+        if (errors.total > 0) {
+            lines.push("", `Agent errors: ${errors.total} · ${Object.entries(errors.byCategory)
+                .map(([category, count]) => `${category}:${count}`).join(", ")}`);
+            lines.push(renderTable("Agent errors", [
                 { header: "Task", minWidth: 8, maxWidth: 14 },
                 { header: "Run", minWidth: 14, maxWidth: 24 },
                 { header: "Role", minWidth: 8, maxWidth: 12 },
-                { header: "Attempts", minWidth: 8, maxWidth: 10 },
-                { header: "Error class", minWidth: 14, maxWidth: 24 },
-                { header: "Decision", minWidth: 14, maxWidth: 26 }
-            ], retries.entries.map((entry) => [
+                { header: "Category", minWidth: 12, maxWidth: 20 },
+                { header: "Code", minWidth: 16, maxWidth: 32 },
+                { header: "Session", minWidth: 12, maxWidth: 16 }
+            ], errors.entries.map((entry) => [
                 entry.taskId,
                 entry.runId,
                 entry.roleName,
-                String(entry.attempts),
-                entry.errorClass,
-                entry.decision
+                entry.category,
+                entry.code,
+                entry.sessionDisposition
             ]), width));
         }
     }
     else {
-        lines.push("", ...sectionError("providerRetries", report));
+        lines.push("", ...sectionError("agentErrors", report));
     }
     if (report.workItems.status === "ok" && report.workItems.data !== undefined) {
         const items = report.workItems.data;
@@ -257,8 +258,8 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
         const versions = Object.entries(runtime.contextProtocolVersions)
             .map(([version, count]) => `${version}:${count}`)
             .join(", ") || "none";
-        const retryStates = Object.entries(runtime.activeRetryStates)
-            .map(([state, count]) => `${state}:${count}`)
+        const errorCategories = Object.entries(runtime.agentErrorCategories)
+            .map(([category, count]) => `${category}:${count}`)
             .join(", ") || "none";
         const exits = Object.entries(runtime.processExitClassifications)
             .map(([classification, count]) => `${classification}:${count}`)
@@ -266,7 +267,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
         const usage = Object.entries(runtime.usageSemantics)
             .map(([semantics, count]) => `${semantics}:${count}`)
             .join(", ") || "none";
-        lines.push("", `Runtime protocol: context versions ${versions} · manifest compatibility identities ${runtime.manifestCompatibilityDigests}`, `Active retry: ${runtime.activeRetryEpisodes} episode(s) [${retryStates}] · failures ${runtime.activeConsecutiveFailures} · dispatched ${runtime.activeDispatchedRetries}`, `Retry audit: ${runtime.retryClassifiedEvents} classified · ${runtime.retryDispatchedEvents} dispatched · ${runtime.retryRecoveredEvents} recovered · ${runtime.retryExhaustedEvents} exhausted`, `Process exits: ${runtime.processExitObservations} [${exits}] · capacity failures ${runtime.contextCapacityFailures}`, `Context telemetry: usage [${usage}] · native compaction events ${runtime.compactionEvents}`);
+        lines.push("", `Runtime protocol: context versions ${versions} · manifest compatibility identities ${runtime.manifestCompatibilityDigests}`, `Agent errors: ${runtime.agentErrors} [${errorCategories}]`, `Process exits: ${runtime.processExitObservations} [${exits}] · capacity failures ${runtime.contextCapacityFailures}`, `Context telemetry: usage [${usage}] · native compaction events ${runtime.compactionEvents}`);
     }
     else {
         lines.push("", ...sectionError("runtimeProtocol", report));

package/dist/commands/globalRoleCommands.js

@@ -247,7 +247,7 @@ function bindRole(args, store) {
             const switched = switchActiveRoleAgent(withBinding, existingSet ?? createRoleSessionSet({ scope: "global", roleName: name }, role.activeAgentId, now), agentId, {
                 activeRun: false,
                 nativeProcessRunning: activeSession !== undefined
-                    && activeSession.status !== "stopped"
+                    && activeSession.status === "active"
             }, now);
             tx.saveGlobalRoleWithSessionSet(switched.role, switched.sessions);
             return { message: `Bound role ${name} to ${agentId}`, role: switched.role };
@@ -271,7 +271,7 @@ function removeRole(args, store) {
             roleName: role.name
         }, "removal");
         const sessions = tx.getGlobalRoleSessionSet(name);
-        if (Object.values(sessions?.sessions ?? {}).some(({ status }) => status !== "stopped")) {
+        if (Object.values(sessions?.sessions ?? {}).some(({ status }) => status === "active")) {
             throw usageError(`GlobalRole is active and cannot be removed: ${name}.`);
         }
         if (!tx.removeGlobalRole(name))
@@ -336,7 +336,7 @@ function roleSession(args, store, options) {
             adapterId: binding.adapterId,
             nativeSessionId,
             policy: "fixed",
-            status: environment.YUI_ROLE === name ? "running" : "ready",
+            status: "active",
             effective: resolveEffectiveLaunch({ role, purpose: "execution" })
         };
         if (command === "record") {
@@ -349,7 +349,7 @@ function roleSession(args, store, options) {
         if (existing === null) {
             throw usageError("Native session replacement requires an existing native session.");
         }
-        if (existing.status !== "stopped") {
+        if (existing.status !== "ended") {
             throw usageError("Native session replacement is blocked while the native Agent process is running.");
         }
         if (existing.nativeSessionId === nativeSessionId) {

package/dist/commands/sessionCommands.js

@@ -75,16 +75,12 @@ function blockedSessions(input) {
             return [];
         return [{
                 session,
-                reason: session.status === "running"
-                    ? "running"
-                    : "runtime-work-pending"
+                reason: "runtime-work-pending"
             }];
     });
 }
 function blockedStopResult(blocked) {
-    const details = blocked.map(({ session, reason }) => (`- ${renderSessionOwner(session)} (${reason === "running"
-        ? "a Turn or Run is still running"
-        : "an active Run or lifecycle operation is still pending"})`));
+    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (an active Run or lifecycle operation is still pending)`));
     return {
         output: [
             `Cannot stop managed Sessions: ${blocked.length} Session(s) are still busy.`,

package/dist/commands/taskActor.js

@@ -207,8 +207,7 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
     if (session === undefined
         || identity(session.nativeSessionId) === undefined
         || identity(session.launchId) === undefined
-        || session.status === "stopped"
-        || session.status === "broken"
+        || session.status === "ended"
         || session.adapterId !== adapterId
         || (explicitAssertion === undefined && session.launchId !== launchId))
         return undefined;

package/dist/commands/taskCommands.js

@@ -1276,6 +1276,8 @@ function taskRoleCommand(args, store, options) {
         return output(bindTaskRole(rest, store, options));
     if (command === "unbind")
         return output(unbindTaskRole(rest, store, options));
+    if (command === "session")
+        return taskRoleSessionCommand(rest, store, options);
     if (command === "view")
         return viewTaskRole(rest, store);
     if (command === "takeover")
@@ -1286,6 +1288,87 @@ function taskRoleCommand(args, store, options) {
         ? "Task role command is required."
         : `Unknown command: task role ${command}`);
 }
+function taskRoleSessionCommand(args, store, options) {
+    const [command, ...rest] = args;
+    if (command === "inspect") {
+        exactPositionals(rest, 2, "Task Role Session inspect usage: yui task role session inspect <task> <role>.");
+        const task = requireTask(store, rest[0]);
+        const role = requireRole(store, task.id, rest[1]);
+        taskActor(store, options, task.id);
+        const sessions = store.getTaskRoleSessionSet(task.id, role.name);
+        const active = sessions?.sessions[sessions.activeAgentId] ?? null;
+        const binding = sessions?.providerBinding ?? null;
+        return output(active === null
+            ? `No Session exists for ${task.id}/${role.name}.\n`
+            : [
+                `Session ${task.id}/${role.name}`,
+                `Agent: ${active.agentId}/${active.adapterId}`,
+                `Native id: ${active.nativeSessionId}`,
+                `Host activation: ${active.launchId ?? "none"}`,
+                `Session: ${active.status}${active.endReason === undefined ? "" : `/${active.endReason}`}`,
+                `Turn: ${binding?.turn?.status ?? "none"}`
+            ].join("\n") + "\n", { task, role, session: active, providerBinding: binding });
+    }
+    if (command === "stop") {
+        const usage = "Task Role Session stop usage: yui task role session stop <task> <role> --reason <text>.";
+        const parsed = parseTail(rest, new Set(["--reason"]), usage);
+        exactPositionals(parsed.positionals, 2, usage);
+        const reason = requiredOption(parsed.options, "--reason");
+        const now = clock(options);
+        const request = store.transaction((tx) => {
+            const task = requireTask(tx, parsed.positionals[0]);
+            assertTaskOpen(task);
+            const actor = taskActor(tx, options, task.id);
+            const role = requireRole(tx, task.id, parsed.positionals[1]);
+            if (actor === "leader" && role.name === LEADER_ROLE) {
+                throw usageError("A Leader cannot stop the Session executing its own current command.", usage);
+            }
+            if (tx.getActiveAgentRun(task.id, role.name) !== null) {
+                throw usageError(`Task Role has an active Run; settle or retire it before stopping the Session: ${task.id}/${role.name}.`, usage);
+            }
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            const session = sessions?.sessions[sessions.activeAgentId];
+            if (session === undefined || session.status === "ended") {
+                throw usageError(`Task Role has no active Session: ${task.id}/${role.name}.`, usage);
+            }
+            const lifecycle = tx.getWorkMailbox(runtimeLifecycleTarget({
+                scope: "task",
+                taskId: task.id,
+                roleName: role.name
+            }));
+            if (lifecycle !== null && workMailboxHasWork(lifecycle)) {
+                throw usageError(`Task Role Session lifecycle is busy: ${task.id}/${role.name}.`, usage);
+            }
+            recordTaskEvent(tx, task.id, "runtime.session-stop-requested", {
+                roleName: role.name,
+                agentId: session.agentId,
+                adapterId: session.adapterId,
+                nativeSessionId: session.nativeSessionId,
+                launchId: session.launchId ?? "",
+                reason,
+                requestedBy: actor
+            }, now);
+            return {
+                taskId: task.id,
+                roleName: role.name,
+                agentId: session.agentId,
+                adapterId: session.adapterId,
+                nativeSessionId: session.nativeSessionId,
+                ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+                sessionUpdatedAt: session.updatedAt
+            };
+        });
+        return {
+            kind: "session-stop",
+            ...request,
+            reason,
+            output: `Stopped Session ${request.taskId}/${request.roleName}: ${reason}\n`
+        };
+    }
+    throw usageError(command === undefined
+        ? "Task Role Session command is required."
+        : `Unknown command: task role session ${command}`);
+}
 function addTaskRole(args, store, options) {
     const usage = "Task role add usage: yui task role add <task> <name> [Role and Agent settings].";
     const [taskId, roleName, ...tail] = args;
@@ -1483,7 +1566,7 @@ function removeTaskRole(args, store, options) {
             throw usageError(`Task Role has an active Run and cannot be removed: ${task.id}/${role.name}.`);
         }
         const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
-        if (Object.values(sessions?.sessions ?? {}).some(({ status }) => status !== "stopped")) {
+        if (Object.values(sessions?.sessions ?? {}).some(({ status }) => status === "active")) {
             throw usageError(`Task Role has a running native Agent and cannot be removed: ${task.id}/${role.name}.`);
         }
         if (!tx.removeTaskRole(task.id, role.name))
@@ -1531,7 +1614,7 @@ function bindTaskRole(args, store, options) {
                 return switchActiveRoleAgent(bound, existing, agent.id, {
                     activeRun: tx.getActiveAgentRun(task.id, role.name) !== null,
                     nativeProcessRunning: currentSession !== undefined
-                        && currentSession.status !== "stopped"
+                        && currentSession.status === "active"
                 }, now);
             }
             catch (error) {
@@ -1585,7 +1668,7 @@ function viewTaskRole(args, store) {
     }
     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") {
+    if (session === null || session.status === "ended") {
         throw usageError(`Task Role has no live Provider view: ${task.id}/${role.name}.`);
     }
     return {
@@ -1614,7 +1697,7 @@ function transferTaskRoleAuthority(args, store, options, action) {
             if (sessions === null || sessions === undefined || session === undefined
                 || binding === null || binding === undefined
                 || session.launchId === undefined
-                || session.status === "stopped" || session.status === "broken") {
+                || session.status === "ended") {
                 throw new Error(`Task Role has no live managed Provider: ${task.id}/${role.name}.`);
             }
             const activation = currentProviderActivation(binding);
@@ -3059,7 +3142,7 @@ function rebindTaskFinalReviewContract(args, store, options) {
             if (leaderSessions.inFlight !== null) {
                 throw usageError("Task final-review contract cannot rebind while the Leader runtime has unsettled Run state.");
             }
-            const liveLeaderSession = Object.values(leaderSessions.sessions).find(({ status }) => status !== "stopped" && status !== "broken");
+            const liveLeaderSession = Object.values(leaderSessions.sessions).find(({ status }) => status === "active");
             if (liveLeaderSession !== undefined) {
                 throw usageError(`Task final-review contract cannot rebind while Leader Session ${liveLeaderSession.agentId} is ${liveLeaderSession.status}.`);
             }
@@ -7162,8 +7245,8 @@ function settleTaskExecutionForCompletion(store, taskId, roles, summary, now) {
                 sessions = terminalizeTaskRoleRunSession(sessions, sessions.inFlight, now);
             }
             const current = sessions.sessions[sessions.activeAgentId];
-            if (current !== undefined && current.status !== "stopped" && current.status !== "broken") {
-                sessions = updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now);
+            if (current !== undefined && current.status === "active") {
+                sessions = updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "ended", now, "stopped");
             }
             store.saveTaskRoleSessionSet(sessions);
         }
@@ -7180,14 +7263,14 @@ function settleTaskExecutionForCompletion(store, taskId, roles, summary, now) {
     return targets;
 }
 function ownedRuntimeSessionRequiresCleanup(session) {
-    if (session === undefined || session.status === "stopped" || session.status === "broken") {
+    if (session === undefined || session.status === "ended") {
         return false;
     }
     // Older synthetic session fixtures can represent a ready native session
     // without a lifecycle generation. Do not manufacture a cleanup obligation
     // for those records; coordinated launches always carry launchId, while a
     // running session remains actionable even when an older record lacks it.
-    return session.status === "running" || session.launchId !== undefined;
+    return session.launchId !== undefined;
 }
 function roleMailbox(taskId, roleName) {
     return { kind: "role", taskId, roleName };

package/dist/commands/taskRoleRuntimeStatus.js

@@ -253,7 +253,7 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
             healthReason: "the native Session is unbound; verified runtime cleanup is pending"
         };
     }
-    if (nativeSession?.status === "broken") {
+    if (nativeSession?.status === "ended" && nativeSession.endReason === "failed") {
         // Issue 09: a broken Session only fails a live Run. When the last Run
         // already yielded, the Session death is a lifecycle event, not a Run
         // failure — surface it as attention with the persisted Run outcome.
@@ -329,10 +329,10 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
             }
         }
     }
-    if (nativeSession?.status === "running" && tmux.state !== "running") {
+    if (nativeSession?.status === "active" && tmux.state !== "running") {
         return { health: "needs-attention", healthReason: "the native session is running without a live tmux pane" };
     }
-    if (nativeSession?.status === "stopped" && tmux.state === "running") {
+    if (nativeSession?.status === "ended" && tmux.state === "running") {
         return { health: "needs-attention", healthReason: "a stopped native session has a live tmux pane" };
     }
     if (role.name === "leader" && openInputRequestCount > 0) {

package/dist/config/configCatalog.js

@@ -1,6 +1,5 @@
-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";
+import { MAX_CONTEXT_BUDGET_TOKENS, 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,
@@ -16,10 +15,6 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "runtime-health", domain: "runtime", property: "runtimeHealth", label: "Runtime health thresholds", summary: "Quiet, checkpoint-overdue, and read-only diagnostic thresholds in seconds; values must be strictly increasing (defaults: 300/900/1800).", takesEffect: "CLI and Web projections immediately; scheduler diagnostics 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: "Legacy context budget (inactive)", summary: `Compatibility-only soft and hard values in ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}; they are parsed but never control Session or workflow behavior.`, takesEffect: "No runtime effect; Session Token metrics are read-only observations." },