@zq-silk/yui 0.6.13 → 0.6.15

package/dist/runtime/providerContinuationReconciliationService.js

@@ -116,6 +116,7 @@ function sameContinuationState(left, right) {
         && left.attachment === right.attachment
         && left.observation === right.observation
         && left.mayWriteWorkspace === right.mayWriteWorkspace
+        && left.durability === right.durability
         && left.resultRef === right.resultRef
         && left.lastProviderSequence === right.lastProviderSequence
         && left.identityConflict === right.identityConflict;

package/dist/runtime/providerErrorCodes.js

@@ -0,0 +1,278 @@
+/**
+ * Provider-neutral structured error taxonomy.
+ *
+ * Each Agent Driver parses its own Provider's raw failure text into one of
+ * these codes at the driver boundary. The retry classifier then maps codes to
+ * Yui error classes by lookup — no Provider-specific regex lives in the
+ * classifier. Text matching remains only as a fallback for drivers that
+ * cannot yet produce a structured code.
+ */
+/**
+ * Maps each structured code to its Yui error class. This is the single
+ * authoritative lookup that replaces regex matching in the classifier.
+ */
+export const PROVIDER_ERROR_CODE_CLASS = Object.freeze({
+    // Stream/transport → transport-uncertain (delivery may have happened)
+    "stream-internal-error": "transport-uncertain",
+    "stream-protocol-error": "transport-uncertain",
+    "stream-error": "transport-uncertain",
+    "connection-reset": "transport-uncertain",
+    "connection-lost": "transport-uncertain",
+    timeout: "transport-uncertain",
+    // HTTP 5xx / capacity → transient-provider
+    "http-5xx": "transient-provider",
+    overloaded: "transient-provider",
+    "server-error": "transient-provider",
+    // HTTP 429 → transient-provider (retryable with backoff)
+    "http-429": "transient-provider",
+    // HTTP 4xx → invalid-request (non-retryable)
+    "http-4xx": "invalid-request",
+    // Policy
+    "policy-denied": "policy-denied",
+    // Session
+    "session-not-found": "session-dead",
+    "session-expired": "session-dead",
+    "session-ended": "session-dead",
+    "process-exited": "session-dead",
+    // Request
+    "invalid-request": "invalid-request",
+    unknown: "unclassified"
+});
+/** Whether a structured code is retryable in place. */
+export function isRetryableErrorCode(code) {
+    const cls = PROVIDER_ERROR_CODE_CLASS[code];
+    return cls === "transient-provider" || cls === "transport-uncertain";
+}
+// ── Claude Code driver ──────────────────────────────────────────────────
+/**
+ * Parses a Claude Code StopFailure `error` string into a structured code.
+ *
+ * Claude sends structured API error codes (server_error, overloaded_error,
+ * rate_limit_error, etc.) as the `error` field, and raw transport text
+ * ("stream error: stream ID …; INTERNAL_ERROR") in error_details or the
+ * CLI's own output. This function handles both.
+ */
+export function parseClaudeError(error, details) {
+    const text = [error, details]
+        .filter((v) => typeof v === "string" && v.length > 0)
+        .join("\n");
+    // ── Structured Claude API error codes ──────────────────────────────
+    // Claude's StopFailure hook sends these as the `error` field.
+    if (/^server_error$/iu.test(text)) {
+        return { code: "server-error", raw: error };
+    }
+    if (/^overloaded_error$/iu.test(text)) {
+        return { code: "overloaded", raw: error };
+    }
+    if (/^rate_limit_error$/iu.test(text)) {
+        return { code: "http-429", raw: error };
+    }
+    if (/^invalid_request_error$/iu.test(text)) {
+        return { code: "invalid-request", raw: error };
+    }
+    if (/^(authentication_error|permission_error)$/iu.test(text)) {
+        return { code: "policy-denied", raw: error };
+    }
+    if (/^not_found_error$/iu.test(text)) {
+        return { code: "session-not-found", raw: error };
+    }
+    if (/^api_error$/iu.test(text)) {
+        return { code: "server-error", raw: error };
+    }
+    // Claude CLI structured error codes (e.g. "[claude-code:unrecognized_model]")
+    if (/\[claude-code:(unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)) {
+        return { code: "invalid-request", raw: error };
+    }
+    // HTTP/2 RST_STREAM (the Task-27 failure mode)
+    if (/stream error:.*INTERNAL_ERROR/iu.test(text)) {
+        return { code: "stream-internal-error", raw: error };
+    }
+    if (/stream error:.*PROTOCOL_ERROR/iu.test(text)) {
+        return { code: "stream-protocol-error", raw: error };
+    }
+    if (/stream error/iu.test(text)) {
+        return { code: "stream-error", raw: error };
+    }
+    // "Server error mid-response" and similar
+    if (/server[\s_-]?error/iu.test(text)) {
+        return { code: "server-error", raw: error };
+    }
+    // HTTP status codes
+    if (/\b429\b/u.test(text))
+        return { code: "http-429", raw: error };
+    if (/\b40[0-9]\b/u.test(text))
+        return { code: "http-4xx", raw: error };
+    if (/\b50[024]\b/u.test(text))
+        return { code: "http-5xx", raw: error };
+    // Connection
+    if (/connection[\s_-]?reset/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    if (/connection[\s_-]?lost/iu.test(text))
+        return { code: "connection-lost", raw: error };
+    if (/econnreset/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    if (/socket hang up/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    // Timeout
+    if (/timed?[ -]?out/iu.test(text))
+        return { code: "timeout", raw: error };
+    if (/etimedout/iu.test(text))
+        return { code: "timeout", raw: error };
+    // Capacity
+    if (/overloaded/iu.test(text))
+        return { code: "overloaded", raw: error };
+    if (/rate[\s_-]?limit/iu.test(text))
+        return { code: "http-429", raw: error };
+    // Policy
+    if (/cyber[_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/policy[\s_-]?violation/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/usage[\s_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/content[\s_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/safety[\s_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    // Session lifecycle
+    if (/session[\s_-]?not[\s_-]?found/iu.test(text))
+        return { code: "session-not-found", raw: error };
+    if (/no[\s_-]?such[\s_-]?(session|thread)/iu.test(text))
+        return { code: "session-not-found", raw: error };
+    if (/thread[\s_-]?not[\s_-]?found/iu.test(text))
+        return { code: "session-not-found", raw: error };
+    if (/session[\s_-]?(has[\s_-]?)?expired/iu.test(text))
+        return { code: "session-expired", raw: error };
+    if (/session[\s_-]?(has[\s_-]?)?ended/iu.test(text))
+        return { code: "session-ended", raw: error };
+    if (/process[\s_-]?exited/iu.test(text))
+        return { code: "process-exited", raw: error };
+    // Request validity
+    if (/invalid[\s_-]?request/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    if (/validation[\s_-]?error/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    if (/bad[\s_-]?request/iu.test(text))
+        return { code: "http-4xx", raw: error };
+    if (/unknown[\s_-]?(flag|tool|argument)/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    return { code: "unknown", raw: error };
+}
+// ── Codex driver ────────────────────────────────────────────────────────
+/**
+ * Parses a Codex CLI failure into a structured code.
+ *
+ * Codex surfaces errors through process exit, transcript messages, and
+ * stream-level failures. Its error formats overlap with Claude's (HTTP/2
+ * stream errors, API status codes) but also include Codex-specific patterns.
+ */
+export function parseCodexError(error, details) {
+    const text = [error, details]
+        .filter((v) => typeof v === "string" && v.length > 0)
+        .join("\n");
+    // ── Structured API error codes ────────────────────────────────────
+    if (/^server_error$/iu.test(text)) {
+        return { code: "server-error", raw: error };
+    }
+    if (/^overloaded_error$/iu.test(text)) {
+        return { code: "overloaded", raw: error };
+    }
+    if (/^rate_limit_error$/iu.test(text)) {
+        return { code: "http-429", raw: error };
+    }
+    if (/^invalid_request_error$/iu.test(text)) {
+        return { code: "invalid-request", raw: error };
+    }
+    if (/^(authentication_error|permission_error)$/iu.test(text)) {
+        return { code: "policy-denied", raw: error };
+    }
+    // Codex CLI structured error codes
+    if (/\[codex:(unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)) {
+        return { code: "invalid-request", raw: error };
+    }
+    // Model not supported / invalid model (non-retryable)
+    if (/model.*not supported|invalid.*model|model.*not found/iu.test(text)) {
+        return { code: "invalid-request", raw: error };
+    }
+    // Stream disconnected (retryable transport)
+    if (/stream disconnected/iu.test(text)) {
+        return { code: "stream-error", raw: error };
+    }
+    // ── Stream / transport ────────────────────────────────────────────
+    if (/stream error:.*INTERNAL_ERROR/iu.test(text)) {
+        return { code: "stream-internal-error", raw: error };
+    }
+    if (/stream error:.*PROTOCOL_ERROR/iu.test(text)) {
+        return { code: "stream-protocol-error", raw: error };
+    }
+    if (/stream error/iu.test(text)) {
+        return { code: "stream-error", raw: error };
+    }
+    // ── HTTP status codes ─────────────────────────────────────────────
+    if (/\b429\b/u.test(text))
+        return { code: "http-429", raw: error };
+    if (/\b40[0-9]\b/u.test(text))
+        return { code: "http-4xx", raw: error };
+    if (/\b50[024]\b/u.test(text))
+        return { code: "http-5xx", raw: error };
+    // ── Server / capacity ─────────────────────────────────────────────
+    if (/server[\s_-]?error/iu.test(text)) {
+        return { code: "server-error", raw: error };
+    }
+    if (/overloaded/iu.test(text))
+        return { code: "overloaded", raw: error };
+    if (/rate[\s_-]?limit/iu.test(text))
+        return { code: "http-429", raw: error };
+    if (/bad gateway/iu.test(text))
+        return { code: "http-5xx", raw: error };
+    if (/gateway timeout/iu.test(text))
+        return { code: "timeout", raw: error };
+    if (/service unavailable/iu.test(text))
+        return { code: "http-5xx", raw: error };
+    if (/temporarily unavailable/iu.test(text))
+        return { code: "http-5xx", raw: error };
+    // ── Connection ────────────────────────────────────────────────────
+    if (/connection[\s_-]?reset/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    if (/connection[\s_-]?lost/iu.test(text))
+        return { code: "connection-lost", raw: error };
+    if (/econnreset/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    if (/socket hang up/iu.test(text))
+        return { code: "connection-reset", raw: error };
+    // ── Timeout ───────────────────────────────────────────────────────
+    if (/timed?[ -]?out/iu.test(text))
+        return { code: "timeout", raw: error };
+    if (/etimedout/iu.test(text))
+        return { code: "timeout", raw: error };
+    // ── Policy ────────────────────────────────────────────────────────
+    if (/cyber[_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/policy[\s_-]?violation/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/usage[\s_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    if (/content[\s_-]?policy/iu.test(text))
+        return { code: "policy-denied", raw: error };
+    // ── Session ───────────────────────────────────────────────────────
+    if (/session[\s_-]?not[\s_-]?found/iu.test(text))
+        return { code: "session-not-found", raw: error };
+    if (/no[\s_-]?such[\s_-]?(session|thread)/iu.test(text))
+        return { code: "session-not-found", raw: error };
+    if (/session[\s_-]?(has[\s_-]?)?expired/iu.test(text))
+        return { code: "session-expired", raw: error };
+    if (/session[\s_-]?(has[\s_-]?)?ended/iu.test(text))
+        return { code: "session-ended", raw: error };
+    if (/process[\s_-]?exited/iu.test(text))
+        return { code: "process-exited", raw: error };
+    // ── Request validity ──────────────────────────────────────────────
+    if (/invalid[\s_-]?request/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    if (/validation[\s_-]?error/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    if (/bad[\s_-]?request/iu.test(text))
+        return { code: "http-4xx", raw: error };
+    if (/unknown[\s_-]?(flag|tool|argument)/iu.test(text))
+        return { code: "invalid-request", raw: error };
+    return { code: "unknown", raw: error };
+}

package/dist/runtime/runtimeHealthPolicy.js

@@ -0,0 +1,20 @@
+/**
+ * Single source of truth for runtime health thresholds shared by the CLI
+ * status projection, the Web snapshot, and the scheduler stall pass.
+ *
+ * The layers are deliberately time-based and conservative: short silence is
+ * normal for high-reasoning-effort turns, large reviews, and tool waits.
+ * Only deterministic dead/broken evidence or the durable semantic stall
+ * window authorizes recovery; quiet time alone never resets a Run.
+ */
+/** Runtime silence after which a live turn is surfaced as "quiet" (hint only). */
+export const RUNTIME_QUIET_AFTER_MS = 5 * 60_000;
+/** No durable semantic progress after which a read-only diagnostic is warranted. */
+export const RUNTIME_DIAGNOSTIC_AFTER_MS = 10 * 60_000;
+/** No durable semantic progress after which the scheduler raises a stall candidate. */
+export const SEMANTIC_STALL_WINDOW_MS = 30 * 60_000;
+export const DEFAULT_RUNTIME_HEALTH_POLICY = Object.freeze({
+    quietAfterMs: RUNTIME_QUIET_AFTER_MS,
+    diagnosticAfterMs: RUNTIME_DIAGNOSTIC_AFTER_MS,
+    stallWindowMs: SEMANTIC_STALL_WINDOW_MS
+});

package/dist/runtime/runtimeObservation.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { requireDriverId } from "./agentDriver.js";
 export const RUNTIME_OBSERVATION_TASK_EVENT = "runtime.observation";
 const KINDS = [
@@ -405,7 +406,11 @@ export function runtimeObservationSemanticKey(input) {
         ].join(":");
     }
     if (input.kind === "continuation.reported") {
-        return ["continuation-report", ...continuationIdentity, input.payload?.reportId ?? "missing"]
+        const summary = input.payload?.summary?.trim();
+        const resultIdentity = summary === undefined || summary.length === 0
+            ? input.payload?.reportId ?? "missing"
+            : `sha256:${createHash("sha256").update(summary).digest("hex")}`;
+        return ["continuation-report", ...continuationIdentity, resultIdentity]
             .join(":");
     }
     if (input.kind === "continuation.started") {
@@ -453,6 +458,7 @@ function normalizeFailure(input) {
         throw new Error("Runtime failure evidence must be an object.");
     }
     return Object.freeze({
+        ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
         code: requireText(input.code, "Runtime failure code"),
         ...(input.details === undefined
             ? {}

package/dist/runtime/runtimeProjection.js

@@ -1,4 +1,5 @@
 import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches } from "./runtimeObservation.js";
+import { DEFAULT_RUNTIME_HEALTH_POLICY } from "./runtimeHealthPolicy.js";
 export function createRuntimeProjection(fence, createdAt) {
     const timestamp = requireTimestamp(createdAt);
     return Object.freeze({
@@ -313,34 +314,125 @@ export function runtimeDisplayStatus(current) {
         return "runtime-unobservable";
     return "starting";
 }
-export function evaluateRuntimeAttention(current, now, policy) {
-    const display = runtimeDisplayStatus(current);
+/**
+ * Classify one RuntimeProjection into the layered health state shared by CLI,
+ * Web, and scheduler. The semantic progress timestamp is the same durable
+ * fence the scheduler stall pass consumes (deliveredAt plus Work/Review/
+ * Integration checkpoints), so token/tool/CPU activity can never masquerade
+ * as business progress.
+ *
+ * Layers below the durable stall window are advisory: `quiet` and
+ * `diagnostic-needed` never authorize a reset. The 30-minute semantic stall is
+ * persisted by the scheduler and surfaced as `stalled-candidate` by the
+ * caller; this function deliberately stops at `diagnostic-needed` so the
+ * Leader's waiting-user/waiting-on-workers classification stays authoritative.
+ */
+export function classifyRuntimeHealth(input) {
+    const policy = input.policy ?? DEFAULT_RUNTIME_HEALTH_POLICY;
+    const current = input.projection;
+    const semanticMs = Date.parse(input.semanticProgressAt);
+    if (!Number.isFinite(semanticMs)) {
+        throw new Error("Runtime health semantic progress timestamp is invalid.");
+    }
     const runtimeIdleMs = current.lastRuntimeActivityAt === undefined
         ? Number.POSITIVE_INFINITY
-        : now.getTime() - Date.parse(current.lastRuntimeActivityAt);
-    const semanticIdleMs = now.getTime() - Date.parse(current.workflow.lastSemanticProgressAt);
-    const runtime = display === "broken"
-        ? "broken"
-        : display === "stopped"
-            ? "stopped"
-            : display === "runtime-unobservable"
-                ? "unobservable"
-                : display.startsWith("waiting-")
-                    ? "waiting"
-                    : runtimeIdleMs <= policy.runtimeSilenceMs
-                        ? "healthy"
-                        : Object.keys(current.operations).length > 0
-                            ? "active-operation-quiet"
-                            : "quiet";
+        : input.now.getTime() - Date.parse(current.lastRuntimeActivityAt);
+    const semanticIdleMs = input.now.getTime() - semanticMs;
+    const activeOperations = Object.entries(current.operations)
+        .map(([id, operation]) => `${operation.kind}:${id}`);
+    const base = {
+        lastSemanticProgressAt: input.semanticProgressAt,
+        activeOperations,
+        host: current.host,
+        observerStatus: current.observer.status,
+        runtimeIdleMs,
+        semanticIdleMs,
+        ...(current.lastRuntimeActivityAt === undefined
+            ? {}
+            : { lastRuntimeActivityAt: current.lastRuntimeActivityAt })
+    };
+    const operation = dominantOperation(current.operations);
+    const layer = classifyLayer(current, operation, runtimeIdleMs, semanticIdleMs, policy);
     return Object.freeze({
-        runtime,
-        workflow: current.workflow.completed
-            ? "completed"
-            : semanticIdleMs > policy.semanticSilenceMs
-                ? "not-progressing"
-                : "progressing"
+        layer,
+        reason: runtimeHealthReason(layer, current),
+        ...base
     });
 }
+function classifyLayer(current, operation, runtimeIdleMs, semanticIdleMs, policy) {
+    // Deterministic terminal evidence is immediate: no waiting for any window.
+    if (current.session === "failed")
+        return "broken";
+    if (current.host === "exited" || current.session === "ended")
+        return "stopped";
+    // Recent structured runtime activity is the strongest liveness signal.
+    if (operation === "subagent")
+        return "subagent-active";
+    if (operation === "tool")
+        return "tool-active";
+    if (operation === "model")
+        return "model-active";
+    // An incomplete observer signal warrants a read-only diagnostic, but a
+    // dominant operation above is still trusted as the most recent fact.
+    if (current.observer.status === "degraded" || current.observer.status === "unavailable") {
+        return "diagnostic-needed";
+    }
+    if (current.turn === "waiting") {
+        return `waiting-${current.waitingReason ?? "external"}`;
+    }
+    // No durable semantic progress past the diagnostic window: read-only look.
+    if (semanticIdleMs >= policy.diagnosticAfterMs)
+        return "diagnostic-needed";
+    // A live turn with no recent structured activity is quiet, not dead.
+    if (runtimeIdleMs >= policy.quietAfterMs)
+        return "quiet";
+    if (current.turn === "accepted" || current.session === "active")
+        return "active-quiet";
+    if (current.session === "ready"
+        || current.turn === "completed"
+        || current.turn === "failed"
+        || current.turn === "cancelled")
+        return "ready";
+    if (current.session === "started")
+        return "awaiting-provider-acceptance";
+    if (current.host === "alive")
+        return "runtime-unobservable";
+    return "starting";
+}
+function runtimeHealthReason(layer, current) {
+    switch (layer) {
+        case "broken":
+            return "the Agent Driver runtime is broken";
+        case "stopped":
+            return "the Provider Activation ended while the Yui Run remains active";
+        case "subagent-active":
+        case "tool-active":
+        case "model-active":
+            return `the Agent Driver reports ${layer.replaceAll("-", " ")}`;
+        case "diagnostic-needed":
+            if (current.observer.status === "degraded" || current.observer.status === "unavailable") {
+                return `the runtime observer is ${current.observer.status}; read-only diagnostic recommended`;
+            }
+            return "no durable semantic progress in the diagnostic window; read-only diagnostic recommended";
+        case "quiet":
+            return "the Agent turn is active but has reported no structured runtime activity recently";
+        case "active-quiet":
+            return "the Agent Driver reports active quiet";
+        case "waiting-user":
+        case "waiting-permission":
+        case "waiting-external":
+            return `the Agent Driver is ${layer.replaceAll("-", " ")}`;
+        case "ready":
+            return "the Agent turn ended while the workflow Run is still active";
+        case "awaiting-provider-acceptance":
+            return "the pushed active Run is awaiting provider acceptance";
+        case "runtime-unobservable":
+            return "the host is present but the Agent Driver exposes no current runtime state";
+        case "starting":
+        default:
+            return "the Agent Driver runtime is starting";
+    }
+}
 function withActivity(current, kind, at) {
     return next(current, {
         activity: Object.freeze({ kind, observedAt: at }),