@zq-silk/yui 0.15.11 → 0.15.12

package/dist/runtime/taskUsageMetrics.js

@@ -0,0 +1,275 @@
+import { builtinDriverIdForAdapter } from "./builtinAgentDrivers.js";
+import { isRuntimeTokenEvidence, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+import { projectSessionTokenObservations, unobservedSessionTokenMetrics } from "./sessionTokenMetrics.js";
+/**
+ * Pure lifetime projection. No transcript reads, collection, persistence,
+ * lifecycle decisions, guessed Run identities, or cumulative counter allocation.
+ */
+export function projectTaskUsageMetrics(input) {
+    const now = input.now ?? new Date();
+    const events = input.events.filter((event) => event.taskId === input.task.id);
+    const observations = events.flatMap((event) => {
+        const observation = runtimeObservationFromTaskEvent(event);
+        return observation !== null
+            && observation.fence.taskId === input.task.id
+            && Date.parse(observation.receivedAt) <= now.getTime()
+            ? [observation] : [];
+    }).sort(compare);
+    const runs = new Map(input.runs.filter((run) => run.taskId === input.task.id).map((run) => [run.id, run]));
+    const inScope = (observation) => {
+        if (input.workItemId === undefined)
+            return true;
+        const run = exactRun(observation, runs);
+        return run?.workItemId === input.workItemId;
+    };
+    const scoped = observations.filter(inScope);
+    const buckets = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        if (identity === null)
+            continue;
+        const key = identityKey(identity);
+        const bucket = buckets.get(key) ?? { identity, observations: [] };
+        bucket.observations.push(observation);
+        buckets.set(key, bucket);
+    }
+    const resourceOwners = new Map();
+    for (const { identity, observations: all } of buckets.values()) {
+        if (!all.some((observation) => !child(observation) && usageAuthority(observation)))
+            continue;
+        const resource = resourceKey(identity);
+        const owners = resourceOwners.get(resource) ?? new Set();
+        owners.add(identity.roleName);
+        resourceOwners.set(resource, owners);
+    }
+    const sessions = [...buckets.values()]
+        .sort((a, b) => identityKey(a.identity).localeCompare(identityKey(b.identity)))
+        .flatMap(({ identity, observations: all }) => {
+        if (!all.some(inScope))
+            return [];
+        const main = all.filter((observation) => !child(observation) && usageAuthority(observation));
+        const evidence = main.filter(isRuntimeTokenEvidence);
+        const metrics = projectSessionTokenObservations(main, identity);
+        let displayedMetrics = input.workItemId === undefined ? metrics : unobservedSessionTokenMetrics(identity);
+        const reasons = [];
+        if (all.some(child))
+            reasons.push("child-usage-overlap-unproven");
+        if (evidence.some(({ payload }) => payload.observationQuality === "partial"
+            || payload.observationQuality === "unavailable"))
+            reasons.push("source-coverage-partial");
+        let tokens = attributableTokens(evidence, metrics);
+        if (input.workItemId !== undefined) {
+            // Establish semantics and request ownership before filtering. Filtering
+            // first could hide a mixed stream or allocate a revised request twice.
+            if (metrics.cumulativeTotal.status !== "observed") {
+                tokens = metric(null, ["session-usage-unavailable"]);
+            }
+            else if (evidence.some(({ payload }) => payload.usage?.semantics === "cumulative-session")) {
+                tokens = metric(null, ["cumulative-not-allocatable-to-work-item"]);
+            }
+            else {
+                const requests = new Map();
+                for (const observation of evidence) {
+                    if (observation.payload.usage?.semantics !== "request-context")
+                        continue;
+                    const key = observation.payload.activityId ?? observation.semanticKey;
+                    requests.set(key, [...(requests.get(key) ?? []), observation]);
+                }
+                const selected = [];
+                for (const versions of requests.values()) {
+                    if (!versions.some(inScope))
+                        continue;
+                    const owners = new Set(versions.map((observation) => exactRun(observation, runs)?.id));
+                    if (owners.size !== 1 || owners.has(undefined) || !versions.every(inScope)) {
+                        reasons.push("request-run-attribution-conflict");
+                    }
+                    else {
+                        selected.push(...versions);
+                    }
+                }
+                displayedMetrics = projectSessionTokenObservations(selected, identity);
+                const subtotal = displayedMetrics.cumulativeTotal;
+                tokens = metric(subtotal.status === "observed" ? subtotal.totalTokens : null, subtotal.status === "observed" ? [] : ["no-attributable-request-usage"]);
+            }
+        }
+        if ((resourceOwners.get(resourceKey(identity))?.size ?? 0) > 1) {
+            tokens = metric(null, ["native-session-role-overlap"]);
+            displayedMetrics = unobservedSessionTokenMetrics(identity);
+        }
+        tokens = metric(tokens.value, [...tokens.reasons, ...reasons]);
+        return [{
+                identity,
+                semantics: [...new Set(evidence.flatMap(({ payload }) => payload.usage === undefined ? [] : [payload.usage.semantics]))].sort(),
+                sources: [...new Set(evidence.map(({ authority, payload }) => payload.observerSource?.sourceId ?? authority))].sort(),
+                observedThrough: all.filter(inScope).at(-1).receivedAt,
+                tokens,
+                metrics: displayedMetrics
+            }];
+    });
+    const reasons = [];
+    if (scoped.some((observation) => sessionIdentity(observation) === null))
+        reasons.push("session-identity-missing");
+    for (const run of runs.values()) {
+        if (input.workItemId !== undefined && run.workItemId !== input.workItemId)
+            continue;
+        if (!observations.some((observation) => exactRun(observation, runs)?.id === run.id
+            && usageAuthority(observation) && isRuntimeTokenEvidence(observation)))
+            reasons.push("run-usage-unobserved");
+    }
+    const tokenValues = sessions.flatMap(({ tokens }) => tokens.value === null ? [] : [tokens.value]);
+    const sum = safeSum(tokenValues);
+    const tokens = metric(tokenValues.length === 0 ? null : sum, [...reasons, ...sessions.flatMap(({ tokens }) => tokens.reasons),
+        ...(sum === null ? ["counter-overflow"] : []),
+        ...(sessions.length === 0 ? ["no-token-evidence"] : [])]);
+    const operations = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        const { nativeTurnId } = observation.fence;
+        if (!usageAuthority(observation) || child(observation) || identity === null || nativeTurnId === undefined
+            || !observation.kind.startsWith("operation.")
+            || observation.payload.operation !== "tool" || observation.payload.operationId === undefined)
+            continue;
+        const key = JSON.stringify([resourceKey(identity), nativeTurnId, observation.payload.operationId]);
+        const versions = operations.get(key) ?? [];
+        versions.push(observation);
+        operations.set(key, versions);
+    }
+    const toolCount = [...operations.values()].filter((versions) => {
+        if (input.workItemId === undefined)
+            return true;
+        const owners = new Set(versions.map((observation) => exactRun(observation, runs)?.id));
+        return owners.size === 1 && !owners.has(undefined) && versions.every(inScope);
+    }).length;
+    return {
+        scope: "task-lifetime", taskId: input.task.id,
+        ...(input.workItemId === undefined ? {} : { workItemId: input.workItemId }),
+        observedThrough: scoped.at(-1)?.receivedAt ?? null,
+        tokens,
+        toolCalls: metric(toolCount === 0 ? null : toolCount, ["tool-history-compacted"]),
+        elapsedSeconds: input.workItemId === undefined
+            ? taskElapsed(input.task, events, now) : metric(null, ["work-item-lifecycle-not-task-elapsed"]),
+        executionSeconds: executionDuration(scoped, now),
+        coverage: {
+            basis: "task-fenced-observations",
+            observedSessions: sessions.length,
+            tokenSessions: tokenValues.length,
+            completeness: "observed-sources-only"
+        },
+        sessions
+    };
+}
+function attributableTokens(evidence, metrics) {
+    const total = metrics.cumulativeTotal;
+    if (total.status !== "observed")
+        return metric(null, ["session-usage-unavailable"]);
+    const cumulative = evidence.filter(({ payload }) => payload.usage?.semantics === "cumulative-session");
+    if (cumulative.length === 0)
+        return metric(total.totalTokens);
+    const first = cumulative[0].payload.usage;
+    const baseline = first.inputTokens + first.outputTokens;
+    if (baseline === 0)
+        return metric(total.totalTokens);
+    // session.started also occurs on resume: it cannot prove a fresh counter.
+    // A nonzero first counter may predate this Task, so exclude it. A single
+    // snapshot does not prove even a zero delta.
+    return cumulative.length < 2
+        ? metric(null, ["nonzero-session-baseline"])
+        : metric(total.totalTokens - baseline, ["nonzero-session-baseline"]);
+}
+function exactRun(observation, runs) {
+    const { fence } = observation;
+    const run = fence.runId === undefined ? undefined : runs.get(fence.runId);
+    if (run === undefined || fence.nativeSessionId === undefined || run.roleName !== fence.roleName
+        || run.effective.agentId !== fence.agentId)
+        return undefined;
+    try {
+        return builtinDriverIdForAdapter(run.effective.adapterId) === fence.driverId ? run : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sessionIdentity({ fence }) {
+    return fence.taskId === undefined || fence.nativeSessionId === undefined ? null : {
+        taskId: fence.taskId, roleName: fence.roleName, agentId: fence.agentId,
+        driverId: fence.driverId, nativeSessionId: fence.nativeSessionId
+    };
+}
+function identityKey(identity) {
+    return JSON.stringify([identity.taskId, identity.roleName, identity.agentId, identity.driverId, identity.nativeSessionId]);
+}
+function resourceKey(identity) {
+    return JSON.stringify([identity.agentId, identity.driverId, identity.nativeSessionId]);
+}
+function child({ fence }) {
+    return fence.continuationId !== undefined || fence.parentContinuationId !== undefined;
+}
+function usageAuthority(observation) {
+    return observation.authority === "provider-structured" || observation.authority === "driver-inferred";
+}
+function compare(left, right) {
+    return left.receivedAt.localeCompare(right.receivedAt)
+        || (left.sequence ?? -1) - (right.sequence ?? -1)
+        || (left.ordinal ?? -1) - (right.ordinal ?? -1)
+        || left.eventId.localeCompare(right.eventId);
+}
+function metric(value, reasons = []) {
+    return {
+        value, status: value === null ? "unknown" : reasons.length === 0 ? "known" : "partial",
+        reasons: [...new Set(reasons)].sort()
+    };
+}
+function safeSum(values) {
+    const sum = values.reduce((a, b) => a + b, 0);
+    return Number.isSafeInteger(sum) && sum >= 0 ? sum : null;
+}
+function taskElapsed(task, events, now) {
+    const terminal = task.status === "completed"
+        || task.status === "cancelled" || task.status === "archived";
+    const cancelledAt = events.filter((event) => event.type === "task.cancelled")
+        .map(({ createdAt }) => createdAt).sort().at(-1);
+    const end = terminal ? task.completedAt ?? task.retiredAt ?? cancelledAt : now.toISOString();
+    const elapsed = end === undefined ? NaN : (Date.parse(end) - Date.parse(task.createdAt)) / 1000;
+    return Number.isFinite(elapsed) && elapsed >= 0
+        ? metric(elapsed) : metric(null, ["task-lifecycle-time-missing"]);
+}
+function executionDuration(observations, now) {
+    const turns = new Map();
+    for (const observation of observations) {
+        const identity = sessionIdentity(observation);
+        const { nativeTurnId } = observation.fence;
+        if (identity === null || nativeTurnId === undefined || child(observation) || !usageAuthority(observation))
+            continue;
+        const resource = resourceKey(identity);
+        const key = JSON.stringify([resource, nativeTurnId]);
+        const turn = turns.get(key) ?? { resource };
+        const time = Date.parse(observation.observedAt ?? observation.receivedAt);
+        if (observation.kind === "turn.accepted")
+            turn.start = Math.min(turn.start ?? time, time);
+        if (["turn.completed", "turn.failed", "turn.cancelled"].includes(observation.kind)) {
+            turn.end = Math.max(turn.end ?? time, time);
+        }
+        turns.set(key, turn);
+    }
+    const intervals = new Map();
+    for (const turn of turns.values()) {
+        if (turn.start === undefined || turn.end === undefined || turn.end < turn.start || turn.end > now.getTime())
+            continue;
+        intervals.set(turn.resource, [...(intervals.get(turn.resource) ?? []), [turn.start, turn.end]]);
+    }
+    let milliseconds = 0;
+    for (const ranges of intervals.values()) {
+        ranges.sort((a, b) => a[0] - b[0]);
+        let end = -Infinity;
+        for (const range of ranges) {
+            milliseconds += Math.max(0, range[1] - Math.max(end, range[0]));
+            end = Math.max(end, range[1]);
+        }
+    }
+    return metric(intervals.size === 0 ? null : milliseconds / 1000, ["native-turn-history-compacted"]);
+}
+/** CLI/audit formatting shares the same metric contract; Web localizes labels. */
+export function formatUsageMetric(metric, suffix = "") {
+    return metric.value === null ? `unknown (${metric.reasons.join(", ")})`
+        : `${metric.value}${suffix}${metric.status === "partial" ? ` (partial: ${metric.reasons.join(", ")})` : ""}`;
+}

package/dist/scheduler/activeRoleRunDelivery.js

@@ -51,6 +51,18 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
     });
     const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
     const binding = sessionSet?.providerBinding ?? null;
