@zq-silk/yui 0.15.11 → 0.15.12

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -30,6 +30,7 @@ export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate
         publications: store.listPublicationReferences(task.id),
         managedWorkspaces: store.listManagedWorkspaces(task.id),
         runs: store.listRuns(task.id),
+        integrations: store.listIntegrationAttempts(task.id),
         currentCandidate
     });
 }
@@ -41,6 +42,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
         publications,
         managedWorkspaces: store.listManagedWorkspaces(task.id),
         runs: store.listRuns(task.id),
+        integrations: store.listIntegrationAttempts(task.id),
         currentCandidate
     });
     return {
@@ -60,6 +62,15 @@ export function assertTaskRemoteDeliveryProof(store, task, proof) {
     if (!isDeepStrictEqual(proof.publications, store.listPublicationReferences(task.id))) {
         throw usageError(`Task Publication evidence changed after remote-delivery preflight: ${task.id}.`);
     }
+    // Recheck semantic adoption/Integration facts as well as Publication versions.
+    // For provisional cancelled Tasks retain the frozen candidate used at preflight.
+    const current = projectTaskRemoteDeliveryFromStore(store, task, {
+        projects: proof.delivery.projects.flatMap(p => p.expectedLocalCommit === null
+            ? [] : [{ projectId: p.projectId, commit: p.expectedLocalCommit }])
+    });
+    if (!isDeepStrictEqual(current, proof.delivery)) {
+        throw usageError(`Task delivery evidence changed after remote-delivery preflight: ${task.id}.`);
+    }
     assertTaskRemoteDeliveryIntegrated(proof.delivery);
     return proof.delivery;
 }
@@ -68,16 +79,15 @@ export function assertTaskRemoteDeliveryIntegrated(delivery) {
         const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
             && project.coverage === "head-unavailable"));
         if (headUnavailable.length > 0 && delivery.source === "task-completed") {
-            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Reopen and complete it again to record exact heads before archiving; `
-                + "An explicitly authorized --force archive retains this evidence gap.");
+            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Historical acceptance cannot be inferred from a merge or archive.`);
         }
         const uncovered = delivery.projects
             .filter((project) => project.codeDelivery !== "none" && !project.merged)
             .map((project) => (`${project.projectId}/${project.coverage}`
             + (project.publication === null ? "" : `/${project.publication.id}`)))
             .join(", ");
-        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Record confirmed current-head evidence with task publication upsert, `
-            + "or use task archive --abandon for an intentional non-merge.");
+        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Inspect each Project reason with task remote-delivery. Record confirmed Publication facts; `
+            + "for a changed post-completion candidate, review publication diff and explicitly adopt its acceptance.");
     }
     if (delivery.allVerified)
         return;
@@ -90,8 +100,7 @@ export function assertTaskRemoteDeliveryIntegrated(delivery) {
         .join(", ");
     throw usageError(`Task ${delivery.taskId} has merged Publication evidence that is not verified: `
         + `${unverified || "verification evidence is unavailable"}. Run task publication verify `
-        + "for each Publication, or repeat task archive --integrated --force to explicitly "
-        + "archive despite evidence gaps, retaining the original delivery facts.");
+        + "for each Publication only when the provider read is authorized.");
 }
 export function renderTaskRemoteDelivery(delivery, indent = "") {
     const source = `${delivery.source}${delivery.provisional ? " (provisional)" : ""}`;
@@ -108,12 +117,14 @@ export function renderTaskRemoteDelivery(delivery, indent = "") {
         `${indent}Projects:${delivery.projects.length === 0 ? " none" : ""}`,
         ...delivery.projects.map((project) => (`${indent}- ${project.directory} (${project.projectId}): `
             + `expected=${shortCommit(project.expectedLocalCommit)}; `
+            + `candidate=${shortCommit(project.deliveryLocalCommit)}; `
+            + `adoption=${project.adoption?.id ?? "none"}; `
             + `base=${shortCommit(project.baseCommit)}; `
             + `publication=${project.publication?.id ?? "none"}; `
             + `state=${project.state ?? "none"}; `
             + `verification=${project.verification ?? "none"}; `
             + `remote=${shortCommit(project.remoteCommit)}; `
-            + `coverage=${project.coverage}`))
+            + `coverage=${project.coverage}\n${indent}  ${project.reason}`))
     ];
     return `${lines.join("\n")}\n`;
 }

