@zq-silk/yui 0.8.3 → 0.8.6

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleProviderRuntimeForCleanup, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
 import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
+import { boundProviderRetryBeforeFirstProgress, projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
@@ -674,6 +675,9 @@ export class FileSchedulerStoreAdapter {
             : sessions?.sessions[agentId];
         return session === undefined ? null : mapSession(session);
     }
+    getTaskRoleSessionSet(taskId, roleName) {
+        return this.store.getTaskRoleSessionSet(taskId, roleName);
+    }
     listEvents(taskId) {
         return this.#taskReadProjection(taskId).events;
     }
@@ -1222,7 +1226,14 @@ export class FileSchedulerStoreAdapter {
                     startedAt: now.toISOString()
                 }), batchId);
             }
-            markRuntimeOwnerSessionStopped(store, runtimeOwnerFromTarget(target), now);
+            const owner = runtimeOwnerFromTarget(target);
+            markRuntimeOwnerSessionStopped(store, owner, now);
+            if (owner.scope === "task") {
+                const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+                if (sessions !== null && sessions.providerBinding !== null) {
+                    store.saveTaskRoleSessionSet(clearTaskRoleProviderRuntimeForCleanup(sessions, now));
+                }
+            }
             saveRuntimeLifecycleMailbox(store, mailbox);
             return true;
         });
