@zq-silk/yui 0.8.2 → 0.8.6

package/dist/run/agentRun.js

@@ -67,11 +67,11 @@ export function withAgentRunContextSnapshot(run, snapshot, deltaRefIds = []) {
     if (run.status !== "active" || run.pushedAt !== undefined || run.deliveredAt !== undefined) {
         throw new Error(`Cannot bind Context Snapshot after Run delivery: ${run.id}.`);
     }
-    const assignment = validateRunAssignment(Object.freeze({
+    const assignment = createRunAssignment({
         ...run.assignment,
         contextSnapshotRef: snapshot,
         deltaRefIds
-    }));
+    });
     return validateAgentRun(Object.freeze({
         ...run,
         assignment,

package/dist/run/runIdentity.js

@@ -1,82 +1,22 @@
 import { MAX_SESSION_TITLE_LENGTH } from "../runtime/sessionTitle.js";
-const TITLED_RUN_SEPARATOR = " · Run ";
-/** Adds the causal token consumed by the native Turn-complete Hook. */
-export function markYuiRunInput(input, runId, title) {
+/**
+ * Prefixes managed launch input with its session title. The bootstrap body
+ * exposes the exact current Run identity to the Agent, while structured
+ * delivery metadata and control hooks retain the delivery fence.
+ */
+export function prefixYuiTitleInput(input, title) {
     const text = input.replace(/\r/g, "").trim();
-    return managedRunInput(text, runId, title);
-}
-/** Replaces the causal token on an input already owned by a persisted Yui Run. */
-export function retagYuiRunInput(input, runId, title) {
-    const lines = input.replace(/\r/g, "").split("\n");
-    if (lines.length < 3
-        || lines[1] !== ""
-        || runIdFromHeader(lines[0]) === undefined) {
-        throw new Error("Managed Run input header is required.");
-    }
-    return managedRunInput(lines.slice(2).join("\n").trim(), runId, title);
-}
-function managedRunInput(text, runId, title) {
-    const id = requireRunId(runId);
     if (text.length === 0)
-        throw new Error("Run input is required.");
-    return `${requireRunTitle(title)}${TITLED_RUN_SEPARATOR}${id}\n\n${text}`;
-}
-/** Reads the last managed Yui header from Codex's structured input-messages. */
-export function yuiRunIdFromInputMessages(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    let found;
-    for (const entry of value) {
-        if (typeof entry !== "string")
-            continue;
-        const lines = entry.replace(/\r/g, "").split("\n");
-        if (lines.length < 3 || lines[1] !== "")
-            continue;
-        const runId = runIdFromHeader(lines[0]);
-        if (runId !== undefined)
-            found = runId;
-    }
-    return found;
-}
-/** Removes only a valid managed Run header, preserving user-authored lookalikes. */
-export function yuiRunBodyFromInputMessage(value) {
-    const lines = value.replace(/\r/g, "").trim().split("\n");
-    return lines.length >= 3
-        && lines[1] === ""
-        && runIdFromHeader(lines[0]) !== undefined
-        ? lines.slice(2).join("\n")
-        : lines.join("\n");
-}
-function runIdFromHeader(line) {
-    const separator = line.lastIndexOf(TITLED_RUN_SEPARATOR);
-    if (separator > 0) {
-        try {
-            requireRunTitle(line.slice(0, separator));
-            return requireRunId(line.slice(separator + TITLED_RUN_SEPARATOR.length));
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return undefined;
+        throw new Error("Managed input body is required.");
+    return `${requireRunTitle(title)}\n\n${text}`;
 }
 function requireRunTitle(value) {
     const title = value.trim();
     if (title.length === 0
         || title.length > MAX_SESSION_TITLE_LENGTH
-        || !title.startsWith("Yui · ")
-        || /[\r\n\0]/u.test(title)) {
+        || /[\r\n\0]/u.test(title)
+        || !title.startsWith("Yui ")) {
         throw new Error("Run title is invalid.");
     }
     return title;
 }
-function requireRunId(value) {
-    const id = value.trim();
-    if (id.length === 0
-        || id.length > 1_024
-        || ["__proto__", "prototype", "constructor", ".", ".."].includes(id)
-        || /[\/\\\0\s]/.test(id)) {
-        throw new Error("Run id is invalid.");
-    }
-    return id;
-}

package/dist/runtime/agentHost.js

@@ -13,9 +13,8 @@ import { ProviderDeliveryUnknownError, ProviderConversationMissingError, Provide
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
 import { readRuntimeStopReceipt, removeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
+import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
 export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v2";
-const HOST_CONTROL_TIMEOUT_MS = 35_000;
-const HOST_READY_TIMEOUT_MS = 35_000;
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
 export function serializeAgentHostLaunchControl(control) {
     return JSON.stringify(validateControl(control));
@@ -599,7 +598,7 @@ export async function inspectAgentHost(input) {
     return result.snapshot;
 }
 export async function waitForAgentHostLaunchAck(input) {
-    const deadline = Date.now() + (input.timeoutMs ?? HOST_READY_TIMEOUT_MS);
+    const deadline = Date.now() + (input.timeoutMs ?? AGENT_HOST_READY_TIMEOUT_MS);
     let lastError;
     while (Date.now() < deadline) {
         try {
@@ -634,7 +633,7 @@ async function sendAgentHostControl(input) {
         const timer = setTimeout(() => {
             client.destroy();
             reject(new Error("Agent Host control request timed out."));
-        }, HOST_CONTROL_TIMEOUT_MS);
+        }, AGENT_HOST_CONTROL_TIMEOUT_MS);
         let settled = false;
         const settle = (callback, value) => {
             if (settled)

package/dist/runtime/codexAppServerRuntime.js

@@ -39,6 +39,12 @@ export class CodexAppServerRuntime {
         const result = await this.transport.request("thread/resume", { threadId: id });
         return parseThreadSnapshot(result, id, true);
     }
+    async setConversationName(input) {
+        await this.transport.request("thread/name/set", {
+            threadId: text(input.conversationId, "Codex thread id"),
+            name: text(input.name, "Codex thread name")
+        });
+    }
     async readConversation(conversationId) {
         const id = text(conversationId, "Codex thread id");
         const result = await this.transport.request("thread/read", {

package/dist/runtime/firstProgressStopLoss.js

@@ -0,0 +1,52 @@
+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.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/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/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/wakeReason.js

@@ -22,6 +22,8 @@ export const WAKE_REASON_KINDS = Object.freeze([
     "leader-run-failed",
     "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";
@@ -720,10 +721,16 @@ 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: this.#sortById(this.#listPayload("events", "task_id = ? AND type = ?", [taskId, TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT]), (event) => event.id),
             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: this.listEvents(taskId).filter((event) => event.type === "review.completed")
+            }
         };
     }
     readCompletionReadinessFacts(taskId) {
@@ -732,6 +739,8 @@ export class SqliteTaskStore {
             return null;
         return {
             ...base,
+            agentRuns: this.listAgentRuns(taskId),
+            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),
             integrationQueueEntries: this.#sortById(this.#listPayload("integration_queue", "task_id = ?", [taskId]), (entry) => entry.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";
@@ -420,11 +421,19 @@ export class FileTaskStore {
             changeSets: values(aggregate.changeSets, "id"),
             integrations: values(aggregate.integrationAttempts, "id"),
             reviewRounds: values(aggregate.reviewRounds, "id"),
+            taskFinalReviewContractEvents: values(aggregate.events, "id")
+                .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: values(aggregate.events, "id").filter((event) => (event.type === "review.completed"))
+            }
         };
     }
     readCompletionReadinessFacts(taskId) {
@@ -442,6 +451,8 @@ export class FileTaskStore {
         }
         return {
             ...base,
+            agentRuns: this.listAgentRuns(taskId),
+            roleSessionSets: this.listRoleSessionSets(taskId),
             managedWorkspaces: values(aggregate.managedWorkspaces, (workspace) => managedWorkspaceKey(workspace.owner)),
             durableJobs: values(aggregate.durableJobs, "id"),
             integrationQueueEntries: values(aggregate.integrationQueue, "id"),