@zq-silk/yui 0.8.3 → 0.8.7

package/dist/runtime/firstProgressStopLoss.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+/** One automatic same-Session continuation is allowed before first progress. */
+export function boundProviderRetryBeforeFirstProgress(policy, projection) {
+    return projection.firstProgressAt === undefined
+        ? Object.freeze({ delaysMs: policy.delaysMs.slice(0, 1), maxWindowMs: policy.maxWindowMs })
+        : policy;
+}
+export function projectFirstProgressStopLoss(input) {
+    const sessions = input.sessions === null
+        ? []
+        : [...(input.sessions.history ?? []), ...Object.values(input.sessions.sessions)]
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    const unique = [...new Map(sessions.map((session) => [
+            `${session.nativeSessionId}\0${session.launchId ?? ""}`,
+            session
+        ])).values()];
+    const firstGenerationAt = unique[0]?.createdAt;
+    const progress = firstGenerationAt === undefined
+        ? []
+        : [
+            ...input.events
+                .filter((event) => typeof event.payload.leaderRunId === "string")
+                .map((event) => ({ at: event.createdAt, ref: `event:${event.id}` })),
+            ...input.workItems
+                .filter((item) => item.status !== "retired")
+                .map((item) => ({ at: item.createdAt, ref: `work-item:${item.id}` })),
+            ...input.reviewRounds.map((round) => ({ at: round.createdAt, ref: `review-round:${round.id}` })),
+            ...input.integrations.map((attempt) => ({ at: attempt.createdAt, ref: `integration-attempt:${attempt.id}` }))
+        ]
+            .filter(({ at }) => at >= firstGenerationAt)
+            .sort((left, right) => left.at.localeCompare(right.at) || left.ref.localeCompare(right.ref));
+    const firstProgressAt = progress[0]?.at;
+    const generationsBeforeFirstProgress = unique.filter((session) => (firstProgressAt === undefined || session.createdAt <= firstProgressAt)).length;
+    const generationRefs = unique.map((session) => (`${session.nativeSessionId}@${session.launchId ?? session.createdAt}`));
+    const progressRefs = progress.map(({ ref }) => ref);
+    const exhausted = firstProgressAt === undefined && generationsBeforeFirstProgress >= 2;
+    const fingerprint = createHash("sha256")
+        .update(JSON.stringify({ generationRefs, progressRefs }))
+        .digest("hex");
+    return Object.freeze({
+        exhausted,
+        generationsBeforeFirstProgress,
+        ...(firstGenerationAt === undefined ? {} : { firstGenerationAt }),
+        ...(firstProgressAt === undefined ? {} : { firstProgressAt }),
+        generationRefs,
+        progressRefs,
+        fingerprint,
+        reason: exhausted
+            ? `${generationsBeforeFirstProgress} fresh Leader generations produced no first durable progress; stop before creating another generation and hand off to the Operator.`
+            : firstProgressAt !== undefined
+                ? `First durable progress was recorded at ${firstProgressAt}.`
+                : `Fewer than two Leader generations exist before first durable progress.`
+    });
+}

package/dist/runtime/launchBroker.js

@@ -1,8 +1,8 @@
 import { randomBytes } from "node:crypto";
 import { resolve } from "node:path";
 import { validateProviderAuthorityFence } from "./providerAuthorityFence.js";
+import { AGENT_HOST_LAUNCH_TICKET_TTL_MS } from "./runtimeDeadlines.js";
 const brokers = new Map();
