@zq-silk/yui 0.6.16 → 0.7.0

package/dist/repository/taskWorkspacePreparer.js

@@ -9,7 +9,7 @@ import { StorageConflictError } from "../storage/taskStore.js";
 import { bindTaskWorkspaceIdentity } from "../task/task.js";
 import { createCandidateGitSnapshot, createDirectTaskMainSnapshot, workItemExecutionGroupById, recordWorkItemWorkspaceDisposition } from "../workItem/workItem.js";
 import { createManagedWorkspace, managedWorkspaceKey, managedWorktreeName, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { NodeGitWorkspace, worktreeIdentity } from "./gitWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
 import { generateTaskWorkspaceIdentity, isLegacyTaskRef, taskArchiveRef, taskMainBranch, taskWorkspaceRefSegment, taskWorkspaceRefSegmentFromIdentity, TASK_WORKSPACE_TOKEN_PATTERN, validateTaskWorkspaceIdentity } from "./taskWorkspaceIdentity.js";
@@ -2519,7 +2519,7 @@ function canCorrectActiveWorkItemRoleWorkspaceHint(store, taskId, role, item, wo
         || sessions.inFlight === null
         || sessions.inFlight.agentId !== role.activeAgentId
         || sessions.inFlight.runId !== run.id
-        || sessions.inFlight.receiptId !== formatAgentRunReceiptId(taskId, run.id)
+        || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run)
         || session === undefined
         || session.agentId !== role.activeAgentId
         || session.adapterId !== run.effective.adapterId

package/dist/run/agentRun.js

@@ -1,20 +1,42 @@
 import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
-import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { markProviderRetryInFlight, validateAgentRunProviderRetry } from "./providerRetry.js";
+import { formatAgentRunReceiptId, validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { prepareProviderRetryDispatch, validateAgentRunProviderRetry } from "./providerRetry.js";
 import { validateYieldReceipt } from "./yieldReceipt.js";
+import { validateAgentRunControlRequest } from "./runControlRequest.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
-export function createAgentRun(id, taskId, roleName, mode, input, now, context) {
+import { createRunAssignment, createRunBootstrapEnvelope, validateRunAssignment, validateRunBootstrapEnvelope } from "../context/runContextContract.js";
+export function createAgentRun(id, taskId, roleName, mode, assignment, now, context) {
     if (mode !== "new" && mode !== "resume") {
         throw new Error(`Agent run dispatch mode is invalid: ${mode}.`);
     }
     const timestamp = now.toISOString();
+    const normalizedAssignment = typeof assignment === "string"
+        ? createRunAssignment({
+            runId: id,
+            roleName,
+            purpose: context.purpose ?? "execution",
+            action: context.purpose === "review"
+                ? "review-round"
+                : context.workItemId === undefined ? "leader-wake" : "execute-work-item",
+            subject: {
+                taskId,
+                ...(context.workItemId === undefined ? {} : { workItemId: context.workItemId }),
+                ...(context.purpose === "review"
+                    ? { reviewRoundId: context.reviewRoundId ?? `legacy-${id}` }
+                    : context.reviewRoundId === undefined ? {} : { reviewRoundId: context.reviewRoundId })
+            },
+            directive: assignment,
+            deltaRefIds: []
+        })
+        : validateRunAssignment(assignment);
     return {
-        schemaVersion: 7,
+        schemaVersion: 9,
         id: requireSafeIdentity(id, "Agent run id"),
         taskId: requireSafeIdentity(taskId, "Task id"),
         roleName: requireSafeIdentity(roleName, "Role name"),
         mode,
-        input: requireText(input, "Agent run input"),
+        assignment: normalizedAssignment,
+        bootstrapEnvelope: createRunBootstrapEnvelope(normalizedAssignment),
         purpose: context.purpose ?? "execution",
         ...(context.workItemId === undefined
             ? {}
@@ -40,6 +62,22 @@ export function createAgentRun(id, taskId, roleName, mode, input, now, context)
 export function isActiveAgentRun(run) {
     return run.status === "active";
 }
+/** Binds a freshly created, not-yet-persisted Run to its frozen Context. */
+export function withAgentRunContextSnapshot(run, snapshot, deltaRefIds = []) {
+    if (run.status !== "active" || run.pushedAt !== undefined || run.deliveredAt !== undefined) {
+        throw new Error(`Cannot bind Context Snapshot after Run delivery: ${run.id}.`);
+    }
+    const assignment = validateRunAssignment(Object.freeze({
+        ...run.assignment,
+        contextSnapshotRef: snapshot,
+        deltaRefIds
+    }));
+    return validateAgentRun(Object.freeze({
+        ...run,
+        assignment,
+        bootstrapEnvelope: createRunBootstrapEnvelope(assignment)
+    }));
+}
 export function markAgentRunPushed(run, now) {
     if (run.status !== "active") {
         throw new Error(`Cannot push a terminal Agent run: ${run.id}.`);
@@ -66,14 +104,23 @@ export function markAgentRunDelivered(run, now) {
     };
 }
 export function validateAgentRun(run) {
-    if (run.schemaVersion !== 7)
-        throw new Error("Agent run must use schemaVersion 7.");
+    if (run.schemaVersion !== 9)
+        throw new Error("Agent run must use schemaVersion 9.");
     validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "agentRun");
     requireSafeIdentity(run.roleName, "Role name");
     if (run.mode !== "new" && run.mode !== "resume") {
         throw new Error(`Agent run dispatch mode is invalid: ${String(run.mode)}.`);
     }
-    requireText(run.input, "Agent run input");
+    validateRunAssignment(run.assignment);
+    validateRunBootstrapEnvelope(run.bootstrapEnvelope);
+    if (run.assignment.runId !== run.id || run.assignment.roleName !== run.roleName
+        || run.assignment.subject.taskId !== run.taskId) {
+        throw new Error("Agent run Assignment identity does not match the Run.");
+    }
+    if (JSON.stringify(createRunBootstrapEnvelope(run.assignment))
+        !== JSON.stringify(run.bootstrapEnvelope)) {
+        throw new Error("Agent run Bootstrap Envelope does not match its Assignment.");
+    }
     if (!["execution", "review"].includes(run.purpose)) {
         throw new Error(`Agent run purpose is invalid: ${String(run.purpose)}.`);
     }
@@ -186,6 +233,12 @@ export function validateAgentRun(run) {
             throw new Error("Agent run deliveredAt requires a prior pushedAt.");
         }
     }
+    if (run.deliveryReceiptId !== undefined) {
+        requireText(run.deliveryReceiptId, "Agent run deliveryReceiptId");
+        if (run.deliveryReceiptId.length > 256) {
+            throw new Error("Agent run deliveryReceiptId exceeds 256 characters.");
+        }
+    }
     if (run.status === "active") {
         if (run.summary !== undefined || run.endedAt !== undefined) {
             throw new Error("An active Agent run cannot have terminal metadata.");
@@ -219,6 +272,12 @@ export function validateAgentRun(run) {
             throw new Error("A terminal Agent run cannot carry a providerRetry projection.");
         }
     }
+    if (run.controlRequest !== undefined) {
+        validateAgentRunControlRequest(run.controlRequest);
+        if (run.status !== "active") {
+            throw new Error("A terminal Agent run cannot carry a controlRequest projection.");
+        }
+    }
     if (run.yieldReceipt !== undefined) {
         validateYieldReceipt(run.yieldReceipt);
         if (run.status !== "yielded") {
@@ -250,6 +309,8 @@ function finishAgentRun(run, status, summary, now) {
     if (terminal.providerRetry !== undefined) {
         delete terminal.providerRetry;
     }
+    if (terminal.controlRequest !== undefined)
+        delete terminal.controlRequest;
     return terminal;
 }
 /**
@@ -264,23 +325,47 @@ export function withProviderRetry(run, retry) {
 }
 /**
  * Reopens an active retry-waiting Run for another in-place attempt on its
- * original Native Session: transport markers are reset so the existing
- * delivery path re-pushes the exact same input, the dispatch mode becomes
- * `resume`, and the projection is marked in-flight.
+ * original Native Session. The original Run transport/acceptance timestamps
+ * remain historical facts; the new delivery receipt and `dispatching` retry
+ * state make the delivery path send only the short continuation envelope.
  */
-export function reopenRunForProviderRetry(run, now) {
+export function reopenRunForProviderRetry(run, receiptId, now) {
     if (run.status !== "active" || run.providerRetry === undefined) {
         throw new Error(`Agent run is not waiting for a provider retry: ${run.id}.`);
     }
     const timestamp = now.toISOString();
-    // Omit the transport markers entirely (not `undefined`, which the file
-    // store rejects) so the delivery path sees an un-pushed Run.
-    const { providerRetry, pushedAt: _pushedAt, deliveredAt: _deliveredAt, ...rest } = run;
+    const { providerRetry, ...rest } = run;
     return validateAgentRun({
         ...rest,
         mode: "resume",
+        deliveryReceiptId: receiptId,
         updatedAt: timestamp,
-        providerRetry: markProviderRetryInFlight(providerRetry, now)
+        providerRetry: prepareProviderRetryDispatch(providerRetry, receiptId, now)
+    });
+}
+/** Any exact correlated provider progress ends the active consecutive-failure episode. */
+export function clearProviderRetryOnProgress(run) {
+    if (run.providerRetry === undefined)
+        return run;
+    const { providerRetry: _providerRetry, ...rest } = run;
+    return validateAgentRun(rest);
+}
+export function agentRunDeliveryReceiptId(run) {
+    return run.deliveryReceiptId
+        ?? run.controlRequest?.receiptId
+        ?? run.providerRetry?.lastRetryReceiptId
+        ?? formatAgentRunReceiptId(run.taskId, run.id);
+}
+export function withAgentRunControlRequest(run, request, now) {
+    if (run.status !== "active" || run.providerRetry !== undefined) {
+        throw new Error(`Agent run cannot accept a control request: ${run.id}.`);
+    }
+    return validateAgentRun({
+        ...run,
+        mode: "resume",
+        deliveryReceiptId: request.receiptId,
+        controlRequest: validateAgentRunControlRequest(request),
+        updatedAt: now.toISOString()
     });
 }
 /** Attaches the Issue 04 yield receipt to a yielded Run. */

package/dist/run/providerRetry.js

@@ -1,24 +1,17 @@
+import { createHash } from "node:crypto";
 import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
-export const PROVIDER_RETRY_BASE_DELAY_MS = 1_000;
-export const PROVIDER_RETRY_MAX_DELAY_MS = 60_000;
-/**
- * Default total budget for one in-place retry lineage. The window starts at
- * the first classified failure and bounds the total wall-clock time the Run
- * may stay in `provider-retrying`; once it elapses the Run terminalizes with
- * one structured failure instead of looping.
- */
-export const PROVIDER_RETRY_MAX_WINDOW_MS = 600_000;
-/**
- * Bounded exponential backoff. The delay is capped in interval so a hot loop
- * can never occupy the control plane; the total retry lineage is bounded by
- * {@link PROVIDER_RETRY_MAX_WINDOW_MS} (see {@link providerRetryBudgetExhausted}).
- */
-export function nextProviderRetryDelayMs(attempt) {
-    if (!Number.isSafeInteger(attempt) || attempt < 1) {
-        throw new Error(`Provider retry attempt must be a positive integer: ${String(attempt)}.`);
+export const PROVIDER_RETRY_DELAYS_MS = Object.freeze([2_000, 5_000, 15_000]);
+export const PROVIDER_RETRY_MAX_DISPATCHES = PROVIDER_RETRY_DELAYS_MS.length;
+export const PROVIDER_RETRY_EPISODE_WINDOW_MS = 600_000;
+/** Durable configuration keeps the historical name for compatibility. */
+export const PROVIDER_RETRY_MAX_WINDOW_MS = PROVIDER_RETRY_EPISODE_WINDOW_MS;
+export function nextProviderRetryDelayMs(retryIndex) {
+    if (!Number.isSafeInteger(retryIndex)
+        || retryIndex < 1
+        || retryIndex > PROVIDER_RETRY_MAX_DISPATCHES) {
+        throw new Error(`Provider retry index is out of range: ${String(retryIndex)}.`);
     }
-    const exponent = Math.min(attempt - 1, 10);
-    return Math.min(PROVIDER_RETRY_MAX_DELAY_MS, PROVIDER_RETRY_BASE_DELAY_MS * (2 ** exponent));
+    return PROVIDER_RETRY_DELAYS_MS[retryIndex - 1];
 }
 /**
  * True when the retry lineage has used its total wall-clock budget. The
@@ -29,74 +22,192 @@ export function providerRetryBudgetExhausted(value, now, maxWindowMs = PROVIDER_
     if (!Number.isSafeInteger(maxWindowMs) || maxWindowMs <= 0) {
         throw new Error(`Provider retry max window must be a positive integer: ${String(maxWindowMs)}.`);
     }
-    return Date.parse(value.firstFailureAt) + maxWindowMs <= now.getTime();
+    return Math.min(Date.parse(value.episodeDeadlineAt), Date.parse(value.firstFailureAt) + maxWindowMs) <= now.getTime();
 }
 export function validateAgentRunProviderRetry(value) {
-    if (value.schemaVersion !== 1) {
-        throw new Error("Agent run providerRetry must use schemaVersion 1.");
+    if (value.schemaVersion !== 2) {
+        throw new Error("Agent run providerRetry must use schemaVersion 2.");
+    }
+    if (!["scheduled", "dispatching", "awaiting-progress", "blocked"].includes(value.state)) {
+        throw new Error("Agent run providerRetry state is invalid.");
     }
-    if (!Number.isSafeInteger(value.attempt) || value.attempt < 1) {
-        throw new Error("Agent run providerRetry attempt must be a positive integer.");
+    requireIdentity(value.episodeId, "Agent run providerRetry episodeId");
+    requireIdentity(value.failureEventId, "Agent run providerRetry failureEventId");
+    if (value.policyVersion !== 1)
+        throw new Error("Provider retry policy version is invalid.");
+    if (!Number.isSafeInteger(value.consecutiveFailures) || value.consecutiveFailures < 1) {
+        throw new Error("Agent run providerRetry consecutiveFailures must be positive.");
+    }
+    if (!Number.isSafeInteger(value.dispatchedRetries)
+        || value.dispatchedRetries < 0
+        || value.dispatchedRetries > value.maxRetries) {
+        throw new Error("Agent run providerRetry dispatchedRetries is invalid.");
+    }
+    if (value.maxRetries !== PROVIDER_RETRY_MAX_DISPATCHES) {
+        throw new Error("Agent run providerRetry maxRetries is invalid.");
     }
     requireTimestamp(value.firstFailureAt, "Agent run providerRetry firstFailureAt");
     requireTimestamp(value.lastFailureAt, "Agent run providerRetry lastFailureAt");
+    requireTimestamp(value.episodeDeadlineAt, "Agent run providerRetry episodeDeadlineAt");
     if (Date.parse(value.lastFailureAt) < Date.parse(value.firstFailureAt)) {
-        throw new Error("Agent run providerRetry lastFailureAt must not precede firstFailureAt.");
+        throw new Error("Agent run providerRetry lastFailureAt precedes firstFailureAt.");
+    }
+    if (Date.parse(value.episodeDeadlineAt) <= Date.parse(value.firstFailureAt)) {
+        throw new Error("Agent run providerRetry deadline must follow firstFailureAt.");
+    }
+    if ((value.state === "scheduled") !== (value.nextAttemptAt !== undefined)) {
+        throw new Error("Only a scheduled providerRetry may carry nextAttemptAt.");
     }
     if (value.nextAttemptAt !== undefined) {
         requireTimestamp(value.nextAttemptAt, "Agent run providerRetry nextAttemptAt");
+        if (Date.parse(value.nextAttemptAt) > Date.parse(value.episodeDeadlineAt)) {
+            throw new Error("Agent run providerRetry next attempt exceeds its episode deadline.");
+        }
     }
-    if (value.launchId !== undefined) {
-        requireIdentity(value.launchId, "Agent run providerRetry launchId");
+    if ((value.state === "dispatching" || value.state === "awaiting-progress")
+        !== (value.lastRetryReceiptId !== undefined)) {
+        throw new Error("An in-flight providerRetry requires one retry receipt identity.");
+    }
+    if (value.lastRetryReceiptId !== undefined) {
+        requireIdentity(value.lastRetryReceiptId, "Agent run providerRetry receipt id");
     }
+    if (value.launchId !== undefined)
+        requireIdentity(value.launchId, "Agent run providerRetry launchId");
     if (value.nativeSessionId !== undefined) {
         requireIdentity(value.nativeSessionId, "Agent run providerRetry nativeSessionId");
     }
+    if (value.failedNativeTurnId !== undefined) {
+        requireIdentity(value.failedNativeTurnId, "Agent run providerRetry failed native Turn id");
+    }
     requireText(value.lastErrorSummary, "Agent run providerRetry lastErrorSummary");
     return value;
 }
-/**
- * Records one more transient failure on a Run lineage. A fresh lineage starts
- * at attempt 1; an existing projection increments its attempt and keeps the
- * original `firstFailureAt`.
- */
+/** Advance one failure episode without ever changing the native Session. */
 export function scheduleProviderRetry(previous, input, now) {
-    const timestamp = now.toISOString();
-    const attempt = (previous?.attempt ?? 0) + 1;
-    const scheduleNextAttempt = input.scheduleNextAttempt ?? true;
-    return validateAgentRunProviderRetry({
-        schemaVersion: 1,
+    const at = now.toISOString();
+    const firstFailureAt = previous?.firstFailureAt ?? at;
+    const episodeDeadlineAt = previous?.episodeDeadlineAt
+        ?? new Date(now.getTime() + PROVIDER_RETRY_EPISODE_WINDOW_MS).toISOString();
+    if (now.getTime() >= Date.parse(episodeDeadlineAt)) {
+        return Object.freeze({ outcome: "exhausted", reason: "window" });
+    }
+    const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + 1;
+    const dispatchedRetries = previous?.dispatchedRetries ?? 0;
+    const schedule = input.scheduleNextAttempt ?? true;
+    if (schedule && dispatchedRetries >= PROVIDER_RETRY_MAX_DISPATCHES) {
+        return Object.freeze({ outcome: "exhausted", reason: "attempts" });
+    }
+    const state = schedule ? "scheduled" : "blocked";
+    const retryAfterMs = input.retryAfterMs;
+    if (retryAfterMs !== undefined && (!Number.isSafeInteger(retryAfterMs) || retryAfterMs <= 0)) {
+        throw new Error("Provider retry Retry-After must be a positive safe integer.");
+    }
+    const delayMs = schedule
+        ? Math.max(nextProviderRetryDelayMs(dispatchedRetries + 1), retryAfterMs ?? 0)
+        : undefined;
+    const nextAttemptAt = delayMs === undefined
+        ? undefined
+        : new Date(now.getTime() + delayMs).toISOString();
+    if (nextAttemptAt !== undefined && Date.parse(nextAttemptAt) > Date.parse(episodeDeadlineAt)) {
+        return Object.freeze({
+            outcome: "exhausted",
+            reason: retryAfterMs === undefined ? "window" : "retry-after-window"
+        });
+    }
+    const retry = validateAgentRunProviderRetry({
+        schemaVersion: 2,
+        episodeId: previous?.episodeId ?? createHash("sha256")
+            .update(`${firstFailureAt}\0${input.nativeSessionId ?? "unknown"}\0${input.launchId ?? "unknown"}`)
+            .digest("hex"),
+        failureEventId: requireIdentity(input.failureEventId, "Provider failure event id"),
+        policyVersion: 1,
+        state,
         errorClass: input.errorClass,
-        attempt,
-        firstFailureAt: previous?.firstFailureAt ?? timestamp,
-        lastFailureAt: timestamp,
-        ...(scheduleNextAttempt
-            ? {
-                nextAttemptAt: new Date(now.getTime() + nextProviderRetryDelayMs(attempt)).toISOString()
-            }
-            : {}),
+        consecutiveFailures,
+        dispatchedRetries,
+        maxRetries: PROVIDER_RETRY_MAX_DISPATCHES,
+        firstFailureAt,
+        lastFailureAt: at,
+        episodeDeadlineAt,
+        ...(nextAttemptAt === undefined ? {} : { nextAttemptAt }),
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
+        ...(input.failedNativeTurnId === undefined
+            ? {}
+            : { failedNativeTurnId: input.failedNativeTurnId }),
         lastErrorSummary: input.lastErrorSummary
     });
+    return Object.freeze({ outcome: schedule ? "scheduled" : "blocked", retry });
 }
-/**
- * Marks the projection in-flight: the retry has been dispatched and no
- * `nextAttemptAt` is due until the next outcome arrives.
- */
-export function markProviderRetryInFlight(value, now) {
-    if (value.nextAttemptAt === undefined)
+/** Mark that one short continuation request was dispatched and now awaits any correlated progress. */
+export function prepareProviderRetryDispatch(value, receiptId, now) {
+    if (value.state !== "scheduled" || value.nextAttemptAt === undefined)
         return value;
-    // Omit `nextAttemptAt` entirely so the projection is durably in-flight
-    // until the next outcome.
+    if (now.getTime() > Date.parse(value.episodeDeadlineAt)) {
+        throw new Error("Provider retry episode expired before dispatch.");
+    }
     const { nextAttemptAt: _nextAttemptAt, ...rest } = value;
     return validateAgentRunProviderRetry({
         ...rest,
-        lastFailureAt: now.toISOString()
+        state: "dispatching",
+        lastRetryReceiptId: requireIdentity(receiptId, "Provider retry receipt id")
+    });
+}
+export function markProviderRetryDispatched(value) {
+    if (value.state !== "dispatching")
+        return value;
+    return validateAgentRunProviderRetry({
+        ...value,
+        state: "awaiting-progress",
+        dispatchedRetries: value.dispatchedRetries + 1
     });
 }
-/** True when the projection is due for another attempt at `now`. */
 export function providerRetryIsDue(value, now) {
-    return value.nextAttemptAt !== undefined
+    return value.state === "scheduled"
+        && value.nextAttemptAt !== undefined
         && Date.parse(value.nextAttemptAt) <= now.getTime();
 }
+/**
+ * Next Controller wake for an active automatic retry episode. Scheduled
+ * retries wake to dispatch; an in-flight retry wakes only at the episode
+ * deadline so silence cannot strand the Run forever. Blocked states are
+ * intentionally excluded because they require native/user evidence rather
+ * than an automatic lifecycle transition.
+ */
+export function providerRetryWakeAt(value) {
+    if (value.state === "scheduled")
+        return value.nextAttemptAt ?? null;
+    if (value.state === "dispatching" || value.state === "awaiting-progress") {
+        return value.episodeDeadlineAt;
+    }
+    return null;
+}
+/** Delay a control-plane recovery gap without changing either failure counter. */
+export function deferProviderRetry(value, now) {
+    const deadline = Date.parse(value.episodeDeadlineAt);
+    if (now.getTime() >= deadline)
+        return null;
+    const { lastRetryReceiptId: _receipt, nextAttemptAt: _next, ...rest } = value;
+    return validateAgentRunProviderRetry({
+        ...rest,
+        state: "scheduled",
+        nextAttemptAt: new Date(Math.min(now.getTime() + 15_000, deadline)).toISOString()
+    });
+}
+/** Short recovery instruction; it cannot repeat the Task Assignment body. */
+export function serializeProviderRetryEnvelope(input) {
+    validateAgentRunProviderRetry(input.retry);
+    const retryOrdinal = input.retry.state === "dispatching"
+        ? input.retry.dispatchedRetries + 1
+        : input.retry.dispatchedRetries;
+    return [
+        "Yui managed in-Session continuation retry.",
+        `task=${requireIdentity(input.taskId, "Provider retry task id")} run=${requireIdentity(input.runId, "Provider retry run id")} role=${requireIdentity(input.roleName, "Provider retry role")}`,
+        `episode=${input.retry.episodeId} retry=${retryOrdinal}/${PROVIDER_RETRY_MAX_DISPATCHES} receipt=${input.retry.lastRetryReceiptId ?? "pending"}`,
+        `failureEvent=${input.retry.failureEventId}`,
+        ...(input.retry.failedNativeTurnId === undefined
+            ? []
+            : [`retryOfTurn=${input.retry.failedNativeTurnId}`]),
+        "Continue the existing native conversation from its latest accepted state. Do not repeat completed work; load exact Run deltas if needed."
+    ].join("\n");
+}

package/dist/run/providerRetryConfig.js

@@ -17,5 +17,9 @@ export function providerRetryConfig(config) {
 /** Whether the adapter has in-place retry enabled in the given mode. */
 export function providerRetryEnabledForAdapter(config, adapterId, mode) {
     return config.mode === mode
-        && config.adapters.includes(adapterId);
+        && providerRetryAdapterEnabled(config, adapterId);
+}
+/** Default admission is capability-driven, not a hard-coded Provider list. */
+export function providerRetryAdapterEnabled(config, adapterId) {
+    return config.adapters === "all-capable" || config.adapters.includes(adapterId);
 }

package/dist/run/runControlRequest.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { requireIdentity, requireTimestamp } from "../domain/validation.js";
+export const WORKFLOW_OUTCOME_REQUEST_TIMEOUT_MS = 30_000;
+export function createWorkflowOutcomeRequest(input) {
+    const requestedAt = input.now.toISOString();
+    return validateAgentRunControlRequest({
+        schemaVersion: 1,
+        kind: "workflow-outcome",
+        requestId: createHash("sha256")
+            .update(`${input.runId}\0${input.nativeTurnId}\0${requestedAt}`)
+            .digest("hex"),
+        state: "dispatching",
+        nativeTurnId: input.nativeTurnId,
+        receiptId: `workflow-outcome-${input.runId}-${input.nativeTurnId}`,
+        requestedAt,
+        deadlineAt: new Date(input.now.getTime() + WORKFLOW_OUTCOME_REQUEST_TIMEOUT_MS).toISOString()
+    });
+}
+export function validateAgentRunControlRequest(value) {
+    if (value.schemaVersion !== 1 || value.kind !== "workflow-outcome") {
+        throw new Error("Agent Run control request is unsupported.");
+    }
+    if (value.state !== "dispatching" && value.state !== "awaiting-outcome") {
+        throw new Error("Agent Run control request state is invalid.");
+    }
+    requireIdentity(value.requestId, "Agent Run control request id");
+    requireIdentity(value.nativeTurnId, "Agent Run control native Turn id");
+    requireIdentity(value.receiptId, "Agent Run control receipt id");
+    requireTimestamp(value.requestedAt, "Agent Run control requestedAt");
+    requireTimestamp(value.deadlineAt, "Agent Run control deadlineAt");
+    if (Date.parse(value.deadlineAt) <= Date.parse(value.requestedAt)) {
+        throw new Error("Agent Run control deadline must follow requestedAt.");
+    }
+    return value;
+}
+export function markWorkflowOutcomeRequestDispatched(value) {
+    validateAgentRunControlRequest(value);
+    return value.state === "dispatching"
+        ? validateAgentRunControlRequest({ ...value, state: "awaiting-outcome" })
+        : value;
+}
+export function serializeWorkflowOutcomeRequestEnvelope(input) {
+    validateAgentRunControlRequest(input.request);
+    return [
+        "Yui managed workflow-outcome request for the existing Run.",
+        `task=${requireIdentity(input.taskId, "Task id")} run=${requireIdentity(input.runId, "Run id")} role=${requireIdentity(input.roleName, "Role name")}`,
+        `request=${input.request.requestId} completedTurn=${input.request.nativeTurnId}`,
+        "Record the required Yui workflow outcome now. Do not replay the Assignment or repeat completed work."
+    ].join("\n");
+}

package/dist/runtime/agentDriver.js

@@ -41,6 +41,36 @@ export function validateAgentDriverCapabilities(input) {
             throw new Error(`Agent Driver control capability ${name} must be boolean.`);
         }
     }
+    const lifecycle = input.lifecycle;
+    if (lifecycle === null || typeof lifecycle !== "object" || Array.isArray(lifecycle)) {
+        throw new Error("Agent Driver lifecycle capabilities must be an object.");
+    }
+    if (lifecycle.host !== "persistent") {
+        throw new Error("Managed Agent Host lifecycle must be persistent.");
+    }
+    if (lifecycle.providerProcess !== "persistent" && lifecycle.providerProcess !== "per-turn") {
+        throw new Error("Provider process lifecycle capability is invalid.");
+    }
+    if (lifecycle.nativeConversationResume !== "exact"
+        && lifecycle.nativeConversationResume !== "unsupported") {
+        throw new Error("Native conversation resume capability is invalid.");
+    }
+    if (!["automatic", "native-explicit", "unsupported", "unknown"].includes(lifecycle.compaction)) {
+        throw new Error("Native compaction capability is invalid.");
+    }
+    if (lifecycle.compactionEvents !== "exact" && lifecycle.compactionEvents !== "unavailable") {
+        throw new Error("Native compaction event capability is invalid.");
+    }
+    if (!["per-request", "remaining-context", "cumulative-only", "unavailable"].includes(lifecycle.contextUsage)) {
+        throw new Error("Context usage capability is invalid.");
+    }
+    if (typeof lifecycle.inSessionContinuation !== "boolean") {
+        throw new Error("In-Session continuation capability must be boolean.");
+    }
+    if (lifecycle.deliveryDeduplication !== "exact"
+        && lifecycle.deliveryDeduplication !== "unsupported") {
+        throw new Error("Delivery deduplication capability is invalid.");
+    }
     const observation = input.observation;
     if (observation === null || typeof observation !== "object" || Array.isArray(observation)) {
         throw new Error("Agent Driver observation capabilities must be an object.");
@@ -92,6 +122,16 @@ export function validateAgentDriverCapabilities(input) {
     }
     return Object.freeze({
         surfaces: Object.freeze(surfaces),
+        lifecycle: Object.freeze({
+            host: lifecycle.host,
+            providerProcess: lifecycle.providerProcess,
+            nativeConversationResume: lifecycle.nativeConversationResume,
+            compaction: lifecycle.compaction,
+            compactionEvents: lifecycle.compactionEvents,
+            contextUsage: lifecycle.contextUsage,
+            inSessionContinuation: lifecycle.inSessionContinuation,
+            deliveryDeduplication: lifecycle.deliveryDeduplication
+        }),
         control: Object.freeze({
             start: control.start,
             resume: control.resume,
@@ -149,6 +189,13 @@ export function managedRuntimeAdmission(capabilities) {
     if (actual.observation.promptAcceptance !== "exact"
         || actual.input.acceptance !== "exact")
         missing.push("exact-prompt-acceptance");
+    if (actual.lifecycle.host !== "persistent")
+        missing.push("persistent-agent-host");
+    if (actual.lifecycle.nativeConversationResume !== "exact") {
+        missing.push("exact-native-conversation-resume");
+    }
+    if (!actual.lifecycle.inSessionContinuation)
+        missing.push("in-session-continuation");
     if (actual.observation.turnLifecycle !== "exact")
         missing.push("exact-turn-lifecycle");
     return missing.length === 0