@zq-silk/yui 0.11.3 → 0.12.1

package/dist/commands/taskRoleRuntimeStatus.js

@@ -8,6 +8,8 @@ import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
+import { freshConversationLaunchBlockers, projectConversationSwitch } from "../runtime/conversationSwitch.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -65,6 +67,12 @@ export function renderTaskRoleRuntimeStatus(status) {
                     ? ""
                     : ` (${status.runtime.observerDetail})`}`
         ].filter((value) => value !== undefined).join("; ");
+    const sessionTokens = [
+        `total=${sessionCumulativeTokenLabel(status.sessionTokens)}`,
+        `max-request-input=${status.sessionTokens.maximumRequestInput.status === "observed"
+            ? status.sessionTokens.maximumRequestInput.inputTokens
+            : "unobserved"}`
+    ].join("; ");
     return [
         `Task Role status: ${status.taskId}/${status.roleName}`,
         "",
@@ -86,9 +94,15 @@ export function renderTaskRoleRuntimeStatus(status) {
             ? `needs-attention (${status.stall.kind ?? "workflow-not-progressing"}; no workflow progress since ${status.stall.progressAt ?? "unknown"})`
             : "none"}`,
         `  Native session   ${nativeSession}`,
+        `  Session switch   ${status.conversationSwitch === null
+            ? "none"
+            : `${status.conversationSwitch.status} (${status.conversationSwitch.requestId}; ${status.conversationSwitch.reason})`}`,
         `  Agent runtime    ${runtime}`,