package/dist/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { providerRetryProjection } from "../runtime/providerRetry.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_INPUT_MAX_DELTAS } from "./runInputContract.js";
@@ -295,6 +296,8 @@ function readLiveTaskState(store, taskId) {
         status: round.status
     }));
     return Object.freeze({
+        providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetryProjection(set.providerBinding) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });

package/dist/context/taskCatalog.js

@@ -0,0 +1,187 @@
+import { usageError } from "../errors/cliError.js";
+import { contextContentDigest } from "./contextSnapshot.js";
+import { materialize, resolveContextReader } from "./taskContext.js";
+import { CATALOG_ATTENTION } from "../storage/taskCatalog.js";
+const TASK_STATUSES = ["draft", "active", "completed", "cancelled", "archived"];
+const PAGE_BYTES = 32 * 1024;
+const SUMMARY_BYTES = 512;
+const MAX_LIMIT = 100;
+export function parseTaskCatalogOptions(args) {
+    const values = new Map();
+    let all = false;
+    for (let i = 0; i < args.length; i++) {
+        const key = args[i];
+        if (key === "--all" && !all) {
+            all = true;
+            continue;
+        }
+        if (!["--view", "--limit", "--cursor", "--status", "--project", "--search", "--attention"].includes(key)
+            || values.has(key) || args[i + 1] === undefined || args[i + 1].startsWith("--")) {
+            throw usageError("Compact Task list expects --view compact [--all] [--status <status>] [--project <id>] [--search <text>] [--attention <category>] [--limit <1..100>] [--cursor <cursor>].");
+        }
+        values.set(key, args[++i]);
+    }
+    if (values.get("--view") !== "compact")
+        throw usageError("Task list view must be compact.");
+    const status = values.get("--status");
+    if (status !== undefined && !TASK_STATUSES.includes(status)) {
+        throw usageError("Unknown Task catalog status.");
+    }
+    const attention = values.get("--attention");
+    if (attention !== undefined && !CATALOG_ATTENTION.includes(attention)) {
+        throw usageError(`Task catalog attention must be one of: ${CATALOG_ATTENTION.join(", ")}.`);
+    }
+    const limit = values.has("--limit") ? Number(values.get("--limit")) : 20;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIMIT)
+        throw usageError("Task catalog limit must be between 1 and 100.");
+    const search = values.get("--search")?.trim();
+    const project = values.get("--project")?.trim();
+    if ((search?.length ?? 0) > 256 || (project?.length ?? 0) > 256 || project === "") {
+        throw usageError("Task catalog filters exceed their text limit.");
+    }
+    return {
+        all: all || status === "archived", limit,
+        ...(status === undefined ? {} : { status: status }),
+        ...(attention === undefined ? {} : { attention: attention }),
+        ...(search ? { search } : {}),
+        ...(project === undefined ? {} : { project }),
+        ...(values.has("--cursor") ? { cursor: values.get("--cursor") } : {})
+    };
+}
+/** Task-local Leaders discover only their Task. Assignment Roles use their
+ * existing Context pack: whole-Task counts would leak unrelated assignments. */
+export function taskCatalogScope(store, environment) {
+    const caller = resolveContextReader(store, environment);
+    if (caller !== undefined && caller.roleName !== "leader") {
+        throw usageError("Task discovery is unavailable to an Assignment-scoped Role; use its authorized Run Context.");
+    }
+    return caller?.taskId;
+}
+export function readTaskCatalog(store, options, environment = {}) {
+    return store.transaction(reader => {
+        const taskId = taskCatalogScope(reader, environment);
+        const { cursor: rawCursor, ...filters } = options;
+        if (!Number.isSafeInteger(filters.limit) || filters.limit < 1 || filters.limit > MAX_LIMIT) {
+            throw usageError("Task catalog limit must be between 1 and 100.");
+        }
+        const scope = contextContentDigest({ taskId: taskId ?? null, ...filters });
+        const cursor = rawCursor === undefined ? undefined : decodeCursor(rawCursor, scope);
+        const facts = reader.queryTaskCatalog({
+            ...filters, ...(taskId === undefined ? {} : { taskId }),
+            ...(cursor === undefined ? {} : { after: cursor.after, through: cursor.through }),
+            limit: options.limit + 1
+        });
+        const refs = new Map();
+        const getRef = (id) => {
+            let ref = refs.get(id);
+            if (ref === undefined) {
+                const task = reader.getTask(id);
+                if (task === null)
+                    throw usageError("Task catalog changed during the read; retry.");
+                ref = { taskId: id, ...materialize("task", id, task).ref };
+                refs.set(id, ref);
+            }
+            return ref;
+        };
+        const attention = Object.fromEntries(CATALOG_ATTENTION.map(kind => {
+            const source = facts.attention[kind];
+            const selected = [];
+            for (const id of source.taskIds) {
+                const ref = getRef(id);
+                if (bytes([...selected, ref]) <= 2048)
+                    selected.push(ref);
+            }
+            return [kind, {
+                    count: source.count,
+                    unit: kind === "executionSignals" ? "signals" : "records",
+                    refs: selected,
+                    // Samples identify affected Tasks, not individual records. Count and
+                    // sample size therefore must never be subtracted from one another.
+                    taskCount: source.taskCount,
+                    omittedTaskRefs: source.taskCount - selected.length,
+                    query: { view: "compact", all: options.all, attention: kind }
+                }];
+        }));
+        const response = {
+            view: "compact",
+            scope: { taskId: taskId ?? null, archived: options.all ? "included" : "excluded",
+                attention: "authorized-catalog-before-filters", executionSignals: "raw-inspection-candidates-not-execution-status" },
+            filters, total: facts.total, counts: facts.counts, attention,
+            tasks: [],
+            nextCursor: null,
+            consistency: "current-per-page; refresh for membership changes; new creation keys after the upper bound excluded",
+            limits: { pageBytes: PAGE_BYTES, summaryBytes: SUMMARY_BYTES, maxTasks: options.limit, attentionTaskRefsPerCategory: 4 }
+        };
+        const through = cursor?.through ?? facts.through;
+        const continuation = (after) => through === null ? null
+            : Buffer.from(JSON.stringify({ version: 1, scope, after, through })).toString("base64url");
+        for (const row of facts.rows.slice(0, options.limit)) {
+            const ref = getRef(row.id);
+            const summary = row.summary === null ? null : truncateUtf8(row.summary, SUMMARY_BYTES);
+            const title = truncateUtf8(row.title, 256);
+            // SQL already limits these fields. Compare against the selected original
+            // only when necessary; length-at-limit is conservatively marked omitted.
+            const item = {
+                id: row.id, title, status: row.status, createdAt: row.createdAt, updatedAt: row.updatedAt,
+                summary, summaryStatus: row.summaryPresent ? "available" : "missing",
+                omitted: { title: row.title.length >= 256 || title !== row.title,
+                    summary: row.summary !== null && (row.summary.length >= 512 || summary !== row.summary) },
+                counts: { workItems: row.workItems, activeRuns: row.activeRuns },
+                attention: Object.fromEntries(CATALOG_ATTENTION.map(kind => [kind, row[kind]])),
+                ref
+            };
+            const next = continuation({ id: row.id, createdAt: row.createdAt });
+            if (bytes({ ok: true, data: { ...response, tasks: [...response.tasks, item], nextCursor: next } }) + 1 > PAGE_BYTES)
+                break;
+            response.tasks.push(item);
+        }
+        if (response.tasks.length < facts.rows.length) {
+            const last = response.tasks.at(-1);
+            if (last === undefined)
+                throw usageError("Task catalog identity/attention metadata exceeds the page byte budget.");
+            response.nextCursor = continuation({ id: last.id, createdAt: last.createdAt });
+        }
+        if (bytes({ ok: true, data: response }) + 1 > PAGE_BYTES)
+            throw usageError("Task catalog metadata exceeds the page byte budget.");
+        return response;
+    });
+}
+export function renderTaskCatalog(result) {
+    return [
+        `Tasks (compact): ${result.tasks.length} shown; ${result.total} matching`,
+        ...result.tasks.map(task => `${task.id}\t${task.status}\t${task.title}\n  ${task.summary ?? "(summary missing)"}`),
+        `Attention across catalog: ${CATALOG_ATTENTION.map(kind => `${kind}=${result.attention[kind].count}`).join(", ")}`,
+        "Expand: yui task context <task-id>; inspect the Task ref for original requirements.",
+        ...(result.nextCursor === null ? [] : [`Next cursor: ${result.nextCursor}`])
+    ].join("\n") + "\n";
+}
+function bytes(value) { return Buffer.byteLength(JSON.stringify(value)); }
+function truncateUtf8(value, max) {
+    let result = "";
+    let size = 0;
+    for (const point of value) {
+        size += Buffer.byteLength(point);
+        if (size > max)
+            break;
+        result += point;
+    }
+    return result;
+}
+function decodeCursor(raw, scope) {
+    try {
+        if (raw.length > 4096 || !/^[A-Za-z0-9_-]+$/.test(raw))
+            throw new Error();
+        const parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+        const validKey = (key) => key && typeof key.id === "string" && key.id.length > 0
+            && typeof key.createdAt === "string" && Number.isFinite(Date.parse(key.createdAt));
+        if (parsed.version !== 1 || parsed.scope !== scope || !validKey(parsed.after) || !validKey(parsed.through)
+            || parsed.after.createdAt > parsed.through.createdAt
+            || (parsed.after.createdAt === parsed.through.createdAt
+                && Buffer.compare(Buffer.from(parsed.after.id), Buffer.from(parsed.through.id)) > 0))
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw usageError("Invalid Task catalog cursor or cursor belongs to another scope/filter.");
+    }
+}

