@zq-silk/yui 0.15.9 → 0.15.12

package/dist/runtime/taskRuntimeIsolation.js

@@ -65,7 +65,9 @@ export class FileTaskRuntimeIsolation {
             this.#resourceRegistrar().registerTaskRuntimeIsolation(descriptor);
             return;
         }
-        ensureDirectoryChain(this.#runtimeRoot, dirname(root));
+        ensureDirectoryChain(this.#controlPlane.managedRuntimeRoot === undefined
+            ? this.#runtimeRoot
+            : this.#controlPlane.yuiHome, dirname(root));
         mkdirSync(root, { mode: 0o700 });
         try {
             const marker = {
@@ -255,10 +257,22 @@ export function assertTaskRuntimeIsolationPreflight(input) {
         }
     }
     const control = normalizeControlBoundary(input.controlPlane);
-    const protectedPaths = [control.yuiHome, ...control.globalInstallPaths];
     for (const root of Object.values(descriptor.roots)) {
-        if (protectedPaths.some((path) => pathsOverlap(root, path))) {
-            throw new Error("Task runtime roots overlap the control YUI_HOME or a global install path.");
+        if (control.globalInstallPaths.some((path) => pathsOverlap(root, path))) {
+            throw new Error("Task runtime roots overlap a global install path.");
+        }
+        // Precise partition isolation: a runtime root may occupy Home only when it
+        // is fully within the single designated managed runtime partition. Every
+        // other part of Home — the database, managed Git workspaces, projects —
+        // stays protected. Both Task and integration runtimes now supply such a
+        // partition; a caller that supplies none keeps the whole-Home overlap ban.
+        if (pathsOverlap(root, control.yuiHome)) {
+            const partition = control.managedRuntimeRoot;
+            const withinPartition = partition !== undefined
+                && (root === partition || isWithin(partition, root));
+            if (!withinPartition) {
+                throw new Error("Task runtime roots overlap the control YUI_HOME outside the managed runtime partition.");
+            }
         }
         if (pathsOverlap(root, descriptor.workspace.root)) {
             throw new Error("Task runtime roots must not dirty the managed workspace.");
@@ -441,11 +455,21 @@ function taskRuntimeServiceNamespace(taskId, owner, runtimeRoot) {
     ])).slice(0, 24)}`;
 }
 function normalizeControlBoundary(value) {
+    const yuiHome = canonicalPath(value.yuiHome, "Control YUI_HOME");
+    const managedRuntimeRoot = value.managedRuntimeRoot === undefined
+        ? undefined
+        : canonicalPath(value.managedRuntimeRoot, "Managed runtime root");
+    if (managedRuntimeRoot !== undefined
+        && managedRuntimeRoot !== yuiHome
+        && !isWithin(yuiHome, managedRuntimeRoot)) {
+        throw new Error("Managed runtime root must be within the control YUI_HOME.");
+    }
     return Object.freeze({
-        yuiHome: canonicalPath(value.yuiHome, "Control YUI_HOME"),
+        yuiHome,
         controllerSocketPath: canonicalPath(value.controllerSocketPath, "Controller socket path"),
         tmuxNamespace: requireIdentity(value.tmuxNamespace, "Controller tmux namespace"),
-        globalInstallPaths: Object.freeze((value.globalInstallPaths ?? []).map((path) => canonicalPath(path, "Global install path")))
+        globalInstallPaths: Object.freeze((value.globalInstallPaths ?? []).map((path) => canonicalPath(path, "Global install path"))),
+        ...(managedRuntimeRoot === undefined ? {} : { managedRuntimeRoot })
     });
 }
 function validateObservation(resource) {

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/runtime/tmuxAdapters.js

@@ -209,7 +209,8 @@ export class TmuxSessionHost {
                 throw toRuntimeLaunchFailure(error, "validation", launchContext);
             }
         }
-        const interactiveCodex = request.owner.scope === "global" && request.adapterId === "codex";
+        const interactiveCodex = request.owner.scope === "global" && request.adapterId === "codex"
+            && planned.launch.providerControl === undefined;
         let reuseInteractivePane = false;
         if (interactiveCodex) {
             let status;
@@ -310,6 +311,7 @@ export class TmuxSessionHost {
         }
         const reservation = broker.reserve(Object.freeze({
             schemaVersion: 2,
+            ...(request.runId === undefined ? {} : { startupRunId: request.runId }),
             command: planned.launch.command,
             args: [...planned.launch.args],
             environment: { ...planned.launch.env },
@@ -577,8 +579,8 @@ export class AgentHostPromptPushAdapter {
         try {
             const result = await sendAgentHostSteerControl({
                 home: this.home,
-                scope: "task",
-                taskId: request.owner.taskId,
+                scope: request.owner.scope,
+                ...(request.owner.scope === "task" ? { taskId: request.owner.taskId } : {}),
                 roleName: request.owner.roleName,
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL,

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/operatorEvent.js

@@ -4,6 +4,8 @@ import { queueLeaderWakeup } from "./wakeupQueue.js";
 export const LEADER_ATTENTION_REQUIRED_EVENT = "leader.attention-required";
 /** The sole Task-event boundary into the global Operator mailbox. */
 export function enqueueOperatorEvent(store, event, reason, now) {
+    if (store.getTask?.(event.taskId)?.status === "archived")
+        return;
     enqueueWork(store, { kind: "operator" }, reason, now, [
         { type: "event", taskId: event.taskId, id: event.id }
     ], {
@@ -13,6 +15,8 @@ export function enqueueOperatorEvent(store, event, reason, now) {
 }
 /** Routes one Role fact to its supervisor without exposing Provider details to Operator code. */
 export function routeRoleEvent(store, event, roleName, reason, now) {
+    if (store.getTask?.(event.taskId)?.status === "archived")
+        return;
     if (roleName === "leader") {
         enqueueOperatorEvent(store, event, reason, now);
         return;

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,13 +215,19 @@ 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");
     const unresolvedIntegration = integrations.some((attempt) => (attempt.status === "running"
         || attempt.status === "validating"
-        || attempt.status === "blocked"));
+        || attempt.status === "blocked"
+        || attempt.status === "conflicted"));
     const hasLeaderMismatch = attention.some((item) => item.kind === "identity-mismatch");
     const renderAttention = () => {
         const first = attention[0];
@@ -256,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"
@@ -279,6 +294,15 @@ export function projectTaskExecution(facts) {
     if (attention.length > 0) {
         return renderAttention();
     }
+    if (conflictedIntegration !== undefined) {
+        return render({
+            task, status: "needs-leader-action", owner: "leader",
+            action: "resolve-integration-conflicts",
+            summary: `Integration ${conflictedIntegration.id} has Git conflicts; resolve its workspace and continue.`,
+            reason: "integration-conflicted", monitoring, failClosed: false,
+            activeRuns: activeRunViews, attention, blockers, pendingWakeup
+        });
+    }
     if (blockedIntegration || failedWork || hasLeaderMismatch) {
         return render({
             task,
@@ -295,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/scheduler/wakeReason.js

@@ -37,7 +37,13 @@ const IMMEDIATE_KINDS = new Set([
     "activation-failed",
     "task-reopened",
     "leader-turn-failed",
-    "role-turn-failed"
+    "role-turn-failed",
+    // A claimed interrupt-then handoff for a no-Run Leader turn: the operator/Leader
+    // explicitly redirected, so the release wake bypasses the aggregation debounce.
+    // It is still held by the leader-mailbox busy-gate until the interrupted native
+    // Turn reaches its proven terminal (decision-3 §4), so "immediate" only removes
+    // the extra 60s aggregation delay once that terminal actually opens the gate.
+    "interrupt-then"
 ]);
 export function wakeReason(kind, ref) {
     if (ref === undefined)

package/dist/scheduler/wakeupQueue.js

@@ -1,5 +1,7 @@
 import { mergePendingWakeup } from "./pendingWakeup.js";
 export function queueLeaderWakeup(store, taskId, reason, now) {
+    if (store.getTask?.(taskId)?.status === "archived")
+        return null;
     if (store.enqueueLeaderWakeup !== undefined) {
         return store.enqueueLeaderWakeup(taskId, reason, now);
     }