+        `  Session tokens   ${sessionTokens}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
-        `  Fresh launch     ${status.freshLaunchAllowed ? "allowed" : "blocked"}`,
+        `  Fresh launch     ${status.freshLaunchAllowed
+            ? "allowed"
+            : `blocked (${status.freshLaunchBlockers.join(", ")})`}`,
         `  tmux pane        ${tmux}`,
         `  Workspace        ${status.workspace.managed ? status.workspace.root : status.workspace.path}`,
         ...workspaceDetails
@@ -109,19 +123,30 @@ export function taskRoleLastRunLabel(status) {
 }
 export function taskRoleNativeSessionLabel(status) {
     if (status.runtimeCleanupPending && status.nativeSession === null)
-        return "reset (cleanup-pending)";
+        return "unbound (cleanup-pending)";
     return status.nativeSession?.status ?? "unbound";
 }
 export function inspectTaskRoleSessionRecovery(taskId, roleName, store) {
     const sessions = store.getTaskRoleSessionSet(taskId, roleName);
     const target = runtimeLifecycleTarget({ scope: "task", taskId, roleName });
     const runtimeMailbox = store.getWorkMailbox(target);
+    const roleMailbox = store.getWorkMailbox({ kind: "role", taskId, roleName });
+    const switchBlockers = freshConversationLaunchBlockers({
+        sessions,
+        events: store.listEvents(taskId),
+        mailbox: roleMailbox,
+        roleName
+    });
+    const freshLaunchBlockers = [
+        ...switchBlockers,
+        ...(hasRuntimeLifecycleWork(runtimeMailbox) ? ["runtime-lifecycle-busy"] : [])
+    ];
     return {
         taskId,
         roleName,
         runtimeCleanupPending: hasRuntimeCleanupObligation(runtimeMailbox),
-        freshLaunchAllowed: (sessions === null
-            || sessions.sessions[sessions.activeAgentId] === undefined) && !hasRuntimeLifecycleWork(runtimeMailbox)
+        freshLaunchAllowed: freshLaunchBlockers.length === 0,
+        freshLaunchBlockers
     };
 }
 export function taskRoleOpenInputLabel(status) {
@@ -178,6 +203,10 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
+    const conversationSwitch = projectConversationSwitch(events, role.name, sessions);
+    const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
+        ? null
+        : { taskId, roleName: role.name, ...nativeSession }));
     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
@@ -213,13 +242,29 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         nativeSession,
         tmux,
         workspace,
+        sessionTokens,
+        conversationSwitch,
         runtime,
         stall
     };
 }
+function sessionCumulativeTokenLabel(metrics) {
+    const total = metrics.cumulativeTotal;
+    if (total.status === "unobserved")
+        return "unobserved";
+    const breakdown = [
+        `input=${total.inputTokens}`,
+        `output=${total.outputTokens}`,
+        ...(total.cachedInputTokens === undefined ? [] : [`cached-input=${total.cachedInputTokens}`]),
+        ...(total.reasoningTokens === undefined ? [] : [`reasoning=${total.reasoningTokens}`])
+    ];
+    return `${total.totalTokens} (${breakdown.join(", ")})`;
+}
 function latestStallKind(events, runId) {
     const event = [...events]
-        .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)
+        .filter((candidate) => candidate.type === "run.stalled"
+        && candidate.payload.runId === runId
+        && candidate.payload.status !== "diagnostic-only")
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return event?.payload.kind === "delivery-stalled" || event?.payload.kind === "workflow-not-progressing"
         ? event.payload.kind
@@ -229,7 +274,7 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
     if (runtimeCleanupPending && nativeSession === null) {
         return {
             health: "needs-attention",
-            healthReason: "the native Session was reset; verified runtime cleanup is pending"
+            healthReason: "the native Session is unbound; verified runtime cleanup is pending"
         };
     }
     if (role.status === "failed" || role.status === "exited") {
@@ -291,12 +336,15 @@ function calculateHealth(role, activeRun, lastRun, nativeSession, runtimeCleanup
                 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 "diagnostic-needed":
+                    return runtime.observerStatus === "degraded" || runtime.observerStatus === "unavailable"
+                        ? { health: "needs-attention", healthReason: runtime.healthReason }
+                        : { health: "running", healthReason: runtime.healthReason };
                 case "waiting-user":
                     return { health: "blocked-input", healthReason: runtime.healthReason };
                 case "waiting-permission":

package/dist/commands/taskWorkspaceCommands.js

@@ -99,8 +99,11 @@ function replaceTaskCommand(args, store, options) {
     const old = store.getTask(oldId);
     if (old === null)
         throw usageError(`Task not found: ${oldId}.`);
-    if (old.status === "draft" || old.status === "active") {
-        throw usageError(`Task is open and can be rebuilt instead of replaced: ${old.id}.`);
+    if (old.status === "draft") {
+        throw usageError(`Draft Task ${old.id} owns no workspace to replace or rebuild; activate it or retire it and create a new Draft.`);
+    }
+    if (old.status === "active") {
+        throw usageError(`Active Task can be rebuilt instead of replaced: ${old.id}.`);
     }
     let title = `Replaces ${old.id}: ${old.title}`;
     for (let index = 1; index < args.length; index += 1) {

package/dist/config/configCatalog.js

@@ -13,7 +13,7 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "time-zone", domain: "system", property: "timeZone", label: "Time zone", summary: "IANA timezone for human-facing timestamps (default: Asia/Shanghai).", takesEffect: "The next human-readable timestamp rendering; durable JSON remains UTC." },
     { key: "reconciliation-interval-seconds", domain: "runtime", property: "reconciliationIntervalSeconds", label: "Reconciliation interval", summary: "Recovery reconciliation interval, 5-300 seconds (default: 120).", takesEffect: "The running Controller is refreshed after the value is saved." },
     { key: "controller-task-concurrency", domain: "runtime", property: "controllerTaskConcurrency", label: "Controller Task concurrency", summary: "Maximum Tasks reconciled concurrently, 1-32 (default: 4).", takesEffect: "After the Controller restarts." },
-    { key: "runtime-health", domain: "runtime", property: "runtimeHealth", label: "Runtime health thresholds", summary: "Quiet, diagnostic, and semantic-stall thresholds in seconds; values must be strictly increasing (defaults: 300/600/1800).", takesEffect: "CLI and Web projections immediately; scheduler stall handling after the Controller restarts." },
+    { key: "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." },
@@ -22,8 +22,8 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "provider-retry-max-window-seconds", domain: "runtime", property: "providerRetryMaxWindowSeconds", label: "Provider retry max window", summary: "Positive-integer total retry budget per Run lineage in seconds (default: 600).", takesEffect: "The next retry episode; an active episode keeps its existing deadline." },
     { key: "leader-next-action", domain: "workflow", property: "leaderNextActionMode", label: "Leader next-action mode", summary: "Leader next-action mode: display, warn, or enforce (default: display).", takesEffect: "The next Leader next-action projection or gate." },
     { key: "leader-semantic-budget-turns", domain: "workflow", property: "leaderSemanticBudgetTurns", label: "Leader semantic budget", summary: "Consecutive yielded Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
-    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Context budget", summary: `Per-Session context token budget; soft and hard are ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}, with soft below hard (defaults: 100000/120000).`, takesEffect: "The next context-budget evaluation; retained conversation content is unchanged." },
-    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger; optional finding-ledger and delta-recheck controls. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
+    { key: "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." },
+    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger and optional finding-ledger behavior. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
     { key: "resources-gc-mode", domain: "resources", property: "resourcesGcMode", label: "Resources GC mode", summary: "Resource GC mode: report or quarantine (default: report).", takesEffect: "The next resource GC operation." },
     { key: "resources-gc-auto-quarantine", domain: "resources", property: "resourcesGcAutoQuarantine", label: "Resources GC auto-quarantine", summary: "Automatically quarantine eligible terminal Task resources (default: false).", takesEffect: "The next eligible automatic resource GC operation." },
     { key: "resources-quarantine-ttl-hours", domain: "resources", property: "resourcesQuarantineTtlHours", label: "Resource quarantine TTL", summary: "Default observation window before purge, 1-720 hours (default: 24).", takesEffect: "The next resource GC command without an explicit TTL override." },

package/dist/config/yuiConfig.js

@@ -227,13 +227,9 @@ export function resolveTmuxHistoryLimit(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");
 }
 /**
- * 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.
+ * Compatibility parser for the retired context-budget setting. Existing
+ * Homes may retain these values, but no runtime, scheduler, or lifecycle path
+ * consumes them. Session Token metrics are an independent read-only view.
  */
 export const DEFAULT_CONTEXT_SOFT_TOKENS = 100_000;
 export const DEFAULT_CONTEXT_HARD_TOKENS = 120_000;

package/dist/context/wakeNotification.js

@@ -4,17 +4,18 @@ import { operationalTaskRecords } from "../task/taskRecordRetirement.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>`.
+ * carries only what the Agent needs for immediate orientation: the wake id,
+ * aggregated reason tags, delta window, and a bounded list of active frozen
+ * Task Reviews. The Agent reads 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. */
+/** Structural guardrail: the envelope stays far below a normal model context window. */
 export const WAKE_ENVELOPE_HARD_BYTES = 2_000;
 /** Maximum reason tags rendered before elision to a count. */
 const REASON_DISPLAY_LIMIT = 6;