package/dist/context/taskContext.js

@@ -7,6 +7,8 @@ import { expandTaskMessageResult } from "../message/message.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { runExecutionObservation } from "../agentRun/agentRun.js";
 import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
+import { projectTaskRemoteDeliveryFromStore } from "../commands/taskRemoteDeliveryCommand.js";
+import { providerRetryProjection } from "../runtime/providerRetry.js";
 const MAX_RECORDS = 256;
 const MAX_VALUE_BYTES = 4096;
 const MAX_PAGE_BYTES = 128 * 1024;
@@ -33,6 +35,8 @@ export function readTaskContext(store, taskId, environment = {}) {
                 : { ...entry, omitted: false };
             const record = { ...content, ...(entry.ref.store === "run" ? {
                     execution: runExecutionObservation(entry.value, reader.getTaskRoleSessionSet(taskId, entry.value.roleName)?.providerBinding, runtimeEvents)
+                } : {}), ...(entry.ref.store === "role" ? {
+                    providerRetry: providerRetryProjection(reader.getTaskRoleSessionSet(taskId, entry.value.name)?.providerBinding)
                 } : {}) };
             const size = Buffer.byteLength(JSON.stringify(record));
             if (records.length >= MAX_RECORDS || bytes + size > MAX_PAGE_BYTES)
@@ -201,10 +205,9 @@ export async function withContextObservations(core, providers, timeoutMs = 250)
     }));
     return { ...core, observations };
 }
