@zq-silk/yui 0.13.8 → 0.13.10

package/dist/storage/taskStore.js

@@ -6,7 +6,7 @@ import { validateConfiguredAgent } from "../agent/agent.js";
 import { validateCapabilityGrant } from "../grant/capabilityGrant.js";
 import { validateReleaseWorkflow } from "../release/releaseWorkflow.js";
 import { publicationExternalKey, validatePublicationReference } from "../task/publicationReference.js";
-import { 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 { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
@@ -15,7 +15,6 @@ import { validateInputRequest } from "../input/inputRequest.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
 import { validateTaskMessage } from "../message/message.js";
 import { agentRunDeliveryReceiptId, validateAgentRun } from "../run/agentRun.js";
-import { providerRetryWakeAt } from "../run/providerRetry.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { FileSessionOwnerRegistry } from "../runtime/sessionOwnerRegistry.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
@@ -45,7 +44,7 @@ import { CURRENT_AGGREGATE_SCHEMA_VERSION, requireCompatibleStorageSchema, requi
 export const STORAGE_STATE_FILE = "state.json";
 /** The root StorageState schema is the persisted aggregate document version. */
 export const CURRENT_STORAGE_STATE_SCHEMA_VERSION = CURRENT_AGGREGATE_SCHEMA_VERSION;
-export const CURRENT_CONFIG_SCHEMA_VERSION = 3;
+export const CURRENT_CONFIG_SCHEMA_VERSION = 4;
 export const CURRENT_HOME_IDENTITY_SCHEMA_VERSION = 1;
 export const CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION = 3;
 /**
@@ -60,7 +59,7 @@ export const CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION = 2;
 export const CURRENT_PROJECT_SCHEMA_VERSION = 5;
 export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
 export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
-export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
+export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 4;
 export const CURRENT_TASK_SCHEMA_VERSION = 6;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -77,9 +76,9 @@ export const CURRENT_MILESTONE_SCHEMA_VERSION = 2;
 export const CURRENT_EVENT_SCHEMA_VERSION = 2;
 export const CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION = 1;
 export const CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION = 1;
-export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 2;
+export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 3;
 export const CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION = 1;
-export const CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION = 3;
+export const CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION = 4;
 export const CURRENT_PENDING_WAKEUP_SCHEMA_VERSION = 1;
 const STORAGE_LOCK_DIRECTORY = ".state.lock";
 const LOCK_TIMEOUT_MS = 5_000;
@@ -118,13 +117,13 @@ export const CURRENT_STORED_TASK_SCHEMA_VERSION = 18;
  * Keep these named at the storage boundary so the upgrade record-axis map can
  * assert it is classifying the same bytes the store reads and writes.
  */
-export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 7;
+export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 8;
 /**
  * v7 combines optional Issue 04 retry/receipt fields and Issue 05 Leader
  * actionability fields. All are optional, so the v6→v7 migration is a
  * version-only rewrite.
  */
-export const CURRENT_AGENT_RUN_SCHEMA_VERSION = 9;
+export const CURRENT_AGENT_RUN_SCHEMA_VERSION = 10;
 export const CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION = 1;
 export class FileTaskStore {
     rootDir;
@@ -991,29 +990,6 @@ export class FileTaskStore {
     }
     getAgentRun(taskId, id) { return optional(this.#state().tasks[taskId]?.agentRuns[id]); }
     listAgentRuns(taskId) { return values(this.#requireTask(taskId).agentRuns, "id"); }
-    listPendingProviderRetries(taskIds) {
-        // The legacy File store can answer the empty case without a scan fallback.
-        // If durable retry state exists, the db-only capability must fail closed
-        // instead of silently losing the Controller's wake deadline.
-        const tasks = taskIds === undefined
-            ? this.listTasks()
-            : [...new Set(taskIds)].sort(numericCompare).flatMap((taskId) => {
-                const task = this.getTask(taskId);
-                return task === null ? [] : [task];
-            });
-        for (const task of tasks) {
-            if (task.status !== "active")
-                continue;
-            for (const run of this.listAgentRuns(task.id)) {
-                if (run.status === "active"
-                    && run.providerRetry !== undefined
-                    && providerRetryWakeAt(run.providerRetry) !== null) {
-                    throw new StorageRecordError("Provider retry in place requires the SQLite backend; run `yui update` to migrate this Home.");
-                }
-            }
-        }
-        return [];
-    }
     saveAgentRun(run) {
         const stored = identified(run, CURRENT_AGENT_RUN_SCHEMA_VERSION, "id", run.id, "Agent run");
         validateAgentRun(stored);
@@ -2498,10 +2474,6 @@ export function validateYuiConfig(config) {
         resolveResourcesGcMode(config.resourcesGcMode);
         resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine);
         resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours);
-        resolveProviderRetryMode(config.providerRetryMode);
-        resolveProviderRetryAdapters(config.providerRetryAdapters);
-        resolveProviderRetryDelaysSeconds(config.providerRetryDelaysSeconds);
-        resolveProviderRetryMaxWindowSeconds(config.providerRetryMaxWindowSeconds);
         resolveRuntimeHealth(config.runtimeHealth);
         resolveControllerTaskConcurrency(config.controllerTaskConcurrency);
         resolveAgentLaunchInactivityTimeoutSeconds(config.agentLaunchInactivityTimeoutSeconds);

package/dist/storage/upgrade/sqliteStateMigration.js

@@ -29,7 +29,7 @@ import { mailboxTargetKey } from "../../coordination/workMailbox.js";
 import { managedWorkspaceKey } from "../../worktree/managedWorkspace.js";
 import { SqliteTaskStore } from "../sqliteStore.js";
 import { readStorageSchemaManifest } from "../storageSchema.js";
-import { CURRENT_STORED_TASK_SCHEMA_VERSION } from "../taskStore.js";
+import { CURRENT_STORED_TASK_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
 /** The sidecar database filename used during staging. */
 export const STAGED_DATABASE_FILENAME = "yui.db.staged";
 /** The committed database filename. */
@@ -62,7 +62,8 @@ export function readMigrationSourceStateFromSqlite(home) {
         // Physical migration 14 rewrites the WorkMailbox family while adding its
         // current columns. Preserve the source rows before applying it so the
         // logical record migration still sees and transforms v1 exactly once.
-        const sourceMailboxes = readWorkMailboxesFromSqlite(snapshotPath);
+        const sourceManifest = readStorageSchemaManifest(home);
+        const sourceMailboxes = readWorkMailboxesFromSqlite(snapshotPath, requireWorkMailboxSchemaVersion(sourceManifest.recordVersions?.workMailbox));
         const stagedStore = new SqliteTaskStore(home, {
             databaseFilename: MIGRATION_SOURCE_DATABASE_FILENAME,
             migration: true
@@ -596,7 +597,7 @@ function hashPayloadTable(db, sql) {
     const rows = db.prepare(sql).all();
     return hashRecords(rows.map((row) => JSON.parse(row.payload)));
 }
-export function rowToMailbox(row) {
+export function rowToMailbox(row, schemaVersion) {
     let target;
     switch (row.target_kind) {
         case "operator":
@@ -623,9 +624,9 @@ export function rowToMailbox(row) {
         processing: row.processing === null ? null : JSON.parse(row.processing),
         pending: row.pending === null ? null : JSON.parse(row.pending)
     };
-    return Object.hasOwn(row, "input_delivery")
+    return schemaVersion > 1
         ? {
-            schemaVersion: 2,
+            schemaVersion,
             ...common,
             inputDelivery: row.input_delivery === null
                 ? null
@@ -633,16 +634,22 @@ export function rowToMailbox(row) {
         }
         : { schemaVersion: 1, ...common };
 }
+function requireWorkMailboxSchemaVersion(value) {
+    if (value !== 1 && value !== 2 && value !== 3) {
+        throw new Error(`WorkMailbox manifest version is invalid: ${String(value)}.`);
+    }
+    return value;
+}
 function readWorkMailboxRows(db) {
     const hasInputDelivery = db.prepare("PRAGMA table_info(mailboxes)").all().some(({ name }) => name === "input_delivery");
     return db.prepare(`SELECT target_kind, task_id, role_name, next_sequence, processing, pending${hasInputDelivery ? ", input_delivery" : ""} FROM mailboxes ORDER BY target_key`).all();
 }
-function readWorkMailboxesFromSqlite(dbPath) {
+function readWorkMailboxesFromSqlite(dbPath, schemaVersion) {
     const db = new Database(dbPath, { readonly: true });
     try {
         const mailboxes = {};
         for (const row of readWorkMailboxRows(db)) {
-            const mailbox = rowToMailbox(row);
+            const mailbox = rowToMailbox(row, schemaVersion);
             mailboxes[mailboxTargetKey(mailbox.target)] = mailbox;
         }
         return mailboxes;
@@ -699,7 +706,7 @@ export function computeDbFamilyChecksums(home, databaseFilename) {
         checksums.publicationReference = hashPayloadTable(db, "SELECT payload FROM publication_references");
         // Mailboxes are reconstructed from typed columns (no payload column).
         const mailboxRows = readWorkMailboxRows(db);
-        checksums.workMailbox = hashRecords(mailboxRows.map(rowToMailbox));
+        checksums.workMailbox = hashRecords(mailboxRows.map((row) => rowToMailbox(row, CURRENT_WORK_MAILBOX_SCHEMA_VERSION)));
         return checksums;
     }
     finally {
@@ -756,6 +763,7 @@ export function readStateFromSqlite(home, databaseFilename = COMMITTED_DATABASE_
         const storedTaskVersion = typeof manifest.recordVersions?.storedTask === "number"
             ? manifest.recordVersions.storedTask
             : CURRENT_STORED_TASK_SCHEMA_VERSION;
+        const storedWorkMailboxVersion = requireWorkMailboxSchemaVersion(manifest.recordVersions?.workMailbox);
         // Home identity + revision continuity.
         const meta = db.prepare("SELECT home_identity, revision FROM home_meta WHERE id = 1").get();
         const state = {
@@ -880,7 +888,7 @@ export function readStateFromSqlite(home, databaseFilename = COMMITTED_DATABASE_
         const mailboxRows = readWorkMailboxRows(db);
         const mailboxes = state.mailboxes;
         for (const row of mailboxRows) {
-            const mailbox = rowToMailbox(row);
+            const mailbox = rowToMailbox(row, storedWorkMailboxVersion);
             mailboxes[mailboxTargetKey(mailbox.target)] = mailbox;
         }
         return state;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.13.8",
+  "version": "0.13.10",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-leader/SKILL.md

@@ -122,8 +122,8 @@ or yield merely to preserve that native wait.
 Before the first durable Leader action, Yui observes fresh native generations
 that produce no WorkItem, Review, Integration, or Leader-attributed durable
 event. Two such generations create a non-blocking orchestration advisory for
-Leader and Operator judgment; they do not fail the Role, reduce the configured
-Provider retry policy, or prevent another useful generation. Read the evidence
+Leader and Operator judgment; they do not fail the Role or prevent another
+useful generation. Read the evidence
 before retrying, then choose whether to continue, change the configured Leader,
 or perform direct maintenance without manufacturing protocol records merely to
 silence the advisory.
@@ -703,13 +703,35 @@ newer WorkItem. If the original execution Session cannot be resumed, surface
 the recovery decision to the user; do not silently discard its context by
 creating a replacement.
 
-If a native Role Session disappears, run `yui task reconcile <task-id>`,
-inspect the Run and partial work, then retry only a confirmed failed Run:
+For a Role runtime failure, inspect the exact error and runtime identities first:
 
 ```sh
-yui task run retry <run-id>
+yui task event show <task> <agent-error-event>
+yui task role session inspect <task> <role>
 ```
 
+When a Provider-accepted Turn fails with availability, `429`, capacity, or a
+recoverable transport error and the Session remains usable, retain the Run and
+Session; a recovery action adds a new Turn on that same native Session. A
+Session preparation failure or Driver rejection before input acceptance fails
+the exact Run once; inspect its error and explicitly retry that failed Run when
+another attempt is useful. Core will not redispatch it on a scheduler tick.
+
+If the Driver proves that the Session cannot continue, settle or retire the
+exact active Run, stop only that Role Session, then retry the failed Run so the
+next dispatch starts a new Session:
+
+```sh
+yui task role session stop <task> <role> --reason "<error decision>"
+yui task run retry <task>/<failed-run>
+```
+
+The new Run context contains the prior Agent, adapter, Run, Host activation,
+native Session/Turn identities, and complete raw error through the referenced
+Task event. Inspect recent `runtime.agent-error` events before another fresh
+Session; after repeated fresh-Session failures, report the evidence and bounded
+options to the user instead of inventing another automatic loop.
+
 ## Request a decision
 
 When a real user choice, new authority, or unavailable external fact is
@@ -789,8 +811,8 @@ yui task complete <task-id> --summary "<outcome, validation, and remaining risks
 
 Retire obsolete WorkItems with `yui task work retire <task>/<work> --summary
 "..."`, optionally using `--replacement`. If the current Provider Conversation
-cannot continue, request a bounded switch with
-`yui task role session switch <task> <role> --reason "..."`; the current
-Conversation remains authoritative until Yui safely binds the replacement. Archiving is a
+cannot continue, settle its Run and stop the exact idle Session with
+`yui task role session stop`; the next explicit Run dispatch creates the
+replacement. Archiving is a
 separate global Operator lifecycle action. It performs the final Task-owned
 runtime and clean-worktree teardown, including this Leader.

package/skills/yui-operator/SKILL.md

@@ -349,12 +349,20 @@ the workflow without claiming that version was delivered.
   treat it as a permission boundary. The Operator may make code, semantic,
   requirement, acceptance, recovery, and integration decisions and must leave
   the real actor and rationale in durable Task state.
-- Reconcile a disappeared native Session with `task reconcile`; inspect the Run
-  before retrying a confirmed failure.
-- If the current Provider Conversation cannot continue, use
-  `yui task role session switch <task> <role> --reason "..."`. The request is
-  audited, and Yui keeps the old Conversation authoritative until the exact
-  replacement bind succeeds; never reconstruct identities from terminal text.
+- Inspect `runtime.agent-error` and `yui task role session inspect` before a
+  recovery. When a Provider-accepted Turn fails with availability, `429`,
+  capacity, or a recoverable transport error and the Session remains usable,
+  add a new Turn to that Session. A Session preparation failure or Driver
+  rejection before input acceptance fails the exact Run once; explicitly retry
+  that failed Run when another attempt is useful. Core does not redispatch it
+  on a scheduler tick. If the Driver proves the Session cannot continue, settle
+  or retire its exact Run, stop that one idle Session with `yui task role
+  session stop <task> <role> --reason "..."`, then retry the failed Run. The
+  replacement Run receives the old Agent, adapter, Run, Host, Session, Turn,
+  and complete raw-error facts through Task context.
+- Inspect recent errors before creating another fresh Session. After repeated
+  fresh-Session failures, summarize the evidence and bounded options to the
+  user; do not hide them behind an automatic replacement counter or loop.
 - Retry only an explicitly failed recovery Job.
 - When a Leader first-progress advisory is reported, inspect its native
   generations and absence of durable progress. It is cost evidence rather than

package/skills/yui-runtime/SKILL.md

@@ -61,7 +61,9 @@ supported checkpoint/yield command as the final control-plane action, then stop
 immediately. If that direct command is denied or stale, report the blocker once
 and stop; do not wrap, retry, broaden permissions, or target another Run.
 
-For a transient Provider retry Envelope, continue the failed Turn in the same
-native Session. Do not replay the original Assignment or reload unrelated Task
-content. Process/child replacement does not by itself authorize a new Yui
-generation or native conversation.
+After a failed Provider Turn, read the referenced `runtime.agent-error` fact.
+The failed Turn is immutable; a recovery is always a new Turn. Continue on the
+same native Session when it remains recoverable, and load only the current Run
+delta instead of replaying its original Assignment. A new Host process does not
+imply a new Session, and a new Session must never be substituted silently for
+the persisted native Session id.

package/dist/lifecycle/providerErrorClass.js

@@ -1,152 +0,0 @@
-/**
- * Issue 04 — Provider error classification.
- *
- * Provider failures arrive at the driver boundary as opaque free text (Claude
- * StopFailure `error`/`errorDetails`, Codex turn-completion summaries). Each
- * driver parses its own Provider's format into a structured
- * {@link ProviderErrorCode} at the driver boundary. This module maps those
- * codes to provider-neutral error classes by lookup, falling back to text
- * matching only when the driver could not produce a structured code.
- *
- * The retry-in-place coordinator needs a stable, provider-neutral error class
- * before it can decide whether the original Session may be retried.
- *
- * Classes (Issue 04 §2):
- * - `transient-provider`   — 500/502/504, connection reset, backend capacity;
- *                            the original Session is retried in place.
- * - `transport-uncertain`  — the request may have been accepted but the
- *                            response was lost; native facts are consulted
- *                            before any resend.
- * - `policy-denied`        — cyber_policy / permission boundary; never retried
- *                            automatically, never worked around by switching
- *                            Session or widening permission.
- * - `session-dead`         — the process/tmux/native identity is gone; in-place
- *                            retry stops and a replacement blocker is raised.
- * - `invalid-request`      — deterministic parameter/protocol error; fail fast,
- *                            never call the Provider again.
- * - `unclassified`         — no conservative match; behaves like
- *                            `invalid-request` for retry purposes (old
- *                            terminalize-immediately behavior) while remaining
- *                            observable in shadow metrics.
- */
-import { PROVIDER_ERROR_CODE_CLASS } from "../runtime/providerErrorCodes.js";
-/** Classes for which the original Session may be retried in place. */
-export const RETRYABLE_PROVIDER_ERROR_CLASSES = [
-    "transient-provider",
-    "transport-uncertain"
-];
-export function isRetryableProviderErrorClass(errorClass) {
-    return RETRYABLE_PROVIDER_ERROR_CLASSES.includes(errorClass);
-}
-/**
- * Ordered pattern tables. The first class whose pattern matches wins, so the
- * table order is the precedence order. Patterns are matched case-insensitively
- * against the concatenation of every available text field.
- */
-const SESSION_DEAD_PATTERNS = [
-    { pattern: /session not found/iu, label: "session-not-found" },
-    { pattern: /no such (session|thread)/iu, label: "no-such-session" },
-    { pattern: /thread not found/iu, label: "thread-not-found" },
-    { pattern: /session (has )?expired/iu, label: "session-expired" },
-    { pattern: /session (has )?ended/iu, label: "session-ended" },
-    { pattern: /session (is )?dead/iu, label: "session-dead" },
-    { pattern: /session terminated/iu, label: "session-terminated" },
-];
-const CONTEXT_CAPACITY_PATTERNS = [
-    { pattern: /maximum context length/iu, label: "maximum-context-length" },
-    { pattern: /context length exceeded/iu, label: "context-length-exceeded" },
-    { pattern: /context window (is )?(full|exceeded)/iu, label: "context-window-exceeded" },
-    { pattern: /prompt (is )?too long/iu, label: "prompt-too-long" },
-    { pattern: /too many tokens/iu, label: "too-many-tokens" }
-];
-const POLICY_DENIED_PATTERNS = [
-    { pattern: /cyber[_-]?policy/iu, label: "cyber-policy" },
-    { pattern: /policy[_-]?violation/iu, label: "policy-violation" },
-    { pattern: /usage[_-]?policy/iu, label: "usage-policy" },
-    { pattern: /content[_-]?policy/iu, label: "content-policy" },
-    { pattern: /safety[_-]?policy/iu, label: "safety-policy" },
-    { pattern: /policy denial/iu, label: "policy-denial" }
-];
-const INVALID_REQUEST_PATTERNS = [
-    { pattern: /invalid[_-]?request/iu, label: "invalid-request" },
-    { pattern: /validation error/iu, label: "validation-error" },
-    { pattern: /bad request/iu, label: "bad-request" },
-    { pattern: /\b400\b/u, label: "http-400" },
-    { pattern: /unknown (flag|tool|argument)/iu, label: "unknown-argument" },
-    { pattern: /unexpected argument/iu, label: "unexpected-argument" },
-    { pattern: /invalid schema/iu, label: "invalid-schema" }
-];
-const TRANSIENT_PROVIDER_PATTERNS = [
-    { pattern: /\b50[024]\b/u, label: "http-5xx" },
-    { pattern: /server[\s_-]?error/iu, label: "server-error" },
-    { pattern: /internal server error/iu, label: "internal-server-error" },
-    // HTTP/2 RST_STREAM / gRPC status carried by Claude Code and Codex streams
-    // (Task-27: "stream error: stream ID …; INTERNAL_ERROR; received from peer").
-    { pattern: /\binternal[\s_-]?error\b/iu, label: "internal-error" },
-    { pattern: /connection lost/iu, label: "connection-lost" },
-    { pattern: /connection reset/iu, label: "connection-reset" },
-    { pattern: /econnreset/iu, label: "econnreset" },
-    { pattern: /socket hang up/iu, label: "socket-hang-up" },
-    { pattern: /kv[_-]?cache[_-]?allocate[_-]?failed/iu, label: "kv-cache-allocate-failed" },
-    { pattern: /overloaded/iu, label: "overloaded" },
-    { pattern: /\b429\b/u, label: "http-429" },
-    { pattern: /rate[_-]?limit/iu, label: "rate-limit" },
-    { pattern: /upstream/iu, label: "upstream" },
-    { pattern: /bad gateway/iu, label: "bad-gateway" },
-    { pattern: /gateway timeout/iu, label: "gateway-timeout" },
-    { pattern: /service unavailable/iu, label: "service-unavailable" },
-    { pattern: /temporarily unavailable/iu, label: "temporarily-unavailable" },
-    { pattern: /try again/iu, label: "try-again" }
-];
-const TRANSPORT_UNCERTAIN_PATTERNS = [
-    { pattern: /timed?[ -]?out/iu, label: "timeout" },
-    { pattern: /etimedout/iu, label: "etimedout" },
-    { pattern: /response lost/iu, label: "response-lost" },
-    { pattern: /lost response/iu, label: "lost-response" },
-    // A stream-level failure means the response may have been cut mid-turn;
-    // the retry path consults durable completion facts before any resend.
-    { pattern: /stream error/iu, label: "stream-error" },
-    { pattern: /stream interrupted/iu, label: "stream-interrupted" },
-    { pattern: /interrupted function/iu, label: "interrupted-function" },
-    { pattern: /controller timeout/iu, label: "controller-timeout" },
-    { pattern: /delivery (unconfirmed|uncertain|not confirmed)/iu, label: "delivery-unconfirmed" },
-    { pattern: /unconfirmed delivery/iu, label: "unconfirmed-delivery" },
-    { pattern: /no response/iu, label: "no-response" }
-];
-const CLASS_TABLE = [
-    { errorClass: "session-dead", patterns: SESSION_DEAD_PATTERNS },
-    { errorClass: "policy-denied", patterns: POLICY_DENIED_PATTERNS },
-    { errorClass: "context-capacity", patterns: CONTEXT_CAPACITY_PATTERNS },
-    { errorClass: "invalid-request", patterns: INVALID_REQUEST_PATTERNS },
-    { errorClass: "transient-provider", patterns: TRANSIENT_PROVIDER_PATTERNS },
-    { errorClass: "transport-uncertain", patterns: TRANSPORT_UNCERTAIN_PATTERNS }
-];
-/**
- * Classifies one provider failure. When the driver produced a structured
- * {@link ProviderErrorCode}, the class is looked up directly. Otherwise the
- * raw text fields are matched against the fallback pattern tables. Every
- * available text field is concatenated so a class can be recognized
- * regardless of which field carried it.
- */
-export function classifyProviderError(input) {
-    // Structured path: the driver already parsed the Provider's error format.
-    if (input.errorCode !== undefined) {
-        const errorClass = PROVIDER_ERROR_CODE_CLASS[input.errorCode];
-        if (errorClass !== undefined) {
-            return { errorClass, matched: input.errorCode, basis: "structured" };
-        }
-    }
-    // Text fallback: for drivers that cannot yet produce a structured code.
-    const text = [input.error, input.errorDetails, input.summary]
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .join("\n");
-    if (text.length === 0)
-        return { errorClass: "unclassified", matched: "none", basis: "text" };
-    for (const { errorClass, patterns } of CLASS_TABLE) {
-        for (const { pattern, label } of patterns) {
-            if (pattern.test(text))
-                return { errorClass, matched: label, basis: "text" };
-        }
-    }
-    return { errorClass: "unclassified", matched: "none", basis: "text" };
-}