@@ -35,11 +36,25 @@ export function buildTaskWakeEnvelope(reader, request) {
         runs: operationalTaskRecords(reader.listAgentRuns(request.taskId), events, "agent-run")
             .filter((record) => Date.parse(record.createdAt) > fromTime).length
     };
+    const activeReviews = reader.listReviewRounds(request.taskId).filter((round) => ((round.scope ?? "work-item") === "task"
+        && (round.status === "pending" || round.status === "running")));
+    const reviewOrientation = activeReviews.slice(0, 3).map((round) => {
+        const projects = round.taskCandidate?.projects ?? [];
+        const heads = projects.slice(0, 2).map(({ projectId, commit }) => (`${projectId}@${commit.slice(0, 12)}`)).join("+");
+        return `${round.id}/${round.reviewerRoleName}`
+            + `/${round.deltaRecheck === undefined ? "full" : "delta"}`
+            + `[${round.status}]`
+            + `@${heads || round.reviewBaseCommit.slice(0, 12)}`
+            + `${projects.length > 2 ? `+${projects.length - 2}` : ""}`;
+    }).join(", ");
     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}`,
+        `  Active Task Reviews: ${activeReviews.length === 0
+            ? "none"
+            : `${reviewOrientation}${activeReviews.length > 3 ? `, … (+${activeReviews.length - 3})` : ""}`}`,
         `Full context: yui task context ${request.taskId}`
     ];
     const body = lines.join("\n");