-function authorizeContext(store, taskId, environment) {
+/** Shared current/historical Session read identity; discovery may only narrow it. */
+export function resolveContextReader(store, environment) {
     const caller = resolveManagedTaskReader(store, environment);
-    if (caller !== undefined && caller.taskId !== taskId)
-        throw usageError("Context is outside the caller's Task.");
     if (caller === undefined && environment.YUI_SESSION_SCOPE === "global" && environment.YUI_ROLE !== "operator") {
         throw usageError("Only Operator may read Task context from a global Session.");
     }
@@ -216,6 +219,12 @@ function authorizeContext(store, taskId, environment) {
     if (environment.YUI_SESSION_SCOPE !== undefined && !["task", "global"].includes(environment.YUI_SESSION_SCOPE)) {
         throw usageError("Incomplete managed Context caller identity.");
     }
+    return caller;
+}
+function authorizeContext(store, taskId, environment) {
+    const caller = resolveContextReader(store, environment);
+    if (caller !== undefined && caller.taskId !== taskId)
+        throw usageError("Context is outside the caller's Task.");
     const task = store.getTask(taskId);
     if (task === null)
         throw taskNotFound(taskId);
@@ -299,6 +308,8 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
     switch (family) {
         case "task": return refId === taskId ? task : null;
         case "task-brief": return refId === taskId ? store.getTaskBrief(taskId) : null;
+        case "remote-delivery": return refId === taskId && allow === undefined
+            ? projectTaskRemoteDeliveryFromStore(store, task) : null;
         case "role": return store.getRole(taskId, refId);
         case "role-profile": {
             const role = store.getRole(taskId, refId);
@@ -397,6 +408,8 @@ function authorizedEntries(store, taskId, environment) {
     };
     add("task", taskId, task);
     add("task-brief", taskId, store.getTaskBrief(taskId));
+    if (allow === undefined)
+        add("remote-delivery", taskId, projectTaskRemoteDeliveryFromStore(store, task));
     for (const role of store.listRoles(taskId)) {
         add("role", role.name, role);
         add("role-profile", role.name, roleProfile(role));
@@ -464,7 +477,7 @@ function authorizedEntries(store, taskId, environment) {
         add("task-event", event.id, event);
     return entries;
 }
-function materialize(store, refId, value) {
+export function materialize(store, refId, value) {
     const digest = contextContentDigest(value);
     const record = value;
     return { ref: { store, refId, revision: String(record.revision ?? record.updatedAt ?? record.createdAt ?? digest), digest }, value };

package/dist/controller/controller.js

@@ -702,6 +702,7 @@ export class FileTaskController {
     #leaderWakeFence;
     #jobSupervisor;
     #globalInputDelivery;
+    #providerRetry;
     #continuationReconciler;
     #current;
     #operatorCurrent;
@@ -711,6 +712,7 @@ export class FileTaskController {
     #operatorStartupRetryArmed = false;
     #lastOperatorSignalIdentity;
     #stopped = false;
+    #workspaceWaitAbort = new AbortController();
     #lastRuntimeDrain;
     #runtimeDrainPasses = 0;
     #runtimeListedEvents = 0;
@@ -724,7 +726,11 @@ export class FileTaskController {
         this.#now = options.now ?? (() => new Date());
         this.#startedAt = this.#now();
         this.#onError = options.onError ?? (() => { });
-        this.#workspacePreparer = options.workspacePreparer;
+        const workspacePreparer = options.workspacePreparer;
+        this.#workspacePreparer = workspacePreparer === undefined ? undefined : {
+            prepareTaskWorkspace: (taskId) => workspacePreparer.prepareTaskWorkspace(taskId, this.#workspaceWaitAbort.signal),
+            activateTaskWorkspace: (taskId, environment) => workspacePreparer.activateTaskWorkspace(taskId, environment, this.#workspaceWaitAbort.signal)
+        };
         this.#deliveryRetryMs = positiveInteger(options.deliveryRetryMs, DEFAULT_DELIVERY_RETRY_MS, "Controller delivery retry delay");
         this.#deliveryRetryLimit = positiveInteger(options.deliveryRetryLimit, DEFAULT_DELIVERY_RETRY_LIMIT, "Controller delivery retry limit");
         this.#deliveryTimeoutMs = positiveInteger(options.deliveryTimeoutMs, DEFAULT_DELIVERY_TIMEOUT_MS, "Controller delivery timeout");
@@ -749,6 +755,7 @@ export class FileTaskController {
         this.#jobSupervisor = options.jobSupervisor;
         this.#continuationReconciler = options.continuationReconciler;
         this.#globalInputDelivery = options.globalInputDelivery;
+        this.#providerRetry = options.providerRetry;
         this.#signalScheduler = new MailboxScheduler(async (keys) => { await this.#requestPass({ kind: "dirty", keys }); }, {
             windowMs: options.signalWindowMs ?? DEFAULT_SIGNAL_WINDOW_MS,
             onError: this.#onError,
@@ -846,6 +853,7 @@ export class FileTaskController {
     }
     stop() {
         this.#stopped = true;
+        this.#workspaceWaitAbort.abort(new Error("Controller stopped while waiting for Project maintenance."));
         this.#signalScheduler.stop();
         this.#operatorSignalScheduler.stop();
         if (this.#deadlineTimer !== undefined) {
@@ -988,6 +996,7 @@ export class FileTaskController {
                         }
                     }
                     const firstRuntimeDrain = await this.#drainRuntimeEvents();
+                    await this.#providerRetry?.reconcile();
                     await this.#globalInputDelivery?.();
                     for (const taskId of runtimeTaskFailureIds(firstRuntimeDrain)) {
                         runtimeFailedTaskIds.add(taskId);
@@ -1331,7 +1340,7 @@ export class FileTaskController {
                     at: Date.parse(request.policy.timeoutAt)
                 }]
             : []);
-        const nearest = nearestDeadlineBatch(deadlines);
+        const nearest = nearestDeadlineBatch([...deadlines, ...(this.#providerRetry?.deadlines() ?? [])]);
         if (nearest === null)
             return;
         const now = this.#now().getTime();

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -6,6 +6,9 @@ import { isDeepStrictEqual } from "node:util";
 import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
 import { resolveAgentHostObservation, recordAgentHostConnection, AgentHostObservationDeferred } from "./agentHostObservation.js";
 import { RuntimeHookRunFenceError } from "./runtimeHookRunFence.js";
+import { admitOwnedProviderInput, ownedProviderInput } from "./providerRetryAdmission.js";
+import { recordProviderFailure, providerRetryPending, deferProviderRetry } from "../runtime/providerRetry.js";
+import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindGlobalRoleProviderRuntime, createRoleSessionSet, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleNativeTurnBoundary, rememberRoleAgentCompletedTurn, detachRoleAgentSessionHost, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime, updateGlobalRoleProviderRuntime, selectNewTaskRoleSession, taskRoleControlTarget } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, cancelQuiescentProviderInput, beginProviderTurn, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, clearProviderGoal, settleProviderTurnSubmission, settleProviderTurn, transferProviderAuthority, supersedeProviderConversation, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -404,7 +407,9 @@ export class FileSchedulerStoreAdapter {
                 }
                 else if (binding.run?.status !== "accepted")
                     return "applied";
-                const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`);
+                const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`
+                    || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                        && binding.retry.input.messageId === entry.id);
                 if (message !== undefined)
                     store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
             }
@@ -417,7 +422,9 @@ export class FileSchedulerStoreAdapter {
                 if (input.kind === "turn.completed" && binding.run != null
                     && ["submitting", "delivery-unknown"].includes(binding.run.status)) {
                     binding = acceptProviderTurn(binding, { attemptId: receipt, nativeTurnId: fence.nativeTurnId, acceptedAt: at });
-                    const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`);
+                    const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`
+                        || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                            && binding.retry.input.messageId === entry.id);
                     if (message !== undefined)
                         store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
                 }
@@ -449,7 +456,13 @@ export class FileSchedulerStoreAdapter {
             else if (input.kind === "conversation.observed" && input.payload.recoverability !== undefined) {
                 binding = updateProviderConversationRecoverability(binding, input.payload.recoverability);
             }
+            if (input.kind === "turn.failed" && matches && input.payload.failure !== undefined) {
+                binding = recordProviderFailure(binding, {
+                    error: input.payload.failure.error, failureRef: input.eventId, at: now.getTime()
+                });
+            }
             store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, binding, now));
+            settleGlobalRetryInput(store, fence.roleName, binding, now);
             return "applied";
         });
     }
@@ -751,7 +764,8 @@ export class FileSchedulerStoreAdapter {
                     ...(failure.lastOutput === undefined ? {} : { lastOutput: failure.lastOutput })
                 }, now);
                 store.saveEvent(taskId, errorEvent);
-                routeRoleEvent(store, errorEvent, input.fence.roleName, wakeReason("agent-error", errorEvent.id), now);
+                if (!providerRetryPending(store.getTaskRoleSessionSet(taskId, input.fence.roleName)?.providerBinding))
+                    routeRoleEvent(store, errorEvent, input.fence.roleName, wakeReason("agent-error", errorEvent.id), now);
             }
             if ((input.kind === "operation.completed" || input.kind === "operation.failed")
                 && input.payload.operation === "subagent") {
@@ -1092,7 +1106,7 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderTurnFenceError("Global Session admission is stopped.");
                 }
                 const sessions = store.getGlobalRoleSessionSet(input.roleName);
-                const binding = sessions?.providerBinding;
+                let binding = sessions?.providerBinding;
                 const session = sessions?.sessions[input.agentId];
                 if (sessions === null || binding == null || session === undefined
                     || sessions.activeAgentId !== input.agentId || session.status !== "active"
@@ -1104,8 +1118,10 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderTurnFenceError("Global input carries a stale Session or writer fence.");
                 }
                 const turn = binding.run;
-                if (turn?.attemptId === input.attemptId && turn.status === "submitting")
+                if (turn?.attemptId === input.attemptId && turn.status === "submitting") {
+                    admitOwnedProviderInput(store, binding, input);
                     return;
+                }
                 if (turn != null && ["submitting", "accepted", "delivery-unknown"].includes(turn.status)) {
                     throw new AgentHostProviderSessionBusyError("Global Conversation has an unsettled input.");
                 }
@@ -1139,7 +1155,10 @@ export class FileSchedulerStoreAdapter {
                             receiptId: input.attemptId, outcome: "pending", observedAt: input.now.toISOString()
                         } });
                 }
+                binding = admitOwnedProviderInput(store, binding, input);
                 store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, beginProviderTurn(binding, { attemptId: input.attemptId,
+                    input: binding.retry?.currentAttemptId === input.attemptId ? binding.retry.input : ownedProviderInput(input),
+                    retrySupported: input.retrySupported,
                     authorityEpoch: input.authorityEpoch, submittedAt: input.now.toISOString() }), input.now));
             });
             return;
