@zq-silk/yui 0.13.7 → 0.13.9

package/ARCHITECTURE.md

@@ -1,9 +1,33 @@
 # Yui Architecture
 
-Yui is a local control plane for durable work across Projects and native Agent
-runtimes. The user talks to one Operator. The Operator routes each request to
-the right Project and Task; that Task's Leader owns decomposition, execution
-choice, review, integration, and completion.
+Yui is a local control plane for intelligent Agents doing durable work across
+Projects and native runtimes. The user talks to one Operator. The Operator
+routes each request to the right Project and Task; that Task's Leader owns
+decomposition, execution choice, review, integration, and completion.
+
+## Design principles
+
+- **Agents own judgment.** Yui exposes current durable context and atomic
+  capabilities; the Operator, Leader, and Workers choose plans, execution
+  topology, sequencing, retry, and recovery from that context.
+- **Core provides primitives, not a prescribed workflow.** Reads, messages,
+  bounded record transitions, workspace ownership, Session lifecycle, and
+  acceptance are composable operations. Project Skills and Knowledge provide
+  project-specific policy without adding core branches.
+- **Durable intent outranks runtime continuity.** Tasks, WorkItems, Messages,
+  Decisions, results, Project Knowledge, and managed workspaces are authority.
+  Provider Sessions, transcripts, processes, and observations are execution
+  aids that may be resumed or replaced.
+- **Trust explicit Agent actions.** Once identity, authority, and scope are
+  established, a valid Agent command is a semantic declaration. Core should not
+  reconstruct the same judgment through another status protocol.
+- **Fail visibly and let the Agent adapt.** Preserve pending intent and return
+  actionable state. Add automated retry, recovery, leases, or fallback only for
+  a normal product path, a hard safety or data-integrity boundary, or a proven
+  failure whose cost justifies the machinery.
+- **One question has one authority.** Projections and indexes may summarize
+  state, but scheduling and lifecycle decisions must not depend on independently
+  writable copies of the same fact.
 
 ## One outcome, Leader-chosen execution topology
 
@@ -254,6 +278,18 @@ Yui's current attachment, not exclusive ownership of the Provider thread. One
 Turn identifies one provider-native execution. Yui's authority epoch fences
 only Yui's own submissions and retries.
 
+`AgentRun` is the single durable scheduling authority for a Role. Provider
+runtime persistence has no independently writable current-Run field; a Turn's
+Run id is correlation evidence for receipts and terminal observations only.
+`TaskRole` likewise stores configuration and identity, not a writable runtime
+status. CLI and Web status views derive activity from the active AgentRun and
+add Session/Driver facts only as lifecycle and diagnostic detail.
+`AgentHost` is the serialized consumer: while a native Turn is active, the next
+AgentRun and mailbox batch remain durable and unsubmitted. When that Turn ends,
+the Host makes the Conversation ready and the retained delivery continues.
+This remains true when the Agent declared the old Run's semantic outcome before
+the Provider emitted its terminal event.
+
 Codex Task threads remain ordinary native sessions and can be opened and used
 directly in Desktop. If a direct user Turn is active, Yui keeps its pending
 Run/message until that Turn settles. Global interactive entry remains a native

package/README.md

@@ -2,7 +2,16 @@
 
 # Yui
 
-Yui is a local control plane for durable Codex and Claude work. It keeps control state and Project knowledge in inspectable JSON, lets tmux own native Agent terminals, and combines reusable Worker Profiles, Leader-owned delegation, explicit acceptance, and isolated Git worktrees for Project-backed Tasks.
+Yui is a local control plane for intelligent Codex and Claude Agents. It keeps
+user intent, Project knowledge, Tasks, handoffs, and results durable and
+inspectable, while exposing small atomic capabilities for context, messaging,
+delegation, workspaces, Sessions, review, and integration. Agents compose those
+capabilities and decide how to plan, sequence, delegate, retry, and recover.
+
+Yui deliberately does not turn Agent judgment into a deterministic workflow
+engine. Its core owns durable identity, user authority, workspace isolation,
+and atomic state changes. Provider Sessions and runtime observations support
+execution and continuity, but they are not competing sources of Task truth.
 
 The current implementation restores the useful Role/Agent/session and CLI framework without restoring the later data-maintenance, lease, schedule, and recovery-ledger systems.
 
@@ -39,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.
@@ -883,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:
@@ -900,6 +910,15 @@ supported human-control boundary. A Codex Role uses an ordinary shared thread
 and may be operated directly in Desktop; an active Desktop Turn creates bounded
 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 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:
 
 ```sh

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/updatePorts.js

@@ -226,10 +226,10 @@ export function createUpdatePorts(environment, spawn = spawnSync, stagingRoot =
                     + `but the staged/verified artifact was ${staged.version}. Refusing to trust a `
                     + "different build than the one that passed preflight.");
             }
-            // Existing managed Sessions may have been created by a release that
-            // embedded an exact CLI path/version in its wrapper. Convert those
-            // authenticated, Manifest-referenced wrappers before the replacement
-            // Controller starts so the update cannot strand a live Session.
+            // Existing managed Sessions may have been created by an earlier release.
+            // Retarget those authenticated, Manifest-referenced wrappers to the
+            // activated control plane before the replacement Controller starts so
+            // the update cannot strand a live Session.
             const sessionCliRefresh = run(activeBinary, ["--json", "internal", "session-cli-refresh"], { cwd: process.cwd(), env: { ...environment, YUI_HOME: home }, shell: false });
             assertSpawnOk(sessionCliRefresh, "refresh managed Session CLI wrappers");
             // Retain the exact path used by both doctor and version verification. The

package/dist/cli.js

@@ -348,7 +348,7 @@ export async function main() {
                 || (process.env.YUI_SESSION_SCOPE === "global" && process.env.YUI_ROLE !== "operator")) {
                 throw usageError("Managed Session CLI refresh may be run only by the user or global Operator.");
             }
-            const result = refreshManagedSessionCliWrappers(home);
+            const result = refreshManagedSessionCliWrappers(home, currentInvocationControlPlane(home));
             emit(`Refreshed ${result.refreshed} legacy Session CLI wrapper(s); `
                 + `${result.current} already current, ${result.skipped} skipped.`, false, result);
             return;
@@ -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;