+    if (binding?.retry !== undefined && (binding.retry.successorRunId === run.id
+        || binding.retry.successorReviewRoundId !== undefined && binding.retry.successorReviewRoundId === run.reviewRoundId)
+        && ["cancelled", "exhausted", "needs-attention"].includes(binding.retry.status)
+        && binding.run?.runId !== run.id) {
+        return failRunDelivery(store, run, now, "runtime-failed", `Scheduled Provider retry ${binding.retry.status}: ${binding.retry.reason ?? "not admitted"}`);
+    }
+    if (binding?.retry?.status === "waiting"
+        && (binding.retry.successorRunId === run.id || binding.retry.successorReviewRoundId !== undefined
+            && binding.retry.successorReviewRoundId === run.reviewRoundId)
+        && now.getTime() < Date.parse(binding.retry.nextEligibleAt)) {
+        return { ...base, status: "skipped", reason: "not-ready" };
+    }
     const observedRun = binding?.run ?? null;
     const initialAttemptId = formatRunReceiptId(task.id, run.id);
     const currentProviderTurn = managedProviderTurnId(observedRun) === run.id ? observedRun : null;

package/dist/scheduler/leaderWakeupProcessor.js

@@ -3,6 +3,7 @@ import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { hasImmediateWakeReason } from "./wakeReason.js";
+import { providerRetryPending } from "../runtime/providerRetry.js";
 export const LEADER_WAKE_AGGREGATION_MS = 60_000;
 /** Deliver a durable mailbox notification, not an implicit execution assignment.
  * Acceptance settles only its claimed batch; no Agent report is required.
@@ -34,6 +35,10 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         }
         const sessions = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
         const provider = sessions?.providerBinding;
+        if (providerRetryPending(provider)) {
+            results.push({ ...base, status: "skipped", reason: "not-ready" });
+            continue;
+        }
         if (provider?.authority.owner === "human" || provider?.authority.owner === "unknown") {
             results.push({ ...base, status: "skipped", reason: "busy" });
             continue;

package/dist/scheduler/taskExecutionProjection.js

@@ -1,5 +1,6 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { providerRetryProjection } from "../runtime/providerRetry.js";
 import { taskOwnsManagedWorkspace } from "../task/task.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
@@ -19,7 +20,8 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         return null;
     const roles = store.listRoles?.(taskId) ?? [];
     const events = store.listEvents?.(taskId) ?? [];
-    const runs = operationalTaskRecords(store.listRuns?.(taskId) ?? [], events, "run");
+    const usageRuns = store.listRuns?.(taskId) ?? [];
+    const runs = operationalTaskRecords(usageRuns, events, "run");
     const leaderMailbox = store.getWorkMailbox?.({
         kind: "role",
         taskId,
@@ -35,6 +37,11 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride, now =
         task,
         roles,
         runs,
+        usageRuns,
+        providerRetries: roles.flatMap(role => {
+            const retry = providerRetryProjection(store.getTaskRoleSessionSet?.(taskId, role.name)?.providerBinding);
+            return retry === null ? [] : [retry];
+        }),
         runDelivery: Object.fromEntries(runs.map((run) => {
             const observed = store.getTaskRoleSessionSet?.(taskId, run.roleName)?.providerBinding?.run;
             return [run.id, observed?.runId === run.id ? observed.status : "unobserved"];
@@ -79,6 +86,7 @@ export function projectTaskExecutionFromFacts(facts) {
     return projectTaskExecution({
         ...facts,
         runs,
+        usageRuns: facts.usageRuns ?? facts.runs,
         executionGroups
     });
 }
@@ -107,9 +115,10 @@ export function projectTaskExecution(facts) {
         });
     });
     const observability = buildTaskObservabilityProjection({
+        task,
         workItems,
         executionGroups: observabilityGroups,
-        runs,
+        runs: facts.usageRuns ?? runs,
         events,
         contextSnapshots: facts.contextSnapshots,
         sessionTokens,
@@ -206,8 +215,12 @@ export function projectTaskExecution(facts) {
     const hasPendingLeaderWork = pendingWakeup !== null
         || leaderMailbox?.pending !== null;
     const recoveryPending = isRecoveryPending(pendingWakeup, leaderMailbox, leaderFailure);
-    const failedWork = workItems.some((item) => item.status === "open"
-        && runs.filter((run) => run.workItemId === item.id).at(-1)?.status === "failed");
+    const providerRecoveries = (facts.providerRetries ?? []).filter(retry => retry.status === "waiting" || retry.status === "in-flight");
+    const recoveringRunIds = new Set(providerRecoveries.flatMap(retry => [retry.previousRunId, retry.successorRunId].filter((id) => id !== undefined)));
+    const failedWork = workItems.some((item) => {
+        const last = runs.filter((run) => run.workItemId === item.id).at(-1);
+        return item.status === "open" && last?.status === "failed" && !recoveringRunIds.has(last.id);
+    });
     const candidateReady = workItems.some((item) => (item.status === "open" && item.currentCandidateId !== undefined));
     const blockedIntegration = integrations.some((attempt) => attempt.status === "blocked");
     const conflictedIntegration = integrations.find((attempt) => attempt.status === "conflicted");
@@ -258,7 +271,7 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
-    if (laneRecovery !== undefined) {
+    if (laneRecovery !== undefined && (laneRecovery.runId === undefined || !recoveringRunIds.has(laneRecovery.runId))) {
         return render({
             task,
             status: laneRecovery.runtimeHealth === "confirmed-dead"
@@ -306,6 +319,14 @@ export function projectTaskExecution(facts) {
             pendingWakeup
         });
     }
+    if (providerRecoveries.length > 0 && healthyActiveRuns.length === 0) {
+        return render({
+            task, status: "recovering", owner: "none", action: "none",
+            summary: `${providerRecoveries.length} Provider recovery chain(s) are cooling down or awaiting their exact result; existing work is preserved. Do not dispatch a duplicate.`,
+            reason: "provider-recovery", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (recoveryPending) {
         return render({
             task,

package/dist/scheduler/taskObservabilityProjection.js

@@ -1,3 +1,4 @@
+import { projectTaskUsageMetrics } from "../runtime/taskUsageMetrics.js";
 /**
  * Build the read-only DAG, execution, cost, and context view consumed by CLI
  * and Web. It deliberately derives every value from existing Task records and
@@ -8,7 +9,7 @@ export function buildTaskObservabilityProjection(input) {
     const dag = projectDag(input.workItems);
     const workItems = input.workItems.map((item) => {
         const groups = item.executionGroups;
-        const itemCost = projectWorkItemCost(groups, input.runs, now);
+        const itemCost = projectCost({ ...input, now }, groups, item.id);
         const itemContext = projectContext(groups, input.runs, input.contextSnapshots);
         const producerObservability = projectWorkItemProducerObservability(item, input.runs);
         return Object.freeze({
@@ -21,7 +22,7 @@ export function buildTaskObservabilityProjection(input) {
             resultCount: producerObservability?.resultCount ?? null
         });
     });
-    const cost = projectCost(input.executionGroups, input.runs, input.events, now);
+    const cost = projectCost({ ...input, now }, input.executionGroups);
     const context = projectContext(input.executionGroups, input.runs, input.contextSnapshots);
     return Object.freeze({
         dag,
@@ -140,17 +141,13 @@ function dependencyEdgeStatus(id, byId) {
         return "active";
     return "active";
 }
-function projectCost(groups, runs, _events, now) {
+function projectCost(input, groups, workItemId) {
     const uniqueGroups = [...new Map(groups.map((group) => [group.id, group])).values()];
     const groupIds = new Set(uniqueGroups.map(({ id }) => id));
-    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
+    const attempts = input.runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
     const laneCount = uniqueGroups.reduce((total, group) => total + group.lanes.length, 0);
     return Object.freeze({
-        tokens: 0,
-        toolCalls: 0,
-        wallClockSeconds: uniqueGroups.reduce((total, group) => total + groupDurationSeconds(group, now), 0),
-        tokensObservable: false,
-        toolCallsObservable: false,
+        ...projectTaskUsageMetrics({ ...input, workItemId }),
         laneCount,
         groupCount: uniqueGroups.length,
         retryCount: Math.max(0, attempts.length - laneCount),
@@ -158,32 +155,6 @@ function projectCost(groups, runs, _events, now) {
         marginalValueStatus: "unavailable"
     });
 }
-function projectWorkItemCost(groups, runs, now) {
-    const groupIds = new Set(groups.map(({ id }) => id));
-    const attempts = runs.filter(({ executionGroupId }) => (executionGroupId !== undefined && groupIds.has(executionGroupId)));
-    const wallClockSeconds = groups.reduce((total, group) => {
-        const started = Date.parse(group.createdAt);
-        const ended = group.lanes.some(({ disposition }) => disposition === "open")
-            ? now.getTime()
-            : Date.parse(group.updatedAt);
-        return total + (Number.isFinite(started) && Number.isFinite(ended)
-            ? Math.max(0, Math.floor((ended - started) / 1_000))
-            : 0);
-    }, 0);
-    const laneCount = groups.reduce((total, group) => total + group.lanes.length, 0);
-    return Object.freeze({
-        tokens: 0,
-        toolCalls: 0,
-        wallClockSeconds,
-        tokensObservable: false,
-        toolCallsObservable: false,
-        laneCount,
-        groupCount: groups.length,
-        retryCount: Math.max(0, attempts.length - laneCount),
-        marginalValuePercent: null,
-        marginalValueStatus: "unavailable"
-    });
-}
 function projectContext(groups, runs, snapshots) {
     const refs = new Map();
     for (const group of groups) {
@@ -223,12 +194,3 @@ function projectContext(groups, runs, snapshots) {
         compressionStatus: "unavailable"
     });
 }
-function groupDurationSeconds(group, now) {
-    const started = Date.parse(group.createdAt);
-    const ended = group.lanes.some(({ disposition }) => disposition === "open")
-        ? now.getTime()
-        : Date.parse(group.updatedAt);
-    return Number.isFinite(started) && Number.isFinite(ended)
-        ? Math.max(0, Math.floor((ended - started) / 1_000))
-        : 0;
-}

package/dist/storage/sqliteSchema.js

@@ -1264,6 +1264,37 @@ UPDATE review_rounds SET payload = json_set(payload, '$.executionGroup.lanes', j
         // The data/filesystem transform is the substantive step; the SQL is inert.
         sql: COLLAPSE_WORKTREE_LAYOUT_SQL,
         migrateData: migrateCollapseWorktreeLayout
+    },
+    {
+        version: 26,
+        name: "publication-candidate-adoption",
+        introducedIn: "0.15.12",
+        // Add optional Publication.headCommit (the observed PR/MR source head) and
+        // publication.candidate-adopted events binding publicationId, completionEventId,
+        // projectId, acceptedCommit/localCommit, acceptedTree/candidateTree, diffDigest,
+        // acceptance and by, optionally integrationId/integrationDigest. Derived
+        // task.archived mergeCoverage may also be uncovered or unverified.
+        // No stored delivery index and no inferred adoption or verification:
+        // valid old Publication, completion and archive payloads remain byte-identical.
+        sql: "SELECT 1; -- fixed acceptance-to-publication evidence; preserve all historical facts"
+    },
+    {
+        version: 27,
+        name: "bounded-provider-input-retry",
+        introducedIn: "0.16.0",
+        // Optional owned input/recovery records on the existing Provider binding;
+        // positive Driver transient evidence on StandardAgentError. No historical
+        // failures are scanned, scheduled, reclassified or replayed by upgrading.
+        sql: `
+-- ProviderTurn.input/retrySupported/failure; ProviderRuntimeBinding.retry/retryHistory/retryDisabled;
+-- optional error retryable and retryAfterMs facts. Index existing records only.
+CREATE INDEX idx_task_provider_retry ON role_session_sets(
+  json_extract(payload, '$.providerBinding.retry.status')
+) WHERE json_extract(payload, '$.providerBinding.retry.status') IN ('waiting', 'in-flight');
+CREATE INDEX idx_global_provider_retry ON global_role_session_sets(
+  json_extract(payload, '$.providerBinding.retry.status')
+) WHERE json_extract(payload, '$.providerBinding.retry.status') IN ('waiting', 'in-flight');
+`
     }
 ]);
 for (let index = 0; index < MIGRATIONS.length; index += 1) {

package/dist/storage/sqliteStore.js

@@ -38,6 +38,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
+import { queryTaskCatalog } from "./taskCatalog.js";
 import { validatePluginValidation } from "../plugins/pluginPackage.js";
 import { validatePluginIntent, validatePluginIntentFailure } from "../plugins/pluginIntent.js";
 import { validateLocalResource, validateEnvironmentPreparation } from "../resources/projectResource.js";
@@ -921,6 +922,15 @@ export class SqliteTaskStore {
         const tasks = this.#listPayload("task_records", "1=1", []);
         return this.#sortById(tasks, (task) => task.id);
     }
+    queryTaskCatalog(query) {
+        return queryTaskCatalog(this.#db, query);
+    }
+    listTaskChoices() {
+        const rows = this.#db.prepare(`SELECT c.task_id AS id, c.status,
+      json_extract(r.payload, '$.title') AS title
+      FROM tasks_catalog c JOIN task_records r ON r.task_id = c.task_id`).all();
+        return this.#sortById(rows, task => task.id);
+    }
     getTask(id) {
         return this.#getPayload("task_records", "task_id = ?", [id]);
     }
@@ -1267,6 +1277,13 @@ export class SqliteTaskStore {
     listRoleSessionSets(taskId) {
         return this.#sortById(this.#listPayload("role_session_sets", "task_id = ?", [taskId]), (set) => set.owner.roleName);
     }
+    listProviderRetrySessions() {
+        const pending = "json_extract(payload, '$.providerBinding.retry.status') IN ('waiting', 'in-flight')";
+        return [
+            ...this.#listPayload("role_session_sets", pending, []),
+            ...this.#listPayload("global_role_session_sets", pending, [])
+        ];
+    }
     listRuntimeSessionCandidates(query = {}) {
         const taskIds = query.taskIds === undefined
             ? undefined

package/dist/storage/storageVersions.js

@@ -13,4 +13,4 @@
  * intermediate Yui releases.
  */
 export const MIN_SUPPORTED_STORAGE_VERSION = 1;
-export const CURRENT_STORAGE_VERSION = 25;
+export const CURRENT_STORAGE_VERSION = 27;

package/dist/storage/storeRpc.js

@@ -72,6 +72,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "getRoleSessionSet",
     "getTaskRoleSessionSet",
     "listRoleSessionSets",
+    "listProviderRetrySessions",
     "listRuntimeSessionCandidates",
     "getRoleSession",
     "getWorkItem",