@@ -1157,7 +1176,7 @@ export class FileSchedulerStoreAdapter {
             }
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const session = sessions?.sessions[input.agentId];
-            const binding = sessions?.providerBinding;
+            let binding = sessions?.providerBinding;
             const active = store.getActiveRun(input.taskId, input.roleName);
             if (sessions === null || sessions === undefined || binding === null || binding === undefined || (input.runId !== undefined && (active?.id !== input.runId || active.effective.agentId !== input.agentId)) || session === undefined || session.nativeSessionId !== input.nativeSessionId || currentProviderConversation(binding).conversationId !== input.nativeSessionId || binding.authority.owner !== input.authorityOwner || binding.authority.epoch !== input.authorityEpoch || binding.authority.holderId !== input.holderId) {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
@@ -1214,11 +1233,14 @@ export class FileSchedulerStoreAdapter {
                     }
                 }
             }
+            binding = admitOwnedProviderInput(store, binding, input);
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, beginProviderTurn(binding, {
                 ...(input.runId === undefined ? {} : { runId: input.runId }),
                 attemptId: input.attemptId,
                 authorityEpoch: input.authorityEpoch,
-                submittedAt: input.now.toISOString()
+                submittedAt: input.now.toISOString(),
+                input: binding.retry?.currentAttemptId === input.attemptId ? binding.retry.input : ownedProviderInput(input),
+                retrySupported: input.retrySupported
             }), input.now));
         });
     }
