@zq-silk/yui 0.6.13 → 0.6.14

package/dist/commands/taskRoleRuntimeStatus.js

@@ -2,7 +2,8 @@ import { isDeepStrictEqual } from "node:util";
 import { hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { evaluateRuntimeAttention, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
+import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation, projectRuntimeTaskEvents, runtimeDisplayStatus } from "../runtime/runtimeProjection.js";
+import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
@@ -20,6 +21,9 @@ export function renderTaskRoleRuntimeStatus(status) {
     const activeRun = status.activeRun === null
         ? "-"
         : `${status.activeRun.id} (${activeRunDeliveryLabel(status.activeRun)})`;
+    const lastRun = status.activeRun !== null || status.lastRun === null
+        ? undefined
+        : `${status.lastRun.id} (${status.lastRun.status}${status.lastRun.endedAt === undefined ? "" : ` at ${status.lastRun.endedAt}`})`;
     const activeWork = status.activeWork === null
         ? "-"
         : `${status.activeWork.id} (${status.activeWork.status}) ${status.activeWork.title}`;
@@ -44,10 +48,12 @@ export function renderTaskRoleRuntimeStatus(status) {
         ? "not observable"
         : [
             `${status.runtime.driverId}: ${status.runtime.status}`,
-            `attention=${status.runtime.attention}`,
+            `health=${status.runtime.healthLayer}`,
+            `health reason=${status.runtime.healthReason}`,
             status.runtime.lastActivityAt === undefined
                 ? undefined
                 : `last activity=${status.runtime.lastActivityAt}`,
+            `last semantic progress=${status.runtime.lastSemanticProgressAt}`,
             status.runtime.activeOperations.length === 0
                 ? undefined
                 : `operations=${status.runtime.activeOperations.join(",")}`,
@@ -73,6 +79,7 @@ export function renderTaskRoleRuntimeStatus(status) {
         `  Role state       ${status.role.status}`,
         `  Active work      ${activeWork}`,
         `  Active run       ${activeRun}`,
+        ...(lastRun === undefined ? [] : [`  Last run         ${lastRun}`]),
         `  Run attention    ${status.stall.active
             ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
@@ -90,6 +97,14 @@ export function taskRoleActiveWorkLabel(status) {
         return `${status.activeWork.id}: ${status.activeWork.title}`;
     return status.activeRun === null ? "-" : status.activeRun.id;
 }
+/** Issue 09: compact last-Run outcome label for the Role list table. */
+export function taskRoleLastRunLabel(status) {
+    if (status.activeRun !== null)
+        return `${status.activeRun.id} ${status.activeRun.status}`;
+    if (status.lastRun === null)
+        return "-";
+    return `${status.lastRun.id} ${status.lastRun.status}`;
+}
 export function taskRoleNativeSessionLabel(status) {
     if (status.runtimeCleanupPending && status.nativeSession === null)
         return "reset (cleanup-pending)";
@@ -121,6 +136,13 @@ export function taskRoleTmuxLabel(status) {
 }
 function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputRequestCount, now) {
     const activeRun = store.getActiveAgentRun(taskId, role.name);
+    // Issue 09: the last Run outcome is a separate axis from the Session
+    // lifecycle. A Session that stops after its Run yielded must not retroactively
+    // turn that Run into a failure; the status display keeps both visible.
+    const lastRun = store.listAgentRuns(taskId)
+        .filter((candidate) => candidate.roleName === role.name)
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
+        ?? null;
     const activeWork = activeRun?.workItemId === undefined
         ? null
         : store.getWorkItem(taskId, activeRun.workItemId);
@@ -154,7 +176,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
-    const runtime = projectTaskRoleRuntime(activeRun, nativeSession, tmux, events, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }), now);
+    const runtime = projectTaskRoleRuntime(activeRun, nativeSession, tmux, events, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }), store, taskId, role.name, now);
     const stalled = activeRun !== null && isRoleRunStalled(events, activeRun.id);
     const stallProgressAt = activeRun === null
         ? undefined
@@ -162,7 +184,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     const stallKind = activeRun === null
         ? undefined
         : latestStallKind(events, activeRun.id);
-    const health = calculateHealth(role, activeRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
+    const health = calculateHealth(role, activeRun, lastRun, nativeSession, recovery.runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime);
     const stall = activeRun === null
         ? { active: false }
         : {
@@ -184,6 +206,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         openInputRequestCount,
         role,
         activeRun,
+        lastRun,
         activeWork,
         nativeSession,
         tmux,
@@ -200,7 +223,7 @@ function latestStallKind(events, runId) {
         ? event.payload.kind
         : undefined;
 }
-function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
+function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanupPending, tmux, openInputRequestCount, stalled, runtime) {
     if (runtimeCleanupPending && nativeSession === null) {
         return {
             health: "needs-attention",
@@ -211,7 +234,18 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
         return { health: "failed", healthReason: `persisted Role state is ${role.status}` };
     }
     if (nativeSession?.status === "broken") {
-        return { health: "failed", healthReason: "the active native session is broken" };
+        // 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.
+        if (activeRun !== null) {
+            return { health: "failed", healthReason: "the active native session is broken" };
+        }
+        return {
+            health: "needs-attention",
+            healthReason: lastRun === null
+                ? "the native session is broken"
+                : `the native session is broken; last run ${lastRun.id} ${lastRun.status}`
+        };
     }
     const awaitingProviderAcceptance = activeRun?.pushedAt !== undefined
         && activeRun.deliveredAt === undefined;
@@ -245,52 +279,36 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
             };
         }
         if (activeRun.deliveredAt !== undefined) {
-            if (runtime === null
-                || runtime.status === "runtime-unobservable"
-                || runtime.attention === "unobservable") {
-                return {
-                    health: "needs-attention",
-                    healthReason: "the host is present but the Agent Driver exposes no current runtime state"
-                };
-            }
-            if (runtime.attention === "quiet" || runtime.attention === "active-operation-quiet") {
-                return {
-                    health: "needs-attention",
-                    healthReason: runtime.attention === "active-operation-quiet"
-                        ? "the Agent Driver reports an open operation but no recent structured runtime activity"
-                        : "the Agent Driver has not reported recent structured runtime activity"
-                };
-            }
-            if (runtime.status === "broken") {
-                return {
-                    health: "failed",
-                    healthReason: `the Agent Driver runtime is ${runtime.status}`
-                };
-            }
-            if (runtime.status === "stopped") {
+            if (runtime === null) {
                 return {
                     health: "needs-attention",
-                    healthReason: "the Provider Activation ended while the Yui Run remains active"
-                };
-            }
-            if (runtime.status.startsWith("waiting-")) {
-                return {
-                    health: runtime.status === "waiting-user" ? "blocked-input" : "waiting",
-                    healthReason: `the Agent Driver is ${runtime.status.replaceAll("-", " ")}`
+                    healthReason: "the delivered Run has no authoritative Agent Driver state"
                 };
             }
-            if (runtime.status === "ready") {
-                return {
-                    health: "needs-attention",
-                    healthReason: "the Agent turn ended while the workflow Run is still active"
-                };
-            }
-            if (["model-active", "tool-active", "subagent-active", "active-quiet"]
-                .includes(runtime.status)) {
-                return {
-                    health: "running",
-                    healthReason: `the Agent Driver reports ${runtime.status.replaceAll("-", " ")}`
-                };
+            switch (runtime.healthLayer) {
+                case "broken":
+                    return { health: "failed", healthReason: runtime.healthReason };
+                case "stopped":
+                case "diagnostic-needed":
+                case "ready":
+                case "awaiting-provider-acceptance":
+                case "runtime-unobservable":
+                case "starting":
+                    return { health: "needs-attention", healthReason: runtime.healthReason };
+                case "waiting-user":
+                    return { health: "blocked-input", healthReason: runtime.healthReason };
+                case "waiting-permission":
+                case "waiting-external":
+                    return { health: "waiting", healthReason: runtime.healthReason };
+                case "quiet":
+                case "active-quiet":
+                case "model-active":
+                case "tool-active":
+                case "subagent-active":
+                default:
+                    // Short silence is a hint, not a failure. Only deterministic
+                    // dead/broken evidence or the durable stall window escalates.
+                    return { health: "running", healthReason: runtime.healthReason };
             }
         }
     }
@@ -327,7 +345,7 @@ function calculateHealth(role, activeRun, nativeSession, runtimeCleanupPending,
         ? { health: "ready", healthReason: "the native Agent pane is ready without active work" }
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
-function projectTaskRoleRuntime(run, session, tmux, events, mailbox, now) {
+function projectTaskRoleRuntime(run, session, tmux, events, mailbox, store, taskId, roleName, now) {
     if (run === null || session?.launchId === undefined)
         return null;
     let driverId;
@@ -370,21 +388,27 @@ function projectTaskRoleRuntime(run, session, tmux, events, mailbox, now) {
         fence,
         payload: { alive: tmux.state === "running" }
     }));
-    const attention = evaluateRuntimeAttention(projection, now, {
-        runtimeSilenceMs: 5 * 60_000,
-        // Workflow attention has its own durable scheduler policy. This value is
-        // deliberately not consumed here; keeping it separate prevents token/tool
-        // activity from extending the workflow deadline.
-        semanticSilenceMs: 30 * 60_000
+    // The semantic progress fence is the same durable fold the scheduler stall
+    // pass consumes, so CLI/Web/scheduler share one progress clock.
+    const semanticProgress = run.deliveredAt === undefined
+        ? { progressAt: run.createdAt }
+        : latestRunDurableProgressAt(store, taskId, roleName, run.id)
+            ?? { progressAt: run.deliveredAt };
+    const classification = classifyRuntimeHealth({
+        projection,
+        semanticProgressAt: semanticProgress.progressAt,
+        now
     });
     return {
         driverId,
         status: runtimeDisplayStatus(projection),
-        attention: attention.runtime,
-        ...(projection.lastRuntimeActivityAt === undefined
+        healthLayer: classification.layer,
+        healthReason: classification.reason,
+        lastSemanticProgressAt: classification.lastSemanticProgressAt,
+        ...(classification.lastRuntimeActivityAt === undefined
             ? {}
-            : { lastActivityAt: projection.lastRuntimeActivityAt }),
-        activeOperations: Object.entries(projection.operations).map(([id, operation]) => (`${operation.kind}:${id}`)),
+            : { lastActivityAt: classification.lastRuntimeActivityAt }),
+        activeOperations: classification.activeOperations,
         ...(projection.waitingReason === undefined
             ? {}
             : { waitingReason: projection.waitingReason }),

package/dist/commands/telemetryCommands.js

@@ -7,6 +7,10 @@ import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigra
 import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, resolveRunCap, resolveTelemetryMode, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
 import { applyTelemetryCompaction, planTelemetryCompaction } from "../telemetry/telemetryCompaction.js";
 import { SqliteTelemetryStore } from "../telemetry/sqliteTelemetryStore.js";
+/** Read the durable config, falling back to defaults when no store is available. */
+function storeConfig(options) {
+    return options.store?.getConfig() ?? { schemaVersion: 1 };
+}
 export async function runTelemetryCommand(args, options) {
     const [command, ...rest] = args;
     if (command === "status")
@@ -27,12 +31,11 @@ export async function runTelemetryCommand(args, options) {
 // -- status ---------------------------------------------------------------------
 function telemetryStatus(args, options) {
     const flags = parseFlags(args, new Set([]));
-    const env = options.environment ?? process.env;
-    const mode = resolveTelemetryMode(env);
+    const mode = resolveTelemetryMode(storeConfig(options).telemetryMode);
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode,
-        terminalKeep: resolveTerminalKeep(env),
-        runCap: resolveRunCap(env)
+        terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
+        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
     });
     try {
         const health = telemetry.health();
@@ -52,8 +55,8 @@ function telemetryStatus(args, options) {
             coalesced: health.coalesced,
             lastError: health.lastError,
             totalRows: health.rows,
-            terminalKeep: resolveTerminalKeep(env),
-            runCap: resolveRunCap(env),
+            terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
+            runCap: resolveRunCap(storeConfig(options).telemetryRunCap),
             tasks: perTask
         };
         if (options.json || flags.has("json"))
@@ -84,11 +87,10 @@ function telemetryPrune(args, options) {
     const taskId = stringOption(args, "--task");
     const keep = integerOption(args, "--keep", DEFAULT_TERMINAL_KEEP);
     const dryRun = flags.has("dry-run");
-    const env = options.environment ?? process.env;
-    const cap = resolveRunCap(env);
+    const cap = resolveRunCap(storeConfig(options).telemetryRunCap);
     const store = requireStore(options);
     const telemetry = new SqliteTelemetryStore(options.home, {
-        mode: resolveTelemetryMode(env),
+        mode: resolveTelemetryMode(storeConfig(options).telemetryMode),
         terminalKeep: keep,
         runCap: cap
     });
@@ -237,11 +239,10 @@ function telemetryRead(args, options) {
     const runId = stringOption(args, "--run");
     const limit = integerOption(args, "--limit", 100);
     const offset = integerOption(args, "--offset", 0);
-    const env = options.environment ?? process.env;
     const telemetry = new SqliteTelemetryStore(options.home, {
-        mode: resolveTelemetryMode(env),
-        terminalKeep: resolveTerminalKeep(env),
-        runCap: resolveRunCap(env)
+        mode: resolveTelemetryMode(storeConfig(options).telemetryMode),
+        terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
+        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
     });
     try {
         if (flags.has("aggregate")) {

package/dist/config/yuiConfig.js

@@ -1,3 +1,6 @@
+import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
+import { PROVIDER_RETRY_MAX_WINDOW_MS } from "../run/providerRetry.js";
+import { DEFAULT_RUN_CAP, DEFAULT_TELEMETRY_MODE, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
 export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 120;
 export const MIN_RECONCILIATION_INTERVAL_SECONDS = 5;
 export const MAX_RECONCILIATION_INTERVAL_SECONDS = 300;
@@ -66,15 +69,165 @@ export function resolveLeaderNextActionMode(value) {
     }
     return normalized;
 }
+// ── Issue 01: Provider retry ──────────────────────────────────────────────
+export const PROVIDER_RETRY_MODES = ["off", "shadow", "enforce"];
+export const DEFAULT_PROVIDER_RETRY_MODE = "enforce";
+export function resolveProviderRetryMode(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_PROVIDER_RETRY_MODE;
+    if (typeof value !== "string") {
+        throw new TypeError("providerRetryMode must be off, shadow, or enforce.");
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0)
+        return DEFAULT_PROVIDER_RETRY_MODE;
+    if (!PROVIDER_RETRY_MODES.includes(normalized)) {
+        throw new TypeError("providerRetryMode must be off, shadow, or enforce.");
+    }
+    return normalized;
+}
+/**
+ * Resolves the adapter list. `["all"]` or undefined means every supported
+ * adapter; an empty array disables in-place retry.
+ */
+export function resolveProviderRetryAdapters(value) {
+    if (value === undefined || value === null) {
+        return [...supportedAgentAdapterIds()];
+    }
+    if (!Array.isArray(value)) {
+        throw new TypeError("providerRetryAdapters must be an array of adapter ids.");
+    }
+    const supported = new Set(supportedAgentAdapterIds());
+    const adapters = [];
+    for (const raw of value) {
+        if (typeof raw !== "string") {
+            throw new TypeError("providerRetryAdapters entries must be strings.");
+        }
+        const token = raw.trim().toLowerCase();
+        if (token === "all") {
+            for (const adapter of supportedAgentAdapterIds()) {
+                if (!adapters.includes(adapter))
+                    adapters.push(adapter);
+            }
+            continue;
+        }
+        if (!/^[a-z0-9][a-z0-9._-]*$/u.test(token)) {
+            throw new TypeError(`Invalid Provider retry adapter: ${token}.`);
+        }
+        if (!supported.has(token)) {
+            throw new TypeError(`Unknown Provider retry adapter: ${token}.`);
+        }
+        if (!adapters.includes(token))
+            adapters.push(token);
+    }
+    return adapters;
+}
+export function resolveProviderRetryMaxWindowMs(value) {
+    if (value === undefined || value === null)
+        return PROVIDER_RETRY_MAX_WINDOW_MS;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError("providerRetryMaxWindowMs must be a positive integer.");
+    }
+    return value;
+}
+export function resolveYieldReceiptReplay(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value !== "boolean") {
+        throw new TypeError("yieldReceiptReplay must be a boolean.");
+    }
+    return value;
+}
+// ── Executable paths ──────────────────────────────────────────────────────
+export function resolveTmuxBin(value) {
+    if (value === undefined || value === null)
+        return "tmux";
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("tmuxBin must be a non-empty string.");
+    }
+    return value.trim();
+}
+export function resolveGitBin(value) {
+    if (value === undefined || value === null)
+        return "git";
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("gitBin must be a non-empty string.");
+    }
+    return value.trim();
+}
+// ── Telemetry ─────────────────────────────────────────────────────────────
+const TELEMETRY_MODES = ["legacy", "dual", "bounded"];
+export function resolveTelemetryMode(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_TELEMETRY_MODE;
+    if (typeof value !== "string") {
+        throw new TypeError("telemetryMode must be legacy, dual, or bounded.");
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0)
+        return DEFAULT_TELEMETRY_MODE;
+    if (!TELEMETRY_MODES.includes(normalized)) {
+        throw new TypeError(`telemetryMode must be one of ${TELEMETRY_MODES.join(", ")}; got ${JSON.stringify(normalized)}.`);
+    }
+    return normalized;
+}
+export function resolveTelemetryTerminalKeep(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_TERMINAL_KEEP;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError("telemetryTerminalKeep must be a positive integer.");
+    }
+    return value;
+}
+export function resolveTelemetryRunCap(value) {
+    if (value === undefined || value === null)
+        return DEFAULT_RUN_CAP;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError("telemetryRunCap must be a positive integer.");
+    }
+    if (value > MAX_RUN_CAP) {
+        throw new TypeError(`telemetryRunCap must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
+    }
+    return value;
+}
 /**
- * Resolve the effective mode. An explicit environment override
- * (`YUI_LEADER_NEXT_ACTION_MODE`) wins over the durable config value so a
- * single CLI invocation can be tightened or loosened without a config write.
+ * Issue 04 (context token budget): thresholds for one native Session
+ * generation's observed per-request input peak, measured in tokens. When the
+ * peak crosses the soft threshold the Leader wake carries a checkpoint
+ * advisory; when it crosses the hard threshold the scheduler retires the
+ * generation and starts a fresh one instead of waiting for provider-side
+ * auto-compaction. The fields are additive and optional — Homes without them
+ * keep these defaults, so no config migration is required.
  */
-export function leaderNextActionMode(configured, env = process.env) {
-    const override = env.YUI_LEADER_NEXT_ACTION_MODE;
-    if (override !== undefined && override.trim().length > 0) {
-        return resolveLeaderNextActionMode(override);
+export const DEFAULT_CONTEXT_SOFT_TOKENS = 100_000;
+export const DEFAULT_CONTEXT_HARD_TOKENS = 120_000;
+export const MIN_CONTEXT_BUDGET_TOKENS = 1_000;
+export const MAX_CONTEXT_BUDGET_TOKENS = 1_000_000;
+function resolveContextBudgetToken(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw new TypeError(`${label} must be a safe integer.`);
+    }
+    if (value < MIN_CONTEXT_BUDGET_TOKENS || value > MAX_CONTEXT_BUDGET_TOKENS) {
+        throw new TypeError(`${label} must be between ${MIN_CONTEXT_BUDGET_TOKENS} and ${MAX_CONTEXT_BUDGET_TOKENS}.`);
+    }
+    return value;
+}
+export function resolveContextBudget(configured) {
+    if (configured === undefined || configured === null) {
+        return { softTokens: DEFAULT_CONTEXT_SOFT_TOKENS, hardTokens: DEFAULT_CONTEXT_HARD_TOKENS };
+    }
+    if (typeof configured !== "object" || Array.isArray(configured)) {
+        throw new TypeError("contextBudget must be an object.");
+    }
+    const record = configured;
+    const softTokens = record.softTokens === undefined
+        ? DEFAULT_CONTEXT_SOFT_TOKENS
+        : resolveContextBudgetToken(record.softTokens, "contextBudget.softTokens");
+    const hardTokens = record.hardTokens === undefined
+        ? DEFAULT_CONTEXT_HARD_TOKENS
+        : resolveContextBudgetToken(record.hardTokens, "contextBudget.hardTokens");
+    if (softTokens >= hardTokens) {
+        throw new TypeError("contextBudget.softTokens must be smaller than contextBudget.hardTokens.");
     }
-    return resolveLeaderNextActionMode(configured);
+    return { softTokens, hardTokens };
 }

package/dist/context/sessionContextBudget.js

@@ -0,0 +1,68 @@
+import { resolveContextBudget } from "../config/yuiConfig.js";
+import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+export function evaluateSessionContextBudget(events, session, configured) {
+    const budget = resolveContextBudget(configured);
+    const peak = observedPeakInputTokens(events, session);
+    const state = peak >= budget.hardTokens
+        ? "hard"
+        : peak >= budget.softTokens
+            ? "soft"
+            : "within";
+    return Object.freeze({ state, peakTokens: peak, budget });
+}
+/**
+ * Largest per-request input peak observed for one Session generation. Usage
+ * observations carry cumulative session totals; consecutive deltas bound the
+ * per-request input of the window between them. The first observation for a
+ * generation is treated as one full request so a long-lived resumed Session
+ * that was only sampled late still counts its inherited context.
+ */
+export function observedPeakInputTokens(events, session) {
+    let previous = 0;
+    let peak = 0;
+    for (const event of events) {
+        const observation = runtimeObservationFromTaskEvent(event);
+        if (observation === null)
+            continue;
+        if (!matchesSession(observation.fence, session))
+            continue;
+        const usage = usageTotal(observation.payload.usage);
+        if (usage === null)
+            continue;
+        const delta = Math.max(0, usage - previous);
+        if (delta > peak)
+            peak = delta;
+        previous = usage;
+    }
+    return peak;
+}
+function matchesSession(fence, session) {
+    if (fence.taskId !== undefined && fence.taskId !== session.taskId)
+        return false;
+    if (fence.roleName !== session.roleName)
+        return false;
+    if (session.nativeSessionId !== undefined
+        && fence.nativeSessionId !== undefined
+        && fence.nativeSessionId !== session.nativeSessionId) {
+        return false;
+    }
+    if (session.launchId !== undefined
+        && fence.launchId !== undefined
+        && fence.launchId !== session.launchId) {
+        return false;
+    }
+    return true;
+}
+function usageTotal(usage) {
+    if (typeof usage !== "object" || usage === null || Array.isArray(usage))
+        return null;
+    const record = usage;
+    const inputTokens = integer(record.inputTokens);
+    if (inputTokens === null)
+        return null;
+    const cachedInputTokens = integer(record.cachedInputTokens) ?? 0;
+    return inputTokens + cachedInputTokens;
+}
+function integer(value) {
+    return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}

package/dist/context/wakeNotification.js

@@ -0,0 +1,65 @@
+import { renderWakeReason } from "../scheduler/wakeReason.js";
+/**
+ * Issue 04 (context token budget) — long-term design:
+ *
+ * A Leader wake is a NOTIFICATION, not a context dump. The wake envelope
+ * carries only what the Agent cannot reconstruct from durable records:
+ * the wake id, the aggregated reason tags, and the delta window. The Agent
+ * reads the delta content on demand with `yui task wake show <wake-id>` and
+ * the full projection with `yui task context <task>`.
+ *
+ * The envelope is mode-agnostic: fresh generations and resumed generations
+ * receive the same minimal text. The native Session is a disposable cache of
+ * working context; Yui's durable Task records (including the wake ledger) are
+ * the checkpoint.
+ */
+/** Structural guardrail: the envelope must stay an order of magnitude below any context budget. */
+export const WAKE_ENVELOPE_HARD_BYTES = 2_000;
+/** Maximum reason tags rendered before elision to a count. */
+const REASON_DISPLAY_LIMIT = 6;
+export function buildTaskWakeEnvelope(reader, request) {
+    const task = reader.getTask(request.taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${request.taskId}.`);
+    if (request.reasons.length === 0) {
+        throw new Error(`Wake envelope ${request.wakeId} must carry at least one reason.`);
+    }
+    const fromTime = Date.parse(request.fromCursor);
+    const counts = {
+        events: reader.listEvents(request.taskId)
+            .filter((record) => Date.parse(record.createdAt) > fromTime).length,
+        messages: reader.listMessages(request.taskId)
+            .filter((record) => Date.parse(record.createdAt) > fromTime).length,
+        runs: reader.listAgentRuns(request.taskId)
+            .filter((record) => Date.parse(record.createdAt) > fromTime).length
+    };
+    const lines = [
+        `Wake: ${request.wakeId} — delta since ${request.fromCursor}`,
+        `  Reasons: ${renderReasons(request.reasons)}`,
+        `  Changed: ${counts.events} events, ${counts.messages} messages, ${counts.runs} runs`
+            + ` → yui task wake show ${request.taskId} ${request.wakeId}`,
+        `Full context: yui task context ${request.taskId}`
+    ];
+    const body = lines.join("\n");
+    const totalBytes = byteLength(body) + 1;
+    if (totalBytes > WAKE_ENVELOPE_HARD_BYTES) {
+        throw new Error(`Wake envelope ${request.wakeId} exceeds the structural hard budget of`
+            + ` ${WAKE_ENVELOPE_HARD_BYTES} bytes (${totalBytes}).`);
+    }
+    return Object.freeze({
+        taskId: request.taskId,
+        wakeId: request.wakeId,
+        fromCursor: request.fromCursor,
+        totalBytes,
+        text: `${body}\n`
+    });
+}
+function renderReasons(reasons) {
+    const selected = reasons.slice(0, REASON_DISPLAY_LIMIT);
+    const elided = reasons.length - selected.length;
+    const rendered = selected.map(renderWakeReason).join(", ");
+    return elided === 0 ? rendered : `${rendered}, … (+${elided} more)`;
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}

package/dist/controller/clientRuntime.js

@@ -20,7 +20,6 @@ const ENVIRONMENT_REFRESH_TIMEOUT_MS = 500;
 const CONFIGURATION_REFRESH_TIMEOUT_MS = 500;
 const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     ...AGENT_OPERATIONAL_ENVIRONMENT_NAMES,
-    "YUI_TMUX_BIN",
     // Issue 01: YUI_STORE_BACKEND/YUI_STORE_WORKER are reserved for tests and
     // explicit recovery commands. A Controller spawned by such a command must
     // inherit the forced backend; otherwise a layout-7 test Home silently opens
@@ -30,6 +29,8 @@ const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     // rr13/test: Forward the liveness seam so an integration test's Controller
     // subprocess does not reap a saved active Leader Run without a real tmux role.
     "YUI_TEST_ROLE_LIVENESS_PRESENT",
+    // Issue 02: agent-signal-driven launch monitoring is Controller-owned.
+    "YUI_LAUNCH_INACTIVITY_TIMEOUT_MS",
     ...EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES
 ];
 /**

package/dist/controller/ephemeralResourceReaper.js

@@ -84,7 +84,8 @@ export function createEphemeralResourceReaper(options) {
     return () => reapExpiredEphemeralResources({
         scan,
         clean: (resource) => cleanControllerResource(resource, {
-            environment: options.environment
+            environment: options.environment,
+            tmuxBin: options.tmuxBin
         }),
         onExpiredDomain: options.onExpiredDomain
     });