-const TICKET_TTL_MS = 60_000;
 /** One Controller-process broker per canonical Home. Payloads never hit disk or tmux. */
 export function launchBrokerForHome(home) {
     const key = resolve(home);
@@ -34,7 +34,7 @@ export class LaunchBroker {
             throw new Error("Launch ticket is invalid or already consumed.");
         }
         this.#reservations.delete(launchId);
-        if (Date.now() - reservation.createdAt > TICKET_TTL_MS) {
+        if (Date.now() - reservation.createdAt > AGENT_HOST_LAUNCH_TICKET_TTL_MS) {
             throw new Error("Launch ticket expired before redemption.");
         }
         return reservation.payload;
@@ -99,6 +99,14 @@ function validateProviderControl(control) {
     }
     if (control.nativeSessionId !== undefined)
         text(control.nativeSessionId, "nativeSessionId");
+    if (control.sessionTitle !== undefined) {
+        const title = control.sessionTitle.trim();
+        if (title.length === 0
+            || title.length > 1_024
+            || /[\r\n\0]/u.test(title)) {
+            throw new Error("Agent Host Provider session title is invalid.");
+        }
+    }
     validateProviderAuthorityFence(control.authority);
     if (control.initialTurn !== undefined) {
         text(control.initialTurn.attemptId, "Provider input attemptId");

package/dist/runtime/runtimeDeadlines.js

@@ -0,0 +1,14 @@
+/**
+ * Managed-runtime deadline hierarchy. Each outer boundary must outlive the
+ * inner operation it awaits, with enough margin to persist observations and
+ * return the enclosing acknowledgement.
+ */
+export const PROVIDER_ACCEPT_TIMEOUT_MS = 60_000;
+const RUNTIME_ENVELOPE_MARGIN_MS = 15_000;
+export const AGENT_HOST_CONTROL_TIMEOUT_MS = PROVIDER_ACCEPT_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
+export const AGENT_HOST_READY_TIMEOUT_MS = AGENT_HOST_CONTROL_TIMEOUT_MS;
+export const AGENT_HOST_LAUNCH_TICKET_TTL_MS = AGENT_HOST_READY_TIMEOUT_MS;
+export const LIFECYCLE_REQUEST_TIMEOUT_MS = AGENT_HOST_CONTROL_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
+export const CONTROLLER_SHUTDOWN_TIMEOUT_MS = LIFECYCLE_REQUEST_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
+export const RELEASE_HANDOVER_OLD_OWNER_GRACE_MS = CONTROLLER_SHUTDOWN_TIMEOUT_MS + RUNTIME_ENVELOPE_MARGIN_MS;
+export const RELEASE_HANDOVER_PROMOTION_TIMEOUT_MS = RELEASE_HANDOVER_OLD_OWNER_GRACE_MS + RUNTIME_ENVELOPE_MARGIN_MS;

package/dist/runtime/sessionTitle.js

@@ -1,19 +1,31 @@
 const TITLE_SEPARATOR = " · ";
-export const MAX_SESSION_TITLE_LENGTH = 160;
+export const MAX_SESSION_TITLE_LENGTH = 80;
+const TASK_TITLE_MAX_LENGTH = 20;
 export function taskRoleSessionTitle(task, roleName) {
-    return sessionTitle(["Yui", task.id, roleLabel(roleName), task.title]);
-}
-function sessionTitle(segments) {
-    const normalized = segments.map(normalizeSegment);
-    const full = normalized.join(TITLE_SEPARATOR);
+    const prefix = `Yui ${roleLabel(roleName)} ${normalizeSegment(task.id)}`;
+    const title = displayTitle(normalizeSegment(task.title), TASK_TITLE_MAX_LENGTH);
+    const full = `${prefix}${TITLE_SEPARATOR}${title}`;
     if (full.length <= MAX_SESSION_TITLE_LENGTH)
         return full;
-    const head = normalized.slice(0, -1).join(TITLE_SEPARATOR);
-    const tail = normalized.at(-1);
-    const tailLength = MAX_SESSION_TITLE_LENGTH - head.length - TITLE_SEPARATOR.length - 1;
-    if (tailLength < 1)
-        return truncate(full, MAX_SESSION_TITLE_LENGTH);
-    return `${head}${TITLE_SEPARATOR}${truncate(tail, tailLength)}…`;
+    if (prefix.length + TITLE_SEPARATOR.length + 1 > MAX_SESSION_TITLE_LENGTH) {
+        return truncate(prefix, MAX_SESSION_TITLE_LENGTH);
+    }
+    const titleLength = MAX_SESSION_TITLE_LENGTH - prefix.length - TITLE_SEPARATOR.length - 1;
+    return `${prefix}${TITLE_SEPARATOR}${displayTitle(title, Math.max(titleLength, 1))}`;
+}
+export function resolveTaskRoleSessionTitle(existingTitle, task, roleName) {
+    if (existingTitle !== undefined
+        && existingTitle.length > 0
+        && existingTitle.length <= MAX_SESSION_TITLE_LENGTH
+        && !/[\r\n\0]/u.test(existingTitle)) {
+        return existingTitle;
+    }
+    return taskRoleSessionTitle(task, roleName);
+}
+function displayTitle(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${truncate(value, maxLength - 1)}…`;
 }
 function normalizeSegment(value) {
     if (typeof value !== "string" || value.includes("\0")) {

package/dist/runtime/structuredProviderHost.js

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { CodexAppServerRequestError, CodexAppServerRuntime, codexAppServerErrorIsMissing } from "./codexAppServerRuntime.js";
+import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { YUI_VERSION } from "../version.js";
 const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
-const PROVIDER_ACCEPT_TIMEOUT_MS = 30_000;
 export class ProviderDeliveryUnknownError extends Error {
     attemptId;
     name = "ProviderDeliveryUnknownError";
@@ -219,6 +219,12 @@ class CodexStructuredProviderSession {
                 throw error;
             }
         }
+        if (control.sessionTitle !== undefined) {
+            await runtime.setConversationName({
+                conversationId,
+                name: control.sessionTitle
+            });
+        }
         const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime);
         session.#activeTurnId = resumedActiveTurnId;
         channel.onMessage((message) => {

package/dist/runtime/tmuxAdapters.js

@@ -216,6 +216,9 @@ export class TmuxSessionHost {
             agentId: request.agentId,
             adapterId: request.adapterId,
             effective: request.effective,
+            ...(planned.launch.env.YUI_SESSION_TITLE === undefined
+                ? {}
+                : { sessionTitle: planned.launch.env.YUI_SESSION_TITLE }),
             ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
             ...(planned.initialTurnRunId === undefined
                 ? {}
@@ -223,9 +226,13 @@ export class TmuxSessionHost {
         });
         const yuiHome = planned.launch.env.YUI_HOME;
         const childLifecycle = planned.launch.childLifecycle;
-        // Interactive/global Roles may still be native TUIs. A managed Task Run
-        // has no terminal-write fallback and must expose the Agent Host contract.
-        if (yuiHome === undefined || childLifecycle === undefined) {
+        // Interactive/global Roles remain native TUIs even when their Driver
+        // advertises a persistent child lifecycle. Provider control metadata is
+        // the discriminator for the structured Agent Host path. A managed Task
+        // Run has no terminal-write fallback and must expose that contract.
+        if (yuiHome === undefined
+            || childLifecycle === undefined
+            || planned.launch.providerControl === undefined) {
             if (request.owner.scope === "task" && request.runId !== undefined) {
                 throw new Error("Managed Task Run is missing its structured Agent Host contract.");
             }

package/dist/scheduler/actionability.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { isDurableJobTerminal } from "../job/durableJob.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
  * Canonical SHA-256 digest over the normalized actionable facts. Pure and
  * deterministic: the same facts always produce the same digest regardless of
@@ -46,7 +47,8 @@ export function collectTaskActionability(store, taskId) {
         throw new Error(`Task not found for actionability projection: ${taskId}.`);
     }
     const facts = [];
-    for (const run of store.listAgentRuns(taskId).filter((candidate) => candidate.status === "active")) {
+    const events = store.listEvents?.(taskId) ?? [];
+    for (const run of operationalTaskRecords(store.listAgentRuns(taskId), events, "agent-run").filter((candidate) => candidate.status === "active")) {
         facts.push({
             key: `active-run:${run.id}`,
             value: [
@@ -95,7 +97,7 @@ export function collectTaskActionability(store, taskId) {
             value: `${request.status}|${request.updatedAt}`
         });
     }
-    for (const message of store.listMessages?.(taskId) ?? []) {
+    for (const message of operationalTaskRecords(store.listMessages?.(taskId) ?? [], events, "message")) {
         if (message.wakePolicy !== "leader")
             continue;
         facts.push({

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,8 +1,8 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { markYuiRunInput } from "../run/runIdentity.js";
-import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { prefixYuiTitleInput } from "../run/runIdentity.js";
+import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
@@ -298,24 +298,25 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 }
                 providerSubmissionBegun = true;
                 deliveryAttempted = true;
-                const outcome = await delivery.sendOnce({
-                    delivery: ready,
-                    receiptId,
-                    text: run.controlRequest?.state === "dispatching"
-                        ? serializeWorkflowOutcomeRequestEnvelope({
+                const launchText = run.controlRequest?.state === "dispatching"
+                    ? serializeWorkflowOutcomeRequestEnvelope({
+                        taskId: task.id,
+                        runId: run.id,
+                        roleName: role.name,
+                        request: run.controlRequest
+                    })
+                    : run.providerRetry?.state === "dispatching"
+                        ? serializeProviderRetryEnvelope({
                             taskId: task.id,
                             runId: run.id,
                             roleName: role.name,
-                            request: run.controlRequest
+                            retry: run.providerRetry
                         })
-                        : run.providerRetry?.state === "dispatching"
-                            ? serializeProviderRetryEnvelope({
-                                taskId: task.id,
-                                runId: run.id,
-                                roleName: role.name,
-                                retry: run.providerRetry
-                            })
-                            : serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
+                        : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+                const outcome = await delivery.sendOnce({
+                    delivery: ready,
+                    receiptId,
+                    text: prefixYuiTitleInput(launchText, resolveTaskRoleSessionTitle(session.title, task, role.name))
                 });
                 if (outcome === "busy" || outcome === "unavailable") {
                     store.resolveRoleRunProviderSubmission?.({
@@ -791,7 +792,7 @@ function continuationInput(task, role, run, attemptId, batch, resultSummaries) {
     const references = batch.refs.map((ref) => ("taskId" in ref
         ? `${ref.type}:${ref.taskId}/${ref.id}`
         : `${ref.type}:${ref.id}`));
-    return markYuiRunInput([
+    return [
         `Yui Task Event Batch: ${attemptId}.`,
         "New durable task events are available for the current Yui Run.",
         "Read the referenced shared context through the Yui CLI, incorporate it, and decide whether to continue work or wait for more results.",
@@ -805,7 +806,7 @@ function continuationInput(task, role, run, attemptId, batch, resultSummaries) {
                 "Native child results (bounded excerpts; read the referenced event for the full content):",
                 ...resultSummaries
             ])
-    ].join("\n"), run.id, taskRoleSessionTitle(task, role.name));
+    ].join("\n");
 }
 /**
  * Issue 13: the parent prompt only ever sees a bounded excerpt of a native
@@ -911,6 +912,7 @@ function preflightSession(role, effective, existing, mode, preflight) {
             adapterId: preflight.adapterId,
             nativeSessionId: preflight.nativeSessionId,
             launchId: preflight.launchId,
+            ...(preflight.sessionTitle === undefined ? {} : { title: preflight.sessionTitle }),
             status: "ready",
             effective: preflight.effective
         };

package/dist/scheduler/activeTaskProgress.js

@@ -3,6 +3,7 @@ import { queueLeaderWakeup } from "./wakeupQueue.js";
 import { wakeReason } from "./wakeReason.js";
 import { projectTaskExecution } from "./taskExecutionProjection.js";
 import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake } from "./actionability.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
  * Repairs an active Task that has no durable owner capable of advancing it.
  * This is a low-frequency safety net; normal transitions enqueue their own
@@ -96,7 +97,7 @@ function admitOrphanWake(store, taskId) {
  * so the admission check never suppresses while a Leader is still running.
  */
 function findLastLeaderRun(store, taskId) {
-    const runs = store.listAgentRuns?.(taskId) ?? [];
+    const runs = operationalTaskRecords(store.listAgentRuns?.(taskId) ?? [], store.listEvents?.(taskId) ?? [], "agent-run");
     let latest = null;
     for (const run of runs) {
         if (run.roleName !== "leader")

package/dist/scheduler/leaderWakeupProcessor.js

@@ -1,12 +1,15 @@
 import { createAgentRun } from "../run/agentRun.js";
 import { createRunAssignment, serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
+import { prefixYuiTitleInput } from "../run/runIdentity.js";
+import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { createLeaderRecoveryNotification } from "./operatorNotification.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
+import { projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
@@ -121,7 +124,34 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 && existingSession.status !== "stopped" && existingSession.status !== "broken") {
                 throw new Error(`Leader Session is incompatible with desired effective launch: ${task.id}/${role.name}.`);
             }
-            const mode = hasNativeSession(existingSession) && compatibleSession ? "resume" : "new";
+            const resumableSession = hasNativeSession(existingSession)
+                && existingSession.status !== "stopped"
+                && existingSession.status !== "broken";
+            const mode = resumableSession && compatibleSession ? "resume" : "new";
+            if (mode === "new" && store.getTaskRoleSessionSet !== undefined) {
+                const stopLoss = projectFirstProgressStopLoss({
+                    sessions: store.getTaskRoleSessionSet(task.id, role.name),
+                    events: store.listEvents?.(task.id) ?? [],
+                    workItems: store.listWorkItems?.(task.id) ?? [],
+                    reviewRounds: store.listReviewRounds?.(task.id) ?? [],
+                    integrations: store.listIntegrationAttempts?.(task.id) ?? []
+                });
+                if (stopLoss.exhausted && store.saveLeaderFirstProgressStopLoss !== undefined) {
+                    const saved = store.saveLeaderFirstProgressStopLoss({
+                        taskId: task.id,
+                        roleName: role.name,
+                        expectedFingerprint: stopLoss.fingerprint,
+                        now
+                    });
+                    results.push({
+                        taskId: task.id,
+                        status: "skipped",
+                        reason: saved === "recorded" ? "recovery-blocked" : "state-changed",
+                        error: saved === "recorded" ? stopLoss.reason : undefined
+                    });
+                    continue;
+                }
+            }
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
             const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
@@ -328,7 +358,7 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const outcome = await delivery.sendOnce({
                 delivery: ready,
                 receiptId,
-                text: serializeRunBootstrapEnvelope(run.bootstrapEnvelope)
+                text: prefixYuiTitleInput(serializeRunBootstrapEnvelope(run.bootstrapEnvelope), resolveTaskRoleSessionTitle(effectiveSession.title, task, role.name))
             });
             if (outcome === "busy" || outcome === "unavailable") {
                 store.resolveRoleRunProviderSubmission?.({
@@ -559,6 +589,7 @@ function preflightSession(role, effective, existing, mode, preflight) {
             adapterId: preflight.adapterId,
             nativeSessionId: preflight.nativeSessionId,
             launchId: preflight.launchId,
+            ...(preflight.sessionTitle === undefined ? {} : { title: preflight.sessionTitle }),
             status: "ready",
             effective: preflight.effective
         };

package/dist/scheduler/taskExecutionProjection.js

@@ -1,3 +1,4 @@
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { mailboxBatches } from "../coordination/workMailbox.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
@@ -12,7 +13,8 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride) {
     if (task === null)
         return null;
     const roles = store.listRoles?.(taskId) ?? [];
-    const runs = store.listAgentRuns?.(taskId) ?? [];
+    const events = store.listEvents?.(taskId) ?? [];
+    const runs = operationalTaskRecords(store.listAgentRuns?.(taskId) ?? [], events, "agent-run");
     const leaderMailbox = store.getWorkMailbox?.({
         kind: "role",
         taskId,
@@ -42,7 +44,7 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride) {
         ...(store.listIntegrationAttempts === undefined
             ? {}
             : { integrations: store.listIntegrationAttempts(taskId) }),
-        ...(store.listEvents === undefined ? {} : { events: store.listEvents(taskId) }),
+        ...(store.listEvents === undefined ? {} : { events }),
         ...(store.getTaskBrief === undefined ? {} : { brief: store.getTaskBrief(taskId) }),
         pendingWakeup: store.getPendingWakeup?.(taskId) ?? null,
         leaderMailbox,
@@ -60,7 +62,11 @@ export function buildTaskExecutionProjection(store, taskId, taskOverride) {
 export function projectTaskExecutionFromFacts(facts) {
     const executionGroups = facts.executionGroups
         ?? collectExecutionGroups(facts.workItems ?? [], facts.reviewRounds ?? []);
-    return projectTaskExecution({ ...facts, executionGroups });
+    return projectTaskExecution({
+        ...facts,
+        runs: operationalTaskRecords(facts.runs, facts.events ?? [], "agent-run"),
+        executionGroups
+    });
 }
 /** Alias kept intentionally small for scheduler callers and external read models. */
 export const deriveTaskExecutionProjection = projectTaskExecution;
@@ -471,7 +477,10 @@ function collectBlockers(workItems, reviewRounds, integrations, openInputs, task
                 summary: item.outcome ?? `WorkItem ${item.id} is ${item.status}.`
             });
         }
-        if (item.status === "pending" && (item.dependsOn ?? []).some((id) => byId.get(id)?.status !== "completed")) {
+        if (item.status === "pending" && (item.dependsOn ?? []).some((id) => {
+            const status = byId.get(id)?.status;
+            return status !== "completed" && status !== "retired";
+        })) {
             blockers.push({
                 kind: "work",
                 id: item.id,

package/dist/scheduler/wakeReason.js

@@ -23,6 +23,7 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "role-run-failed",
     "job-finished",
     "published-tree-authorized",
+    "review-contract-rebound",
     "force-wake"
 ]);
 const IMMEDIATE_KINDS = new Set([

package/dist/storage/sqliteStore.js

@@ -40,6 +40,7 @@ import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
 import { consumePendingBatch, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
+import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT } from "../review/taskFinalReviewContractEvent.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { validateReviewFinding } from "../review/reviewFinding.js";
 import { reviewFindingLedgerMode } from "../review/reviewFindingLedger.js";
@@ -47,6 +48,7 @@ import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeId
 import { validateIntegrationQueueEntry } from "../integration/integrationQueueEntry.js";
 import { validDurableJobTransition, validateDurableJob } from "../job/durableJob.js";
 import { validateTaskWake } from "../scheduler/taskWake.js";
+import { operationalTaskRecords, TASK_RECORD_RETIRED_EVENT } from "../task/taskRecordRetirement.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { assertHomeWritable } from "./upgradeFence.js";
@@ -708,7 +710,13 @@ export class SqliteTaskStore {
             return null;
         // One indexed query (idx_agent_runs_role_status) covers both the active
         // Runs the projection waits on and the Leader Runs the budget consumes.
-        const runs = this.#sortById(this.#listPayload("agent_runs", "task_id = ? AND (status = 'active' OR role_name = 'leader')", [taskId]), (run) => run.id);
+        const events = this.#sortById(this.#listPayload("events", "task_id = ? AND type IN (?, ?, ?)", [
+            taskId,
+            TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT,
+            TASK_RECORD_RETIRED_EVENT,
+            "review.completed"
+        ]), (event) => event.id);
+        const runs = operationalTaskRecords(this.#sortById(this.#listPayload("agent_runs", "task_id = ? AND (status = 'active' OR role_name = 'leader')", [taskId]), (run) => run.id), events, "agent-run");
         return {
             task: {
                 id: task.id,
@@ -720,10 +728,17 @@ export class SqliteTaskStore {
             changeSets: this.#sortById(this.#listPayload("change_sets", "task_id = ?", [taskId]), (changeSet) => changeSet.id),
             integrations: this.#sortById(this.#listPayload("integration_attempts", "task_id = ?", [taskId]), (attempt) => attempt.id),
             reviewRounds: this.#sortById(this.#listPayload("review_rounds", "task_id = ?", [taskId]), (round) => round.id),
+            taskFinalReviewContractEvents: events
+                .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),
             reviewConfig: this.getReviewConfig(),
             openInputRequests: this.#sortById(this.#listPayload("input_requests", "task_id = ? AND status = 'open'", [taskId]), (request) => request.id),
             activeRuns: runs.filter((run) => run.status === "active"),
-            leaderRuns: runs.filter((run) => run.roleName === "leader")
+            leaderRuns: runs.filter((run) => run.roleName === "leader"),
+            reviewOutcomeEvidence: {
+                agentRuns: this.#sortById(this.#listPayload("agent_runs", "task_id = ?", [taskId]).filter((run) => run.purpose === "review"), (run) => run.id),
+                reviewFindings: this.listReviewFindings(taskId),
+                events: events.filter((event) => event.type === "review.completed")
+            }
         };
     }
     readCompletionReadinessFacts(taskId) {
@@ -732,7 +747,7 @@ export class SqliteTaskStore {
             return null;
         return {
             ...base,
-            agentRuns: this.listAgentRuns(taskId),
+            agentRuns: operationalTaskRecords(this.listAgentRuns(taskId), this.listEvents(taskId), "agent-run"),
             roleSessionSets: this.listRoleSessionSets(taskId),
             managedWorkspaces: this.#sortById(this.#listPayload("managed_workspaces", "task_id = ?", [taskId]), (workspace) => managedWorkspaceKey(workspace.owner)),
             durableJobs: this.#sortById(this.#listPayload("durable_jobs", "task_id = ?", [taskId]), (job) => job.id),

package/dist/storage/taskStore.js

@@ -10,6 +10,7 @@ import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeout
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
+import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT } from "../review/taskFinalReviewContractEvent.js";
 import { validateInputRequest } from "../input/inputRequest.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
 import { validateTaskMessage } from "../message/message.js";
@@ -33,6 +34,7 @@ import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../scheduler/leaderFailur
 import { CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION } from "../scheduler/operatorNotification.js";
 import { CURRENT_TASK_WAKE_SCHEMA_VERSION, validateTaskWake } from "../scheduler/taskWake.js";
 import { validateTask } from "../task/task.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_RECORD_ID_PREFIXES, validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { workItemExecutionGroupById, validateWorkItem } from "../workItem/workItem.js";
 import { isExecutionGroupTransition, validateExecutionGroup } from "../execution/executionGroup.js";
@@ -408,7 +410,8 @@ export class FileTaskStore {
         const aggregate = this.#state().tasks[taskId];
         if (aggregate === undefined)
             return null;
-        const agentRuns = values(aggregate.agentRuns, "id");
+        const events = values(aggregate.events, "id");
+        const agentRuns = operationalTaskRecords(values(aggregate.agentRuns, "id"), events, "agent-run");
         return {
             task: {
                 id: aggregate.task.id,
@@ -420,11 +423,19 @@ export class FileTaskStore {
             changeSets: values(aggregate.changeSets, "id"),
             integrations: values(aggregate.integrationAttempts, "id"),
             reviewRounds: values(aggregate.reviewRounds, "id"),
+            taskFinalReviewContractEvents: events
+                .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),
             reviewConfig: this.getReviewConfig(),
             openInputRequests: values(aggregate.inputRequests, "id")
                 .filter((request) => request.status === "open"),
             activeRuns: agentRuns.filter((run) => run.status === "active"),
-            leaderRuns: agentRuns.filter((run) => run.roleName === "leader")
+            leaderRuns: agentRuns.filter((run) => run.roleName === "leader"),
+            reviewOutcomeEvidence: {
+                agentRuns: agentRuns.filter((run) => run.purpose === "review"),
+                // The rollback file backend has no finding-ledger records.
+                reviewFindings: [],
+                events: events.filter((event) => (event.type === "review.completed"))
+            }
         };
     }
     readCompletionReadinessFacts(taskId) {
@@ -442,7 +453,7 @@ export class FileTaskStore {
         }
         return {
             ...base,
-            agentRuns: this.listAgentRuns(taskId),
+            agentRuns: operationalTaskRecords(this.listAgentRuns(taskId), values(aggregate.events, "id"), "agent-run"),
             roleSessionSets: this.listRoleSessionSets(taskId),
             managedWorkspaces: values(aggregate.managedWorkspaces, (workspace) => managedWorkspaceKey(workspace.owner)),
             durableJobs: values(aggregate.durableJobs, "id"),