@@ -1230,8 +1252,11 @@ export class FileSchedulerStoreAdapter {
                 if (input.runId !== undefined || sessions == null || binding?.run?.attemptId !== input.attemptId) {
                     throw new Error("Global input submission is no longer current.");
                 }
-                store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, settleProviderTurnSubmission(binding, { attemptId: input.attemptId, status: input.status,
-                    reason: input.reason, resolvedAt: input.now.toISOString() }), input.now));
+                let resolved = settleProviderTurnSubmission(binding, { attemptId: input.attemptId, status: input.status,
+                    reason: input.reason, resolvedAt: input.now.toISOString() });
+                resolved = this.retrySubmissionResolution(resolved, input, sessions.sessions[sessions.activeAgentId]?.adapterId);
+                store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, resolved, input.now));
+                settleGlobalRetryInput(store, input.roleName, resolved, input.now);
                 const message = store.listGlobalRoleMessages(input.roleName).find(entry => input.attemptId === `global-input:${input.roleName}/${entry.id}`);
                 if (message !== undefined && message.delivery?.via !== "provider") {
                     const outcome = input.status === "delivery-unknown" ? "delivery-unknown" : "rejected";
@@ -1239,7 +1264,7 @@ export class FileSchedulerStoreAdapter {
                             requestId: message.inputControl?.requestId ?? message.interruptThen.requestId,
                             receiptId: input.attemptId, outcome, observedAt: input.now.toISOString()
                         } };