@@ -1288,6 +1299,40 @@ export class FileSchedulerStoreAdapter {
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
     getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
+    saveLeaderFirstProgressStopLoss(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            const role = store.getRole(input.taskId, input.roleName);
+            if (task === null || task.status !== "active" || role === null
+                || store.getLeaderFailure(input.taskId) !== null) {
+                return "state-changed";
+            }
+            const stopLoss = projectFirstProgressStopLoss({
+                sessions: store.getTaskRoleSessionSet(input.taskId, input.roleName),
+                events: store.listEvents(input.taskId),
+                workItems: store.listWorkItems(input.taskId),
+                reviewRounds: store.listReviewRounds(input.taskId),
+                integrations: store.listIntegrationAttempts(input.taskId)
+            });
+            if (!stopLoss.exhausted || stopLoss.fingerprint !== input.expectedFingerprint) {
+                return "state-changed";
+            }
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const lastSession = sessions === null
+                ? undefined
+                : [...(sessions.history ?? []), ...Object.values(sessions.sessions)]
+                    .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+                    .at(-1);
+            const message = `Leader first-progress stop-loss: ${stopLoss.reason}`;
+            store.saveRole(input.taskId, updateRoleStatus(role, "failed", input.now));
+            store.saveLeaderFailure(recordLeaderFailure(input.taskId, lastSession?.nativeSessionId ?? "(unregistered)", message, input.now, null));
+            store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, message, input.now, store.getOperatorNotification(input.taskId)));
+            enqueueWork(store, { kind: "operator" }, "leader-first-progress-stop-loss", input.now, [
+                { type: "task", id: input.taskId }
+            ]);
+            return "recorded";
+        });
+    }
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
@@ -2241,7 +2286,7 @@ export class FileSchedulerStoreAdapter {
             failedNativeTurnId: input.nativeTurnId,
             lastErrorSummary: summary,
             ...(input.retryAfterMs === undefined ? {} : { retryAfterMs: input.retryAfterMs })
-        }, now, configuredProviderRetryPolicy(store));
+        }, now, configuredProviderRetryPolicy(store, input.taskId, input.roleName));
         if (retryDecision.outcome === "exhausted") {
             this.recordProviderRetryClassified(store, input, classification.errorClass, {
                 wouldRetry: "false",
@@ -2253,7 +2298,7 @@ export class FileSchedulerStoreAdapter {
             if (run.providerRetry === undefined)
                 return null;
             const finalized = finalizeProviderRetryDeadline(store, run, retryDecision.reason === "attempts"
-                ? `Provider retry failed after all ${config.delaysMs.length} in-Session continuation attempts.`
+                ? `Provider retry failed after all ${run.providerRetry.maxRetries} in-Session continuation attempts.`
                 : retryDecision.reason === "retry-after-window"
                     ? `Provider Retry-After exceeded the bounded ${config.maxWindowMs / 1_000}-second episode window.`
                     : `Provider retry did not recover within the bounded ${config.maxWindowMs / 1_000}-second episode window.`, retryDecision.reason === "attempts" ? "attempts-exhausted" : "episode-window-exhausted", now);
@@ -3616,6 +3661,7 @@ function mapSession(session) {
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
         ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+        ...(session.title === undefined ? {} : { title: session.title }),
         status: session.status,
         effective: session.effective,
         updatedAt: session.updatedAt
@@ -3629,6 +3675,7 @@ function saveTaskSession(store, role, session, status, now, launchId) {
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
         ...(launchId === undefined ? {} : { launchId }),
+        ...(session.title === undefined ? {} : { title: session.title }),
         policy: "fixed",
         status,
         effective: session.effective
@@ -4021,7 +4068,19 @@ function compareCanonicalObservationOrder(left, right) {
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
         || left.eventId.localeCompare(right.eventId);
 }
-function configuredProviderRetryPolicy(store) {
+function configuredProviderRetryPolicy(store, taskId, roleName) {
     const config = providerRetryConfig(store.getConfig());
+    if (taskId !== undefined && roleName === "leader") {
+        const progress = projectFirstProgressStopLoss({
+            sessions: store.getTaskRoleSessionSet(taskId, roleName),
+            events: store.listEvents(taskId),
+            workItems: store.listWorkItems(taskId),
+            reviewRounds: store.listReviewRounds(taskId),
+            integrations: store.listIntegrationAttempts(taskId)
+        });
+        if (progress.firstProgressAt === undefined) {
+            return boundProviderRetryBeforeFirstProgress(config, progress);
+        }
+    }
     return { delaysMs: config.delaysMs, maxWindowMs: config.maxWindowMs };
 }

package/dist/controller/handoverCandidate.js

@@ -19,6 +19,7 @@ import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { detectRunningRelease, isOwnerLive, readActiveReleasePointer, readHandoverFence, removeCandidateDiscovery, removeHandoverFence, writeCandidateDiscovery, writeHandoverFence, writeHandoverReceipt, writeRuntimeIdentity } from "../release/runtimeRelease.js";
 import { startFileTaskControllerRuntime } from "./runtime.js";
 import { readLinuxProcessStartIdentity } from "./domainIdentity.js";
+import { RELEASE_HANDOVER_OLD_OWNER_GRACE_MS } from "../runtime/runtimeDeadlines.js";
 export const CONTROLLER_CANDIDATE_ENV = "YUI_CONTROLLER_CANDIDATE";
 export const CONTROLLER_HANDOVER_ID_ENV = "YUI_CONTROLLER_HANDOVER_ID";
 const DEFAULT_POLL_INTERVAL_MS = 100;
@@ -29,7 +30,7 @@ const DEFAULT_POLL_INTERVAL_MS = 100;
  * a second independent grace (see `DEFAULT_DUAL_OWNER_GRACE_MS` in
  * `releaseHandover.ts`, which is only an optional confirmation debounce).
  */
-export const DEFAULT_DUAL_OWNER_GRACE_MS = 30_000;
+export const DEFAULT_DUAL_OWNER_GRACE_MS = RELEASE_HANDOVER_OLD_OWNER_GRACE_MS;
 /** Reads the candidate configuration from the process environment. */
 export function handoverCandidateFromEnvironment(environment) {
     if (environment[CONTROLLER_CANDIDATE_ENV] !== "1")
@@ -85,7 +86,6 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         dualOwner: false
     }));
     advanceFence(home, fence, "candidate-ready", now().toISOString());
-    const committedAt = Date.now();
     let dualOwnerReported = false;
     for (;;) {
         const current = readHandoverFence(home);
@@ -111,7 +111,7 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         }
         if (current.phase === "committed"
             && !oldDead
-            && Date.now() - committedAt > dualOwnerGraceMs
+            && committedFenceAgeMs(current, now()) > dualOwnerGraceMs
             && !dualOwnerReported) {
             // The old Controller was told to exit but is still live. Stay read-only
             // and make the dual-owner condition visible; never write concurrently.
@@ -129,6 +129,13 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         await delay(pollIntervalMs);
     }
 }
+function committedFenceAgeMs(fence, observedAt) {
+    const committedAt = Date.parse(fence.updatedAt);
+    if (!Number.isFinite(committedAt)) {
+        throw new Error("Committed handover fence timestamp is invalid.");
+    }
+    return observedAt.getTime() - committedAt;
+}
 async function promote(home, fence, environment, now) {
     removeCandidateDiscovery(home);
     const controller = await startFileTaskControllerRuntime(home, { environment });

package/dist/controller/sessionNotify.js

@@ -1,6 +1,5 @@
 import { callController } from "../core/controllerClient.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
-import { yuiRunBodyFromInputMessage, yuiRunIdFromInputMessages } from "../run/runIdentity.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { setCodexThreadName } from "../execution/codexThreadNaming.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
@@ -50,9 +49,11 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
     const nativeSessionId = requireText(payload["thread-id"], "Codex thread-id");
     const turnId = requireText(payload["turn-id"], "Codex turn-id");
     const lastAssistantMessage = requireAssistantMessage(payload["last-assistant-message"]);
-    const runId = yuiRunIdFromInputMessages(payload["input-messages"]);
+    const runId = environment.YUI_RUN_ID === undefined
+        ? undefined
+        : requireText(environment.YUI_RUN_ID, "YUI_RUN_ID");
     const title = environment.YUI_SESSION_TITLE === undefined
-        ? sessionTitleFromInputMessages(payload["input-messages"])
+        ? undefined
         : requireText(environment.YUI_SESSION_TITLE, "YUI_SESSION_TITLE");
     const scope = environment.YUI_SESSION_SCOPE;
     if (scope !== "task" && scope !== "global") {
@@ -117,19 +118,6 @@ function requireAssistantMessage(value) {
     }
     return text;
 }
-function sessionTitleFromInputMessages(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    for (const entry of value) {
-        if (typeof entry !== "string")
-            continue;
-        const body = yuiRunBodyFromInputMessage(entry);
-        const normalized = body.trim().replaceAll(/\s+/g, " ");
-        if (normalized.length > 0)
-            return truncateSessionText(normalized);
-    }
-    return undefined;
-}
 function shouldSetThreadName(home, params) {
     if (params.scope !== "task"
         || params.title === undefined
@@ -168,12 +156,6 @@ function threadNameRequest(params, environment) {
         return null;
     }
 }
-function truncateSessionText(value) {
-    const truncated = value.slice(0, 1_024);
-    return /[\uD800-\uDBFF]$/.test(truncated)
-        ? truncated.slice(0, -1)
-        : truncated;
-}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/executor/agentAdapter.js

@@ -276,7 +276,7 @@ class ClaudeAdapter extends BaseAdapter {
         return ["--append-system-prompt-file", input.managedContextFile];
     }
     compileResume(input) {
-        const launch = super.compileNew(input);
+        const launch = this.compileNew(input);
         return { ...launch, argv: [...launch.argv, "--resume", nativeId(input.nativeSessionId)] };
     }
     compileManagedControl(input, mode, nativeSessionId) {
@@ -285,7 +285,7 @@ class ClaudeAdapter extends BaseAdapter {
         }
         const sessionId = nativeId(nativeSessionId);
         const launch = mode === "new"
-            ? super.compileNew(input)
+            ? this.compileNew(input)
             : this.compileResume({ ...input, nativeSessionId: sessionId });
         return {
             ...launch,

package/dist/executor/agentExecutor.js

@@ -173,9 +173,29 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
         // receive a fresh identity after the Role workspace changes.
         history: [...(set.history ?? []), ...Object.values(set.sessions)],
         sessions: {},
+        providerBinding: null,
         updatedAt: timestamp
     });
 }
+/**
+ * Clears the Provider transport identity after its physical runtime is proven
+ * stopped, without retiring workspace-bound Session records. Workspace
+ * retirement remains a separate, stricter transaction after every supported
+ * placeholder has been terminalized.
+ */
+export function clearTaskRoleProviderRuntimeForCleanup(set, now) {
+    validateRoleSessionSet(set);
+    if (set.inFlight !== null) {
+        throw new Error("Cannot clear a Task Role Provider runtime with unsettled Run state.");
+    }
+    if (set.providerBinding === null)
+        return set;
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: null,
+        updatedAt: requireDate(now, "Provider Runtime cleanup timestamp")
+    });
+}
 /**
  * Terminalizes only the aggregate-16 Claude placeholder shape after the
  * caller has fenced the Task store and proved that the exact Role has no live
@@ -261,16 +281,16 @@ export function roleAgentSessionResumeMode(set, agentId, desired, workspace) {
         }
         return "new";
     }
+    if (session.status === "stopped" || session.status === "broken") {
+        return "new";
+    }
     const compatible = set.owner.scope === "task"
         ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, desired, workspace)
         : effectiveLaunchSnapshotsCompatible(session.effective, desired);
     if (compatible)
         return "resume";
-    if (session.status !== "stopped" && session.status !== "broken") {
-        throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
-            + "Stop the existing native process before starting a fresh Session.");
-    }
-    return "new";
+    throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
+        + "Stop the existing native process before starting a fresh Session.");
 }
 export function bindTaskRoleRun(set, fence, preparedAt) {
     validateRoleSessionSet(set);

package/dist/executor/fileRoleLaunchPlanner.js

@@ -11,9 +11,10 @@ import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessi
 import { materializeSessionBootstrap } from "../context/sessionBootstrapManifest.js";
 import { serializeRunBootstrapEnvelope, serializeRunHostRecoveryEnvelope } from "../context/runContextContract.js";
 import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
+import { prefixYuiTitleInput } from "../run/runIdentity.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
 import { inspectCodexLaunchConfig } from "./codexConfigConflict.js";
-import { taskRoleSessionTitle } from "../runtime/sessionTitle.js";
+import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 import { activeLiveRoleAgentSession } from "./agentExecutor.js";
@@ -224,7 +225,7 @@ export class FileRoleLaunchPlanner {
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Task Role resume effective snapshot drifted: ${task.id}/${role.name}.`);
         }
-        return this.#compile(role, input, { scope: "task", taskId: task.id }, taskRoleSessionTitle(task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
+        return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
             purpose: activeRun?.purpose ?? "execution"
         });
     }
@@ -506,12 +507,13 @@ export class FileRoleLaunchPlanner {
                 ...(providerNativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: providerNativeSessionId }),
+                ...(sessionTitle === undefined ? {} : { sessionTitle }),
                 authority: providerAuthority,
                 ...(carriesInitialTurn
                     ? {
                         initialTurn: {
                             attemptId: formatAgentRunReceiptId(owner.taskId, input.runId),
-                            boundedText: managedRunLaunchEnvelope(managedRun, input.mode)
+                            boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionTitle)
                         }
                     }
                     : {})
@@ -578,6 +580,7 @@ export class FileRoleLaunchPlanner {
             },
             launch: scopedLaunch,
             session,
+            ...(sessionTitle === undefined ? {} : { sessionTitle }),
             ...(carriesInitialTurn && input.runId !== undefined
                 ? { initialTurnRunId: input.runId }
                 : {})
@@ -645,18 +648,20 @@ export class FileRoleLaunchPlanner {
         return selectEnvironment(source, names);
     }
 }
-function managedRunLaunchEnvelope(run, mode) {
-    if (run.providerRetry?.state === "dispatching") {
-        return serializeProviderRetryEnvelope({
+function managedRunLaunchEnvelope(run, mode, title) {
+    const body = run.providerRetry?.state === "dispatching"
+        ? serializeProviderRetryEnvelope({
             taskId: run.taskId,
             runId: run.id,
             roleName: run.roleName,
             retry: run.providerRetry
-        });
-    }
-    return mode === "resume" && run.pushedAt !== undefined
-        ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
-        : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+        })
+        : mode === "resume" && run.pushedAt !== undefined
+            ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
+            : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+    return title === undefined
+        ? body
+        : prefixYuiTitleInput(body, title);
 }
 export function nativeAgentWorkspace(workspace) {
     return workspace.entries.length === 1

package/dist/integration/gitIntegrationService.js

@@ -1,5 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import { lstat, mkdir, open, rm, stat } from "node:fs/promises";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
@@ -18,6 +19,8 @@ import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { recordIntegrationCheckJob, requireLeaderDecision, updateIntegrationAttempt } from "./integrationAttempt.js";
 import { createManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
+import { readRuntimeIdentity } from "../release/runtimeRelease.js";
+import { findReusableIntegrationCheckEvidence, INTEGRATION_RUNTIME_RELEASE_ENV } from "./integrationCheckEvidenceReuse.js";
 const executeFile = promisify(execFile);
 const INTEGRATION_OPERATIONAL_ENVIRONMENT_NAMES = [
     "PATH",
@@ -300,8 +303,6 @@ export class GitIntegrationService {
      */
     async #startCheckJob(attempt, workspace, path, managedWorkspace, repositoryPath, gate) {
         const runtime = this.#runtimePreparation(attempt, managedWorkspace);
-        this.runtimeIsolation.activate(runtime);
-        const environment = await integrationCheckEnvironment(this.environment, runtime);
         const head = await gitLine(["-C", path, "rev-parse", "HEAD^{commit}"]);
         const steps = gate === undefined
             ? attempt.checkCommands.map((command, index) => ({
@@ -319,6 +320,30 @@ export class GitIntegrationService {
                     timeoutMs: 30 * 60_000
                 }))
             ];
+        const releaseId = integrationRuntimeReleaseIdentity(this.home);
+        if (gate === undefined && releaseId !== null) {
+            const reusable = findReusableIntegrationCheckEvidence({
+                taskId: attempt.taskId,
+                projectId: attempt.projectId,
+                currentAttemptId: attempt.id,
+                candidateCommit: head,
+                checkCommands: attempt.checkCommands,
+                runtimeReleaseId: releaseId,
+                attempts: this.store.listIntegrationAttempts(attempt.taskId),
+                jobs: this.store.listDurableJobs(attempt.taskId),
+                logExists: (homeRelativePath) => existsSync(join(this.home, homeRelativePath)),
+                logPathFor: (job, relativeLogPath) => (join(job.artifactsLocator, "logs", relativeLogPath))
+            });
+            if (reusable !== null) {
+                return this.#finalizeGateSuccess(attempt, workspace, repositoryPath, head, [...reusable.checks]);
+            }
+        }
+        this.runtimeIsolation.activate(runtime);
+        const baseEnvironment = await integrationCheckEnvironment(this.environment, runtime);
+        const environment = Object.freeze({
+            ...baseEnvironment,
+            ...(releaseId === null ? {} : { [INTEGRATION_RUNTIME_RELEASE_ENV]: releaseId })
+        });
         // Persist the gate identity before starting the job so a plan edit
         // during the gate never misattributes the evidence on resume.
         let persisted = attempt;
@@ -906,6 +931,29 @@ function integrationRuntimeLaunchId(home, integrationId) {
         .digest("hex");
     return `${integrationId}-${homeDigest}`;
 }
+/**
+ * Reuse is enabled only for an immutable installed release. Development
+ * checkouts have no content-addressed release identity, so they rerun.
+ */
+function integrationRuntimeReleaseIdentity(home) {
+    try {
+        const receipt = readRuntimeIdentity(home);
+        const release = receipt?.activeRelease;
+        if (receipt === null
+            || receipt.mode !== "primary"
+            || receipt.dualOwner
+            || release === null
+            || release === undefined
+            || receipt.packageDigest !== release.packageDigest
+            || receipt.buildId !== release.buildId) {
+            return null;
+        }
+        return release.releaseId;
+    }
+    catch {
+        return null;
+    }
+}
 function checkFailureReason(completion) {
     if (completion.timedOut)
         return "Command timed out after 1800 seconds.";

package/dist/integration/integrationCheckEvidenceReuse.js

@@ -0,0 +1,53 @@
+/** Internal, Controller-derived release fence carried by Integration jobs. */
+export const INTEGRATION_RUNTIME_RELEASE_ENV = "YUI_INTEGRATION_RUNTIME_RELEASE_ID";
+/**
+ * Find exact reusable evidence without creating cache state. Every identity
+ * field is read from the existing IntegrationAttempt and DurableJob records.
+ */
+export function findReusableIntegrationCheckEvidence(input) {
+    const attempts = [...input.attempts]
+        .filter((attempt) => (attempt.taskId === input.taskId
+        && attempt.id !== input.currentAttemptId
+        && attempt.projectId === input.projectId
+        && sameOrderedText(attempt.checkCommands, input.checkCommands)))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    for (const attempt of attempts) {
+        if (attempt.jobId === undefined)
+            continue;
+        const job = input.jobs.find((candidate) => (candidate.id === attempt.jobId
+            && candidate.taskId === input.taskId
+            && candidate.owner.kind === "integration-attempt"
+            && candidate.owner.integrationAttemptId === attempt.id));
+        const resultSteps = job?.result?.steps ?? [];
+        const logPaths = resultSteps.map((step) => (input.logPathFor?.(job, step.logPath) ?? step.logPath));
+        if (job === undefined
+            || job.projectId !== input.projectId
+            || job.head !== input.candidateCommit
+            || job.status !== "succeeded"
+            || job.result?.outcome !== "succeeded"
+            || job.env[INTEGRATION_RUNTIME_RELEASE_ENV] !== input.runtimeReleaseId
+            || job.steps.length !== input.checkCommands.length
+            || job.steps.some((step, index) => (step.name !== `check-${index + 1}`
+                || step.command !== input.checkCommands[index]))
+            || resultSteps.length !== input.checkCommands.length
+            || resultSteps.some((step, index) => (step.name !== `check-${index + 1}`
+                || step.exitCode !== 0
+                || step.signal !== null
+                || step.timedOut
+                || step.head !== input.candidateCommit
+                || (input.logExists !== undefined && !input.logExists(logPaths[index]))))) {
+            continue;
+        }
+        const checks = resultSteps.map((step, index) => ({
+            name: input.checkCommands[index],
+            outcome: "passed",
+            details: `Reused successful check evidence from ${attempt.id}/${job.id}.`,
+            logPath: logPaths[index]
+        }));
+        return Object.freeze({ sourceAttempt: attempt, sourceJob: job, checks });
+    }
+    return null;
+}
+function sameOrderedText(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/observability/executionAudit.js

@@ -18,6 +18,7 @@ import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.j
 import { classifyAgentRunFailure, classifyIntegrationAttempt, classifyReviewRound, classifyWakeReasons, countFaultClasses } from "./faultClassification.js";
 import { RUNTIME_LAUNCH_KINDS, RUNTIME_LAUNCH_PHASES } from "../runtime/launchDiagnostics.js";
 import { UNSUPPORTED } from "./runtimeIdentity.js";
+import { projectTaskOrchestration } from "./orchestrationMetrics.js";
 export function createProductionExecutionAuditPorts() {
     return {
         openStore: (home) => openCompatibleFileTaskStore(home),
@@ -206,6 +207,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             events: section,
             providerRetries: section,
             workItems: section,
+            orchestration: section,
             storage: section,
             runtimeProtocol: section,
             topLongRunning: section
@@ -443,7 +445,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         else if (round.deltaRecheck.disposition === "requires-full-review")
                             deltaEscalated += 1;
                     }
-                    const classification = classifyReviewRound(round);
+                    const classification = classifyReviewRound(round, store);
                     if (classification.faultClass === "review-infra")
                         infraFailed += 1;
                     else if (classification.faultClass === "review-semantic-negative") {
@@ -674,6 +676,37 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
+    const orchestration = (() => {
+        try {
+            const metrics = taskIds.flatMap((taskId) => {
+                const task = store.getTask(taskId);
+                if (task === null)
+                    return [];
+                return [projectTaskOrchestration({
+                        task,
+                        runs: withinWindow(store.listAgentRuns(taskId), options),
+                        roleSessionSets: sessionSetsWithinWindow(store.listRoleSessionSets(taskId), options),
+                        workItems: withinWindow(store.listWorkItems(taskId), options),
+                        changeSets: withinWindow(store.listChangeSets(taskId), options),
+                        reviewRounds: withinWindow(store.listReviewRounds(taskId), options),
+                        reviewFindings: withinWindow(store.listReviewFindings(taskId), options),
+                        integrations: withinWindow(store.listIntegrationAttempts(taskId), options),
+                        durableJobs: withinWindow(store.listDurableJobs(taskId), options),
+                        publications: withinWindow(store.listPublicationReferences(taskId), options),
+                        decisions: withinWindow(store.listDecisions(taskId), options),
+                        events: withinWindow(store.listEvents(taskId), options),
+                        managedWorkspaces: withinWindow(store.listManagedWorkspaces(taskId), options)
+                    })];
+            });
+            return ok({
+                tasks: metrics,
+                advisoryCount: metrics.reduce((total, task) => total + task.advisories.length, 0)
+            });
+        }
+        catch (error) {
+            return failed(error);
+        }
+    })();
     const storage = (() => {
         try {
             let stateJsonBytes = UNSUPPORTED;
@@ -834,8 +867,21 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         events,
         providerRetries,
         workItems,
+        orchestration,
         storage,
         runtimeProtocol,
         topLongRunning
     };
 }
+function withinWindow(records, options) {
+    return records.filter((record) => inWindow(record.createdAt, options));
+}
+function sessionSetsWithinWindow(sets, options) {
+    if (options.since === undefined && options.until === undefined)
+        return sets;
+    return sets.map((set) => ({
+        ...set,
+        sessions: Object.fromEntries(Object.entries(set.sessions).filter(([, session]) => (inWindow(session.createdAt, options)))),
+        history: (set.history ?? []).filter((session) => inWindow(session.createdAt, options))
+    }));
+}

package/dist/observability/faultClassification.js

@@ -1,3 +1,4 @@
+import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
 export const FAULT_CLASSES = [
     "provider-transient",
     "policy-denied",
@@ -73,15 +74,16 @@ export function classifyAgentRunFailure(run, structured) {
  * Review execution failure (the Round itself failed to execute/deliver) is
  * `review-infra`; a completed Round with failed checks is a semantic negative.
  */
-export function classifyReviewRound(round) {
-    if (round.status === "failed") {
+export function classifyReviewRound(round, evidence) {
+    const outcome = classifyReviewRoundOutcome(round, evidence);
+    if (outcome?.kind === "non-semantic") {
         return {
             faultClass: "review-infra",
             basis: "structured",
-            evidence: "round status=failed"
+            evidence: outcome.reason
         };
     }
-    if (round.status === "completed" && (round.checks ?? []).some((c) => c.outcome === "failed")) {
+    if (outcome?.kind === "semantic" && (round.checks ?? []).some((c) => c.outcome === "failed")) {
         const failed = (round.checks ?? [])
             .filter((c) => c.outcome === "failed")
             .map((c) => c.name)