@zq-silk/yui 0.13.7 → 0.13.9

package/dist/runtime/builtinAgentErrorMappers.js

@@ -0,0 +1,150 @@
+/** Provider-specific Claude Code failure recognition. */
+export function mapClaudeAgentError(input) {
+    const text = `${input.message}\n${input.raw}`;
+    if (/^server_error$/iu.test(input.message) || /\bapi_error\b/iu.test(text)) {
+        return recoverable("availability", "provider.server-error");
+    }
+    if (/^overloaded_error$/iu.test(input.message) || /\boverloaded\b/iu.test(text)) {
+        return recoverable("availability", "provider.overloaded");
+    }
+    if (/^rate_limit_error$/iu.test(input.message) || /rate[\s_-]?limit/iu.test(text)) {
+        return recoverable("rate-limit", "provider.rate-limit");
+    }
+    if (/^(authentication_error|permission_error)$/iu.test(input.message)) {
+        return classification("access", "provider.access-denied");
+    }
+    if (/^not_found_error$/iu.test(input.message)) {
+        return sessionUnavailable("provider.session-not-found");
+    }
+    return mapSharedAgentError(text, "claude-code");
+}
+/** Provider-specific Codex failure recognition. */
+export function mapCodexAgentError(input) {
+    const text = `${input.message}\n${input.raw}`;
+    if (/^server_error$/iu.test(input.message)) {
+        return recoverable("availability", "provider.server-error");
+    }
+    if (/^overloaded_error$/iu.test(input.message)
+        || /selected model is at capacity/iu.test(text)
+        || /\bmodel\b.*\bat capacity\b/iu.test(text)) {
+        return recoverable("availability", "provider.model-capacity");
+    }
+    if (/^rate_limit_error$/iu.test(input.message)) {
+        return recoverable("rate-limit", "provider.rate-limit");
+    }
+    if (/^(authentication_error|permission_error)$/iu.test(input.message)) {
+        return classification("access", "provider.access-denied");
+    }
+    if (/\[codex:(unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)
+        || /model.*not supported|invalid.*model|model.*not found/iu.test(text)) {
+        return classification("invalid-request", "provider.invalid-model");
+    }
+    if (/stream disconnected/iu.test(text)) {
+        return recoverable("transport", "transport.stream-disconnected");
+    }
+    return mapSharedAgentError(text, "codex");
+}
+function mapSharedAgentError(text, namespace) {
+    if (/stream error:.*INTERNAL_ERROR/iu.test(text)) {
+        return recoverable("transport", "transport.stream-internal-error");
+    }
+    if (/stream error:.*PROTOCOL_ERROR/iu.test(text)) {
+        return recoverable("transport", "transport.stream-protocol-error");
+    }
+    if (/stream error/iu.test(text))
+        return recoverable("transport", "transport.stream-error");
+    if (/\b429\b/u.test(text) || /rate[\s_-]?limit/iu.test(text)) {
+        return recoverable("rate-limit", "provider.rate-limit");
+    }
+    if (/\b40[0-9]\b/u.test(text))
+        return classification("invalid-request", "provider.http-4xx");
+    if (/\b50[0-9]\b/u.test(text)
+        || /bad gateway|service unavailable|temporarily unavailable/iu.test(text)) {
+        return recoverable("availability", "provider.http-5xx");
+    }
+    if (/server[\s_-]?error/iu.test(text)) {
+        return recoverable("availability", "provider.server-error");
+    }
+    if (/\boverloaded\b/iu.test(text)) {
+        return recoverable("availability", "provider.overloaded");
+    }
+    if (/gateway timeout|timed?[ -]?out|etimedout/iu.test(text)) {
+        return recoverable("transport", "transport.timeout");
+    }
+    if (/connection[\s_-]?reset|econnreset|socket hang up/iu.test(text)) {
+        return recoverable("transport", "transport.connection-reset");
+    }
+    if (/connection[\s_-]?lost/iu.test(text)) {
+        return recoverable("transport", "transport.connection-lost");
+    }
+    if (/\beconnrefused\b|connection refused|connect[^\n]*refused/iu.test(text)) {
+        return recoverable("transport", "transport.connection-refused");
+    }
+    if (/\bepipe\b|broken pipe/iu.test(text)) {
+        return recoverable("transport", "transport.broken-pipe");
+    }
+    if (/\b(?:enotfound|eai_again)\b|dns[^\n]*(?:failed|unavailable)/iu.test(text)) {
+        return recoverable("transport", "transport.name-resolution");
+    }
+    if (/\benoent\b[^\n]*(?:socket|agent-host)|no such file[^\n]*(?:socket|agent-host)/iu.test(text)) {
+        return recoverable("transport", "transport.endpoint-missing");
+    }
+    if (/delivery[^\n]*unknown|acknowledgement[^\n]*unknown/iu.test(text)) {
+        return Object.freeze({
+            category: "transport",
+            code: "transport.delivery-unknown",
+            inputDisposition: "unknown",
+            sessionDisposition: "recoverable"
+        });
+    }
+    if (/unsettled turn|turn[^\n]*busy|session[^\n]*busy|writer fence|writer authority|human writer/iu.test(text)) {
+        return Object.freeze({
+            category: "conflict",
+            code: "runtime.session-busy",
+            inputDisposition: "not-accepted",
+            sessionDisposition: "recoverable"
+        });
+    }
+    if (/cyber[_-]?policy|policy[\s_-]?violation|usage[\s_-]?policy|content[\s_-]?policy|safety[\s_-]?policy/iu.test(text)) {
+        return classification("access", "provider.policy-denied");
+    }
+    if (/maximum context length|context length exceeded|context window (?:is )?(?:full|exceeded)|prompt (?:is )?too long|too many tokens/iu.test(text)) {
+        return classification("context", "provider.context-capacity");
+    }
+    if (/session[\s_-]?not[\s_-]?found|no[\s_-]?such[\s_-]?(?:session|thread)|thread[\s_-]?not[\s_-]?found/iu.test(text)) {
+        return sessionUnavailable("provider.session-not-found");
+    }
+    if (/session[\s_-]?(?:has[\s_-]?)?expired/iu.test(text)) {
+        return sessionUnavailable("provider.session-expired");
+    }
+    if (/session[\s_-]?(?:has[\s_-]?)?ended/iu.test(text)) {
+        return sessionUnavailable("provider.session-ended");
+    }
+    if (/process[\s_-]?exited/iu.test(text)) {
+        return recoverable("runtime", "runtime.process-exited");
+    }
+    if (/invalid[\s_-]?request|validation[\s_-]?error|bad[\s_-]?request|unknown[\s_-]?(?:flag|tool|argument)|unexpected argument|invalid schema/iu.test(text)
+        || (namespace === "codex"
+            ? /\[codex:(?:unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)
+            : /\[claude-code:(?:unrecognized_model|invalid_model|model_not_found)\]/iu.test(text))) {
+        return classification("invalid-request", "provider.invalid-request");
+    }
+    return classification("unknown", "unknown");
+}
+function classification(category, code) {
+    return Object.freeze({ category, code });
+}
+function recoverable(category, code) {
+    return Object.freeze({
+        category,
+        code,
+        sessionDisposition: "recoverable"
+    });
+}
+function sessionUnavailable(code) {
+    return Object.freeze({
+        category: "session",
+        code,
+        sessionDisposition: "unrecoverable"
+    });
+}

package/dist/runtime/exactControlPlane.js

@@ -304,21 +304,16 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
         && isRuntimeLaunchReservation(lifecycleMailbox?.processing, runtime.launchId);
     const sessionLaunch = runtime.launchId !== undefined
         && session?.launchId === runtime.launchId;
-    const executionRef = lifecycleMailbox?.processing?.executionRef;
     const preallocated = options.preallocatedDriverSessionReservation;
-    const exactRunLaunchReservation = runtime.runId !== undefined
-        && runtime.launchId !== undefined
+    const exactHostLaunchReservation = runtime.launchId !== undefined
         && reservation
-        && !hasRuntimeCleanupObligation(lifecycleMailbox)
-        && executionRef?.type === "run"
-        && executionRef.taskId === runtime.taskId
-        && executionRef.id === runtime.runId;
-    const terminalSessionReplacementReservation = exactRunLaunchReservation
+        && !hasRuntimeCleanupObligation(lifecycleMailbox);
+    const terminalSessionReplacementReservation = exactHostLaunchReservation
         && session !== undefined
-        && (session.status === "stopped" || session.status === "broken");
+        && session.status === "ended";
     const exactPreallocatedReservation = preallocated !== undefined
         && runtime.adapterId === preallocated.adapterId
-        && exactRunLaunchReservation
+        && exactHostLaunchReservation
         && runtime.nativeSessionId !== undefined
         && (session === undefined || terminalSessionReplacementReservation)
         && runtime.nativeSessionId === nativeSessionIdForLaunch(preallocated.yuiHome, runtime.launchId, runtime.agentId, runtime.adapterId);
@@ -346,8 +341,7 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
         || session.adapterId !== runtime.adapterId
         || session.nativeSessionId !== runtime.nativeSessionId
         || session.launchId !== runtime.launchId
-        || session.status === "stopped"
-        || session.status === "broken"
+        || session.status === "ended"
         || session.effective.agentId !== runtime.agentId
         || session.effective.adapterId !== runtime.adapterId
         || canonicalPath(session.effective.workspace.root) !== runtime.workspace) {

package/dist/runtime/index.js

@@ -14,8 +14,7 @@ export { formatRuntimeLaunchDiagnostic, redactLaunchArgument, redactLaunchText,
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
 export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";
 export { codexNotificationBoundary, codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
-export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rebindProviderRuntimeRun, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 export { FencedProviderControl } from "./providerControl.js";
 export { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
-export { decideProviderRecovery } from "./providerRecoveryDecision.js";
 export { reconcileSessionOwners } from "./sessionReconciliation.js";

package/dist/runtime/launchBroker.js

@@ -98,22 +98,16 @@ function validateProviderControl(control) {
     if (control.mode !== "new" && control.mode !== "resume") {
         throw new Error("Agent Host Provider control mode is invalid.");
     }
-    if (control.kind !== "new" && control.kind !== "resume" && control.kind !== "ensure") {
+    if (control.kind !== "start" && control.kind !== "restore") {
         throw new Error("Agent Host Provider control kind is invalid.");
     }
-    if ((control.kind === "new") !== (control.mode === "new")) {
+    if ((control.kind === "start") !== (control.mode === "new")) {
         throw new Error("Agent Host Provider control kind does not match its transport mode.");
     }
-    if (control.kind !== "ensure" && control.initialTurn === undefined) {
-        throw new Error("Managed Provider new/resume launch requires its initial Turn.");
+    if (control.kind !== "restore" && "ownedTurn" in control) {
+        throw new Error("Only Session restore can reconcile an owned Turn.");
     }
-    if (control.kind === "ensure" && control.initialTurn !== undefined) {
-        throw new Error("Managed Provider ensure launch cannot carry a new Turn.");
-    }
-    if (control.kind !== "ensure" && "ownedTurn" in control) {
-        throw new Error("Only a managed Provider ensure launch can recover an owned Turn.");
-    }
-    if (control.kind === "ensure" && control.ownedTurn !== undefined) {
+    if (control.kind === "restore" && control.ownedTurn !== undefined) {
         if (control.adapterId !== "codex") {
             throw new Error("Only Managed Codex can recover an owned Turn across client attachment.");
         }
@@ -135,14 +129,6 @@ function validateProviderControl(control) {
         }
     }
     validateProviderAuthorityFence(control.authority);
-    if (control.initialTurn !== undefined) {
-        text(control.initialTurn.attemptId, "Provider input attemptId");
-        if (typeof control.initialTurn.boundedText !== "string"
-            || control.initialTurn.boundedText.includes("\0")
-            || Buffer.byteLength(control.initialTurn.boundedText, "utf8") > 32 * 1024) {
-            throw new Error("Agent Host Provider input must be bounded bootstrap text.");
-        }
-    }
 }
 function validateCodexThreadOptions(options) {
     if (options === null || typeof options !== "object" || Array.isArray(options)) {

package/dist/runtime/lifecycleReservation.js

@@ -2,6 +2,7 @@ import { mailboxHasWork } from "../coordination/workMailbox.js";
 export const RUNTIME_LIFECYCLE_OWNER = "runtime-lifecycle";
 export const RUNTIME_LAUNCH_RESERVED_REASON = "runtime-launch-reserved";
 export const RUNTIME_CLEANUP_REQUIRED_REASON = "runtime-cleanup-required";
+export const RUNTIME_HOST_DETACH_REQUIRED_REASON = "runtime-host-detach-required";
 /**
  * A Role runtime lifecycle lane already holds an in-flight operation (a
  * launch reservation or a cleanup obligation). This is scheduler
@@ -42,10 +43,25 @@ export function hasRuntimeLaunchReservation(mailbox) {
     return isRuntimeLaunchReservation(mailbox?.processing);
 }
 export function hasRuntimeCleanupObligation(mailbox) {
-    const pending = mailbox?.pending.normal;
-    return pending?.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON) === true
-        || (!isRuntimeLaunchReservation(mailbox?.processing)
-            && mailbox?.processing?.batch.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON) === true);
+    return runtimeCleanupDisposition(mailbox) !== null;
+}
+/** Explicit Session end dominates a coalesced physical Host detach request. */
+export function runtimeCleanupDisposition(mailbox) {
+    const reasons = [
+        ...(mailbox?.pending.normal?.reasons ?? []),
+        ...(!isRuntimeLaunchReservation(mailbox?.processing)
+            ? mailbox?.processing?.batch.reasons ?? []
+            : [])
+    ];
+    if (reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON))
+        return "end-session";
+    if (reasons.includes(RUNTIME_HOST_DETACH_REQUIRED_REASON))
+        return "detach-host";
+    return null;
+}
+export function isRuntimeCleanupReason(reason) {
+    return reason === RUNTIME_CLEANUP_REQUIRED_REASON
+        || reason === RUNTIME_HOST_DETACH_REQUIRED_REASON;
 }
 export function hasRuntimeLifecycleWork(mailbox) {
     return mailbox !== null && mailboxHasWork(mailbox);

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,10 +1,9 @@
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
     return validateProviderRuntimeBinding({
-        schemaVersion: 2,
+        schemaVersion: 3,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
         accountScope: identity(input.accountScope, "Provider account scope"),
-        runId: identity(input.runId, "Run id"),
         currentConversationEpoch: 1,
         conversations: [{
                 conversationId: identity(input.conversationId, "Provider Conversation id"),
@@ -40,17 +39,6 @@ export function currentProviderActivation(binding) {
     const conversation = currentProviderConversation(binding);
     return [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId && entry.status === "active")) ?? null;
 }
-/** Rebinds the live Conversation state to the next Yui Run without resetting authority. */
-export function rebindProviderRuntimeRun(raw, runId) {
-    const binding = validateProviderRuntimeBinding(raw);
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error("Provider Runtime cannot bind another Run while a Turn is unsettled.");
-    }
-    return validateProviderRuntimeBinding({
-        ...binding,
-        runId: identity(runId, "Run id")
-    });
-}
 export function startProviderActivation(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     if (currentProviderActivation(binding) !== null) {
@@ -158,8 +146,10 @@ export function transferProviderAuthority(raw, input) {
 }
 export function beginProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
+    const runId = identity(input.runId, "Run id");
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    if (binding.turn?.attemptId === attemptId
+    if (binding.turn?.runId === runId
+        && binding.turn.attemptId === attemptId
         && binding.turn.authorityEpoch === input.authorityEpoch
         && binding.turn.status === "submitting") {
         return binding;
@@ -176,6 +166,7 @@ export function beginProviderTurn(raw, input) {
     return validateProviderRuntimeBinding({
         ...binding,
         turn: {
+            runId,
             attemptId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
@@ -236,7 +227,7 @@ export function rejectProviderTurn(raw, input) {
         }
     });
 }
-/** Resolves an Agent Host submission exactly once and accepts an exact acknowledgement replay. */
+/** Resolves an Agent Host submission; an unknown delivery may later gain exact negative evidence. */
 export function settleProviderTurnSubmission(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const attemptId = identity(input.attemptId, "Provider input attempt id");
@@ -245,7 +236,8 @@ export function settleProviderTurnSubmission(raw, input) {
     }
     if (binding.turn.status === input.status)
         return binding;
-    if (binding.turn.status !== "submitting") {
+    if (binding.turn.status !== "submitting"
+        && !(binding.turn.status === "delivery-unknown" && input.status === "rejected")) {
         throw new Error("Provider Turn does not match a resolvable delivery state.");
     }
     return input.status === "delivery-unknown"
@@ -350,11 +342,10 @@ export function supersedeProviderConversation(raw, input) {
     });
 }
 export function validateProviderRuntimeBinding(value) {
-    if (value.schemaVersion !== 2)
-        throw new Error("Provider Runtime Binding schemaVersion must be 2.");
+    if (value.schemaVersion !== 3)
+        throw new Error("Provider Runtime Binding schemaVersion must be 3.");
     identity(value.providerNamespace, "Provider namespace");
     identity(value.accountScope, "Provider account scope");
-    identity(value.runId, "Run id");
     integer(value.currentConversationEpoch, 1, "Current Provider Conversation epoch");
     if (!Array.isArray(value.conversations) || value.conversations.length === 0) {
         throw new Error("Provider Runtime Binding requires a Conversation.");
@@ -459,6 +450,7 @@ export function validateProviderRuntimeBinding(value) {
     return value;
 }
 function validateProviderTurn(turn, currentAuthorityEpoch) {
+    identity(turn.runId, "Run id");
     identity(turn.attemptId, "Provider input attempt id");
     integer(turn.authorityEpoch, 1, "Provider Turn authority epoch");
     if (turn.authorityEpoch > currentAuthorityEpoch) {

package/dist/runtime/runtimeBinding.js

@@ -5,27 +5,6 @@ export function createRuntimeBinding(input) {
     const hostCreated = input.hostCreated === undefined
         ? undefined
         : requireBoolean(input.hostCreated, "Runtime host-created flag");
-    const initialTurnRunId = input.initialTurnRunId === undefined
-        ? undefined
-        : requireSafeIdentity(input.initialTurnRunId, "Initial Turn Run id");
-    const initialTurnDeliveryUnknownRunId = input.initialTurnDeliveryUnknownRunId === undefined
-        ? undefined
-        : requireSafeIdentity(input.initialTurnDeliveryUnknownRunId, "Delivery-unknown initial Turn Run id");
-    const initialTurnRejectedRunId = input.initialTurnRejectedRunId === undefined
-        ? undefined
-        : requireSafeIdentity(input.initialTurnRejectedRunId, "Rejected initial Turn Run id");
-    const initialTurnBusyRunId = input.initialTurnBusyRunId === undefined
-        ? undefined
-        : requireSafeIdentity(input.initialTurnBusyRunId, "Busy initial Turn Run id");
-    if ([
-        initialTurnRunId,
-        initialTurnDeliveryUnknownRunId,
-        initialTurnBusyRunId,
-        initialTurnRejectedRunId
-    ]
-        .filter((value) => value !== undefined).length > 1) {
-        throw new TypeError("Runtime binding must report at most one initial Turn outcome.");
-    }
     return {
         id: requireSafeIdentity(input.id, "Runtime binding id"),
         launchId: requireSafeIdentity(input.launchId, "Launch id"),
@@ -34,12 +13,6 @@ export function createRuntimeBinding(input) {
         adapterId: requireSafeIdentity(input.adapterId, "Agent adapter id"),
         hostRef: requireText(input.hostRef, "Session host reference"),
         ...(hostCreated === undefined ? {} : { hostCreated }),
-        ...(initialTurnRunId === undefined ? {} : { initialTurnRunId }),
-        ...(initialTurnDeliveryUnknownRunId === undefined
-            ? {}
-            : { initialTurnDeliveryUnknownRunId }),
-        ...(initialTurnBusyRunId === undefined ? {} : { initialTurnBusyRunId }),
-        ...(initialTurnRejectedRunId === undefined ? {} : { initialTurnRejectedRunId }),
         ...(input.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireText(input.nativeSessionId, "Native session id") }),

package/dist/runtime/runtimeObservation.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { requireDriverId } from "./agentDriver.js";
+import { isStandardAgentError } from "./agentError.js";
 export const RUNTIME_OBSERVATION_TASK_EVENT = "runtime.observation";
 /**
  * Numeric usage and value-less partial request boundaries are both durable
@@ -435,7 +436,7 @@ export function runtimeObservationSemanticKey(input) {
             ...continuationIdentity,
             fence.continuationId ?? fence.nativeTurnId ?? "none",
             input.kind,
-            input.payload?.outcome ?? input.payload?.failure?.code ?? "terminal",
+            input.payload?.outcome ?? input.payload?.failure?.error.code ?? "terminal",
             input.kind === "continuation.settled" ? input.payload?.resultRef ?? "none" : "none",
             input.kind === "turn.failed" && input.payload?.failure?.runTerminal === true
                 ? "run-terminal"
@@ -494,21 +495,17 @@ function normalizeFailure(input) {
     if (input === null || typeof input !== "object" || Array.isArray(input)) {
         throw new Error("Runtime failure evidence must be an object.");
     }
+    if (!isStandardAgentError(input.error)) {
+        throw new Error("Runtime failure requires a standard Agent error.");
+    }
     return Object.freeze({
-        ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
-        code: requireText(input.code, "Runtime failure code"),
-        ...(input.details === undefined
-            ? {}
-            : { details: requireText(input.details, "Runtime failure details") }),
+        error: Object.freeze({ ...input.error }),
         ...(input.lastOutput === undefined
             ? {}
             : { lastOutput: requireText(input.lastOutput, "Runtime failure last output") }),
         ...(input.runTerminal === undefined
             ? {}
-            : { runTerminal: requireBoolean(input.runTerminal, "Runtime failure runTerminal") }),
-        ...(input.retryAfterMs === undefined
-            ? {}
-            : { retryAfterMs: requirePositiveMilliseconds(input.retryAfterMs) })
+            : { runTerminal: requireBoolean(input.runTerminal, "Runtime failure runTerminal") })
     });
 }
 function requireBoolean(value, label) {
@@ -516,12 +513,6 @@ function requireBoolean(value, label) {
         throw new Error(`${label} must be boolean.`);
     return value;
 }
-function requirePositiveMilliseconds(value) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new Error("Runtime failure retryAfterMs must be a positive safe integer.");
-    }
-    return value;
-}
 function validateUsage(input) {
     if (!["cumulative-session", "request-context", "remaining-context"].includes(input.semantics)) {
         throw new Error("Runtime usage semantics are invalid.");

package/dist/runtime/runtimeSessionCandidate.js

@@ -1,14 +1,8 @@
 import { activeRoleAgentSession } from "../executor/agentExecutor.js";
-/** Exact completed-Task cleanup contract shared by projection writers/readers. */
-export function runtimeSessionRequiresCleanup(input) {
-    if (input.status === "stopped" || input.status === "broken")
-        return false;
-    return input.status === "running" || input.launchId !== undefined;
-}
-/** Projects only the current active Agent Session; stopped history disappears. */
+/** Projects only the current active Agent Session; ended history disappears. */
 export function projectRuntimeSessionCandidate(sessions) {
     const active = activeRoleAgentSession(sessions);
-    if (active === null || active.status === "stopped")
+    if (active === null || active.status === "ended")
         return null;
     return {
         owner: sessions.owner.scope === "task"
@@ -22,9 +16,8 @@ export function projectRuntimeSessionCandidate(sessions) {
         adapterId: active.adapterId,
         nativeSessionId: active.nativeSessionId,
         ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
-        status: active.status,
         sessionUpdatedAt: active.updatedAt,
-        cleanupRequired: runtimeSessionRequiresCleanup(active)
+        cleanupRequired: active.launchId !== undefined
     };
 }
 /** Deterministic owner order shared by all storage backends. */

package/dist/runtime/sessionLaunchRequest.js

@@ -18,8 +18,7 @@ export function createSessionLaunchRequest(input) {
     if (runtimeIsolation !== undefined && (input.owner.scope !== "task"
         || runtimeIsolation.taskId !== input.owner.taskId
         || runtimeIsolation.workspace.root !== workspace
-        || runtimeIsolation.generation.launchId !== input.launchId
-        || runtimeIsolation.generation.runId !== input.runId)) {
+        || runtimeIsolation.generation.launchId !== input.launchId)) {
         throw new TypeError("Session launch request does not match its Task runtime isolation descriptor.");
     }
     const common = {

package/dist/runtime/sessionReconciliation.js

@@ -41,14 +41,14 @@ function reconcileOne(record, input) {
         mismatch = "identity-conflict";
     }
     else if (physical?.alive === true) {
-        if (durable === undefined || durable.status === "stopped" || durable.status === "broken") {
+        if (durable === undefined || durable.status === "ended") {
             mismatch = "durable-terminal-physical-live";
         }
     }
     else if (physical === undefined) {
         verificationGap = "/proc identity unavailable";
     }
-    else if (durable !== undefined && durable.status === "running") {
+    else if (durable !== undefined && durable.status === "active") {
         mismatch = "durable-live-physical-absent";
     }
     const terminalTask = taskStatus === "completed"