-                    store.updateGlobalRoleMessage(input.status === "rejected" && updated.delivery === undefined
+                    store.updateGlobalRoleMessage(input.status === "rejected" && updated.delivery === undefined && !providerRetryPending(resolved)
                         ? markGlobalRoleMessageNotDelivered(updated, input.reason, input.now) : updated);
                 }
             });
@@ -1257,20 +1282,18 @@ export class FileSchedulerStoreAdapter {
                 || binding.run?.attemptId !== input.attemptId) {
                 throw new Error("Agent Host Provider Turn submission is no longer current.");
             }
-            const updated = settleProviderTurnSubmission(binding, {
+            let updated = settleProviderTurnSubmission(binding, {
                 attemptId: input.attemptId,
                 status: input.status,
                 reason: input.reason,
                 resolvedAt: input.now.toISOString()
             });
+            updated = this.retrySubmissionResolution(updated, input, sessions.sessions[sessions.activeAgentId]?.adapterId);
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
-            if (input.runId === undefined)
-                return;
-            const run = store.getRun(input.taskId, input.runId);
+            const run = input.runId === undefined ? null : store.getRun(input.taskId, input.runId);
             const session = sessions.sessions[sessions.activeAgentId];
-            const driver = run === null
-                ? null
-                : this.drivers.findByAdapterId(run.effective.adapterId);
+            const adapterId = run?.effective.adapterId ?? session?.adapterId;
+            const driver = adapterId === undefined ? null : this.drivers.findByAdapterId(adapterId);
             const error = standardAgentError({
                 source: "driver",
                 phase: "turn-submit",
@@ -1284,7 +1307,7 @@ export class FileSchedulerStoreAdapter {
             });
             const errorEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
                 sourceEventId: input.attemptId,
-                runId: input.runId,
+                runId: input.runId ?? "",
                 roleName: input.roleName,
                 agentId: run?.effective.agentId ?? sessions.activeAgentId,
                 adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
@@ -1306,7 +1329,7 @@ export class FileSchedulerStoreAdapter {
                 sessionDisposition: error.sessionDisposition
             }, input.now);
             store.saveEvent(input.taskId, errorEvent);
-            if (input.status === "deferred")
+            if (input.status === "deferred" || providerRetryPending(updated))
                 return;
             const route = input.roleName === "leader"
                 ? { kind: "operator" }
@@ -1319,6 +1342,30 @@ export class FileSchedulerStoreAdapter {
             });
         });
     }
+    retrySubmissionResolution(binding, input, adapterId) {
+        if (input.status === "deferred")
+            return deferProviderRetry(binding, input.now.getTime());
+        const driver = adapterId === undefined ? null : this.drivers.findByAdapterId(adapterId);
+        const classification = driver?.runtime.mapError({ message: input.reason, raw: input.raw });
+        const error = standardAgentError({
+            source: "driver", phase: "turn-submit", classification,
+            message: input.reason, raw: input.raw,
+            inputDisposition: input.status === "delivery-unknown" ? "unknown" : "not-accepted"
+        });
+        // Native preflight issued no mutation. Transient metadata failures may
+        // cool down within the same deadline; unavailable proof needs an Agent.
+        const noProviderWrite = input.status === "rejected" && input.noProviderWrite === true;
+        if (noProviderWrite && classification?.retryable !== true) {
+            const recorded = binding.run === null ? binding : {
+                ...binding, run: { ...binding.run, failure: { error, ref: input.attemptId } }
+            };
+            return deferProviderRetry(recorded, input.now.getTime(), input.reason);
+        }
+        return recordProviderFailure(binding, {
+            error,
+            failureRef: input.attemptId, at: input.now.getTime(), noProviderWrite
+        });
+    }
     getProviderAuthorityFence(input) {
         const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
         const session = sessions?.sessions[input.agentId];
@@ -2140,6 +2187,12 @@ export class FileSchedulerStoreAdapter {
                 && sessions.providerBinding !== null) {
                 sessions = updateTaskRoleProviderRuntime(sessions, updateProviderConversationRecoverability(sessions.providerBinding, "unrecoverable"), now);
             }
+            if (input.observation?.kind === "turn.failed" && input.observation.payload.failure !== undefined
+                && sessions.providerBinding !== null) {
+                sessions = updateTaskRoleProviderRuntime(sessions, recordProviderFailure(sessions.providerBinding, {
+                    error: input.observation.payload.failure.error, failureRef: input.observation.eventId, at: now.getTime()
+                }), now);
+            }
             store.saveTaskRoleSessionSet(sessions);
             let terminalRun;
             if (recordedProviderTurn && observedRun?.status === "active") {
@@ -2482,6 +2535,14 @@ export class FileSchedulerStoreAdapter {
                         return "obsolete";
                     }
                     store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
+                    const retry = binding.retry;
+                    if (retry?.currentAttemptId === ordinaryAttemptId && retry.input.kind === "wake") {
+                        const originalWakeId = retry.input.wakeId;
+                        const original = store.listTaskWakes(input.fence.taskId).find(w => w.id === originalWakeId);
+                        if (original !== undefined && original.status !== "consumed") {
+                            store.saveTaskWake(input.fence.taskId, markTaskWakeConsumed(original, now));
+                        }
+                    }
                     return "applied";
                 }
             }