@zq-silk/yui 0.8.6 → 0.8.8

package/dist/executor/fileRoleLaunchPlanner.js

@@ -19,8 +19,8 @@ import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.j
 import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
 import { activeLiveRoleAgentSession } from "./agentExecutor.js";
 import { effectiveLaunchSnapshotsCompatibleForTaskMain, effectiveLaunchSnapshotsCompatible, effectiveRoleForLaunch, resolveEffectiveLaunch } from "./effectiveLaunch.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeState, createExactControlPlaneDescriptor, createExactTaskRuntimeDescriptor, exactControlPlaneCommandPrefix, exactControlPlaneDigest, exactTaskRuntimeDescriptorPath, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
-import { readActiveReleasePointer } from "../release/runtimeRelease.js";
+import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR, assertExactTaskRuntimeState, createExactControlPlaneDescriptor, createExactTaskRuntimeDescriptor, exactControlPlaneDigest, exactTaskRuntimeDescriptorPath, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
+import { detectRunningRelease } from "../release/runtimeRelease.js";
 import { parseTaskRuntimeIsolationDescriptor, taskRuntimeIsolationEnvironment } from "../runtime/taskRuntimeIsolation.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
 import { builtinAgentDriverRegistry, builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
@@ -53,21 +53,19 @@ export class FileRoleLaunchPlanner {
         this.#createNativeSessionId = options.createNativeSessionId ?? randomUUID;
         this.#cliPath = canonicalPath(options.cliPath
             ?? fileURLToPath(new URL("../cli.js", import.meta.url)));
-        // Freeze the complete control identity before any native process exists.
-        // This value is immutable for the planner/Controller lifetime and is never
-        // rewritten through a shared PATH launcher.
-        // Issue 02: bind the active release build ID so a Session created after a
-        // handover cannot mutate a different control plane.
-        const activeRelease = readActiveReleasePointer(this.home);
+        // Internal callbacks retain one exact command identity for receipt fencing.
+        // Interactive Role commands use ordinary `yui`; their continuity is the
+        // Session Manifest plus protocol/storage and durable runtime identity.
+        const runningRelease = detectRunningRelease(this.#cliPath);
         this.#controlPlane = createExactControlPlaneDescriptor({
             executable: process.execPath,
             cliEntry: this.#cliPath,
             yuiHome: this.home,
-            ...(activeRelease === null
+            ...(runningRelease === null
                 ? {}
                 : {
-                    buildId: activeRelease.buildId,
-                    activeReleaseDigest: activeRelease.packageDigest
+                    buildId: runningRelease.manifest.buildId,
+                    activeReleaseDigest: runningRelease.manifest.packageDigest
                 })
         });
     }
@@ -247,7 +245,7 @@ export class FileRoleLaunchPlanner {
         if (input.mode === "resume" && !compatibleExisting) {
             throw new Error(`Global Role resume effective snapshot drifted: ${role.name}.`);
         }
-        return this.#compile(role, input, { scope: "global" }, undefined, compatibleExisting ? existing.nativeSessionId : undefined, undefined, effective, { purpose: "execution" });
+        return this.#compile(role, input, { scope: "global" }, undefined, input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, undefined, effective, { purpose: "execution" });
     }
     #compile(role, input, owner, sessionTitle, knownNativeSessionId, workspaceOverride, effective, sessionPolicy) {
         const launchRole = effectiveRoleForLaunch(role, effective);
@@ -347,7 +345,7 @@ export class FileRoleLaunchPlanner {
         const roleConfig = binding.config.adapterId === "claude"
             && owner.scope === "task"
             && input.runId !== undefined
-            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.runId, this.#controlPlane, sessionContext.sessionCliPath)
+            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.runId)
             : binding.config;
         const effectiveConfig = withNativeProjectDirectories(roleConfig, nativeAdditionalDirectories(effective.workspace, agentWorkspace));
         const compileInput = {
@@ -383,15 +381,14 @@ export class FileRoleLaunchPlanner {
                 CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "codex_exec"
             }
             : {};
-        const preallocatedManagedNativeSessionId = managedControl
-            && binding.adapterId === "claude"
+        const preallocatedNativeSessionId = binding.adapterId === "claude"
             && resumeNativeSessionId === undefined
             ? requireText(input.launchId === undefined
                 ? this.#createNativeSessionId()
                 : nativeSessionIdForLaunch(this.home, input.launchId, input.agentId, input.adapterId), "Native session id")
             : resumeNativeSessionId;
         const managedCompiled = managedControl
-            ? adapter.compileManagedControl(compileInput, launchMode, preallocatedManagedNativeSessionId)
+            ? adapter.compileManagedControl(compileInput, launchMode, preallocatedNativeSessionId)
             : undefined;
         const compiled = managedCompiled !== undefined
             ? managedCompiled
@@ -440,7 +437,7 @@ export class FileRoleLaunchPlanner {
         else if (launchMode === "new") {
             if (managedControl)
                 args.push("--plugin-dir", ensureManagedClaudeLifecyclePlugin(this.home, this.#cliPath));
-            const nativeSessionId = requireText(preallocatedManagedNativeSessionId, "Native session id");
+            const nativeSessionId = requireText(preallocatedNativeSessionId, "Native session id");
             if (!managedControl)
                 args.push("--session-id", nativeSessionId);
             else if (!args.includes("--session-id"))
@@ -496,7 +493,7 @@ export class FileRoleLaunchPlanner {
             ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId)
             : undefined;
         const providerNativeSessionId = binding.adapterId === "claude"
-            ? preallocatedManagedNativeSessionId
+            ? preallocatedNativeSessionId
             : resumeNativeSessionId;
         const providerControl = managedControl
             ? {
@@ -745,18 +742,17 @@ function ensureManagedClaudeLifecyclePlugin(home, cliPath) {
     }, null, 2)}\n`);
     return root;
 }
-function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId, controlPlane, sessionCliPath) {
+function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId) {
     if (config.permission.strategy !== "configured")
         return config;
-    const exact = exactControlPlaneCommandPrefix(controlPlane);
     const managed = [
-        `Bash(${sessionCliPath} task run context ${taskId}/${runId}:*)`,
-        `Bash(${exact} --json task context ${taskId})`,
-        `Bash(${exact} --json task work list ${taskId})`,
+        `Bash(yui task run context ${taskId}/${runId}:*)`,
+        `Bash(yui --json task context ${taskId})`,
+        `Bash(yui --json task work list ${taskId})`,
         ...(workItemId === undefined
             ? []
-            : [`Bash(${exact} --json task work show ${workItemId})`]),
-        `Bash(${exact} task run yield ${runId} --summary-file -:*)`
+            : [`Bash(yui --json task work show ${workItemId})`]),
+        `Bash(yui task run yield ${runId} --summary-file -:*)`
     ];
     const existing = (config.permission.allowedTools ?? [])
         .filter((rule) => !isManagedYuiBashRule(rule));
@@ -773,15 +769,6 @@ function isManagedYuiBashRule(rule) {
     return /^Bash\(yui(?:\s|:\*|\*|\))/u.test(normalized)
         || /^Bash\(.*\s--yui-control\s/u.test(normalized);
 }
-function renderExactControlPlaneInstructions(descriptor) {
-    const command = exactControlPlaneCommandPrefix(descriptor);
-    return [
-        "Exact Yui control-plane command prefix for this managed Task session:",
-        `\`${command}\``,
-        "Replace the portable bare `yui` token in Yui Role Skills and dispatch instructions with this exact prefix.",
-        "Bare `yui`, a PATH launcher, another checkout CLI, another YUI_HOME, or a changed schema/Controller identity is invalid and fails before Task state is read or written."
-    ].join("\n");
-}
 function canonicalPath(path) {
     const absolute = resolve(path);
     try {

package/dist/release/releaseHandover.js

@@ -135,8 +135,8 @@ async function activateLocked(ports, locked) {
         };
     }
     // 6) Switch the active release pointer. This is the atomic commit point:
-    // after it succeeds, the stable launcher and new Sessions resolve the new
-    // release.
+    // after it succeeds, Controller lifecycle operations resolve the new
+    // release. The ordinary CLI and managed Session wrappers stay on `yui`.
     const pointer = Object.freeze({
         schemaVersion: 1,
         releaseId,

package/dist/release/runtimeRelease.js

@@ -4,9 +4,10 @@
  *
  * A release is a self-contained, content-addressed runtime package unpacked
  * below `runtime/releases/<version>-<package-sha256>/`. The Home's active
- * release pointer (`runtime/active-release.json`) names exactly one release;
- * the stable launcher shim resolves the CLI through that pointer instead of
- * symlinking a development checkout.
+ * release pointer (`runtime/active-release.json`) names exactly one Controller
+ * release. The ordinary CLI remains the globally installed package; only an
+ * explicit target activation delegates to the verified target release CLI so
+ * that release owns its handover protocol and deadlines.
  *
  * The Controller writes its provenance to `runtime/runtime-identity.json` on
  * every start, and a versioned handover fence (`runtime/handover-fence.json`)

package/dist/review/reviewOutcomeClassifier.js

@@ -1,4 +1,5 @@
 import { matchYieldReceipt } from "../run/yieldReceipt.js";
+import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 const INFRA_SIGNATURES = [
     { kind: "session-not-stopped", pattern: /session must be stopped before workspace migration/iu },
     { kind: "run-start", pattern: /role run could not start|could not start (?:the )?(?:reviewer|role) run/iu },
@@ -15,6 +16,14 @@ const INFRA_SIGNATURES = [
 export function classifyReviewRoundOutcome(round, evidence) {
     if (round.status !== "completed" && round.status !== "failed")
         return null;
+    if (evidence !== undefined && round.reviewerRunId !== undefined
+        && isTaskRecordRetired(evidence.listEvents(round.taskId), "agent-run", round.reviewerRunId)) {
+        return {
+            kind: "non-semantic",
+            infraKind: "run-identity",
+            reason: `Reviewer Run ${round.reviewerRunId} was retired from operational evidence.`
+        };
+    }
     const infraKind = classifyInfraKind(`${round.summary ?? ""}\n${round.report ?? ""}`);
     if (round.status === "failed") {
         const semanticEvidence = failedRoundSemanticEvidence(round, evidence);
@@ -86,7 +95,8 @@ function failedRoundSemanticEvidence(round, evidence) {
     if (semanticLane !== undefined)
         return `Reviewer Lane ${semanticLane.id} delivered semantic evidence.`;
     if (evidence !== undefined) {
-        const reviewRun = evidence.listAgentRuns(round.taskId).find((run) => (run.purpose === "review"
+        const events = evidence.listEvents(round.taskId);
+        const reviewRun = operationalTaskRecords(evidence.listAgentRuns(round.taskId), events, "agent-run").find((run) => (run.purpose === "review"
             && run.reviewRoundId === round.id
             && (run.status === "yielded" || runtimeFailureSummaryHasReviewerOutput(run.summary ?? ""))));
         if (reviewRun !== undefined)
@@ -94,7 +104,7 @@ function failedRoundSemanticEvidence(round, evidence) {
         const finding = evidence.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
         if (finding !== undefined)
             return `Review finding ${finding.id} references the Round.`;
-        const completion = evidence.listEvents(round.taskId).find((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
+        const completion = events.find((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
         if (completion !== undefined)
             return `Review completion Event ${completion.id} exists.`;
     }
@@ -142,7 +152,8 @@ function completedInfrastructureCorroborationFailure(round, store) {
             return `Completed Round has non-completed Reviewer Lane ${lane.id}/${lane.status}.`;
         }
     }
-    const runs = store.listAgentRuns(round.taskId).filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
+    const allEvents = store.listEvents(round.taskId);
+    const runs = operationalTaskRecords(store.listAgentRuns(round.taskId), allEvents, "agent-run").filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
     const active = runs.find(({ status }) => status === "active");
     if (active !== undefined)
         return `Reviewer Run ${active.id} is still active.`;
@@ -176,7 +187,7 @@ function completedInfrastructureCorroborationFailure(round, store) {
     const finding = store.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
     if (finding !== undefined)
         return `Review finding ${finding.id} references the Round.`;
-    const events = store.listEvents(round.taskId).filter((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
+    const events = allEvents.filter((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
     if (events.length !== 1)
         return "Completed Round lacks one exact completion Event.";
     const event = events[0];

package/dist/review/taskFinalReviewContractRebind.js

@@ -23,6 +23,13 @@ export function resolveRecordedTaskFinalReviewContract(taskId, workItems, review
                     source: `Candidate ${item.id}/${candidate.id}`
                 }];
     });
+    const historicalCandidateObservations = workItems.flatMap((item) => (item.candidates
+        .filter((candidate) => candidate.taskFinalReviewContract !== undefined)
+        .map((candidate) => ({
+        contract: candidate.taskFinalReviewContract,
+        createdAt: candidate.createdAt,
+        source: `Historical Candidate ${item.id}/${candidate.id}`
+    }))));
     const reviewObservations = reviewRounds.flatMap((round) => ((round.scope ?? "work-item") !== "task"
         || round.taskFinalReviewContract === undefined
         ? []
@@ -31,7 +38,7 @@ export function resolveRecordedTaskFinalReviewContract(taskId, workItems, review
                 createdAt: round.createdAt,
                 source: `ReviewRound ${round.id}`
             }]));
-    return resolveTaskFinalReviewContract(taskId, [...candidateObservations, ...reviewObservations], events);
+    return resolveTaskFinalReviewContract(taskId, [...candidateObservations, ...reviewObservations], events, historicalCandidateObservations);
 }
 export function createTaskFinalReviewContractRebind(input) {
     const taskId = requireIdentity(input.taskId, "Task final-review rebind Task id");
@@ -140,7 +147,7 @@ export function taskFinalReviewContractRebindFromEvent(event) {
  * as a forward-only sequence, then require one strict append-only rebind chain.
  * Any Reviewer change, reversion, fork, or post-rebind drift fails closed.
  */
-export function resolveTaskFinalReviewContract(taskId, observations, events) {
+export function resolveTaskFinalReviewContract(taskId, observations, events, historicalObservations = []) {
     const normalizedTaskId = requireIdentity(taskId, "Task final-review contract Task id");
     const orderedObservations = [...observations]
         .map((observation) => ({
@@ -149,6 +156,13 @@ export function resolveTaskFinalReviewContract(taskId, observations, events) {
         source: requireText(observation.source, "Task final-review observation source")
     }))
         .sort(compareCreatedAt);
+    const orderedHistoricalObservations = [...historicalObservations]
+        .map((observation) => ({
+        contract: validateTaskFinalReviewContract(observation.contract),
+        createdAt: requireTimestamp(observation.createdAt, "Task final-review historical observation createdAt"),
+        source: requireText(observation.source, "Task final-review historical observation source")
+    }))
+        .sort(compareCreatedAt);
     const orderedEvents = events
         .filter(({ type }) => type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT)
         .map((event) => ({
@@ -158,26 +172,29 @@ export function resolveTaskFinalReviewContract(taskId, observations, events) {
     }))
         .sort((left, right) => compareCreatedAt(left, right)
         || left.event.id.localeCompare(right.event.id, undefined, { numeric: true }));
-    if (orderedObservations.length === 0) {
-        if (orderedEvents.length > 0) {
-            throw new Error(`Task ${normalizedTaskId} has a final-review rebind without a stored contract.`);
-        }
+    if (orderedObservations.length === 0 && orderedEvents.length === 0)
         return undefined;
-    }
-    for (const observation of orderedObservations) {
+    for (const observation of [...orderedObservations, ...orderedHistoricalObservations]) {
         if (observation.contract.taskId !== normalizedTaskId) {
             throw new Error(`${observation.source} carries a final-review contract for another Task.`);
         }
     }
-    const initial = orderedObservations[0].contract;
-    const reviewerRoleName = initial.reviewerRoleName;
     const firstRebindAt = orderedEvents[0]?.createdAt;
-    const legacyObservations = firstRebindAt === undefined
+    const primaryLegacyObservations = firstRebindAt === undefined
         ? orderedObservations
         : orderedObservations.filter(({ createdAt }) => createdAt < firstRebindAt);
+    const historicalRebindSource = orderedEvents[0] === undefined
+        ? undefined
+        : orderedHistoricalObservations.find((observation) => (observation.createdAt < orderedEvents[0].createdAt
+            && sameTaskFinalReviewContract(observation.contract, orderedEvents[0].rebind.fromContract)));
+    const legacyObservations = primaryLegacyObservations.length > 0
+        ? primaryLegacyObservations
+        : historicalRebindSource === undefined ? [] : [historicalRebindSource];
     if (legacyObservations.length === 0) {
         throw new Error(`Task ${normalizedTaskId} has a final-review rebind without an established source contract.`);
     }
+    const initial = legacyObservations[0].contract;
+    const reviewerRoleName = initial.reviewerRoleName;
     let effective = initial;
     const legacyContractDigests = new Set([initial.digest]);
     for (const observation of legacyObservations) {

package/dist/runtime/exactControlPlane.js

@@ -9,7 +9,6 @@ import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecyc
 import { nativeSessionIdForLaunch } from "./preallocatedNativeSession.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
-import { readActiveReleasePointer } from "../release/runtimeRelease.js";
 export const EXACT_CONTROL_ARGUMENT = "--yui-control";
 export const YUI_CONTROL_PLANE_DESCRIPTOR = "YUI_CONTROL_PLANE_DESCRIPTOR";
 export const YUI_TASK_RUNTIME_DESCRIPTOR = "YUI_TASK_RUNTIME_DESCRIPTOR";
@@ -174,43 +173,67 @@ export async function assertExactControlPlanePreflight(input, options = {}) {
             + `(expected ${descriptor.identity.aggregateSchemaVersion}, found `
             + `${storage.currentAggregateSchemaVersion ?? "unknown"}).`);
     }
-    // Issue 02: bind the descriptor to the active release. A descriptor that
-    // carries a build ID must match the Home's active release pointer; a
-    // descriptor without a build ID is rejected once a Home has an active
-    // release (old Sessions cannot mutate a released control plane). Homes
-    // without an active release pointer keep the legacy continuity contract.
-    const readActiveRelease = options.readActiveRelease ?? defaultReadActiveRelease;
-    const activeRelease = readActiveRelease(descriptor.yuiHome);
-    if (descriptor.buildId !== undefined) {
-        if (activeRelease === null) {
-            throw new Error("Exact control-plane descriptor names a release build but the Home has "
-                + "no active release pointer.");
+    // A frozen descriptor authenticates the command that created it; it no
+    // longer pins the Home's deployment pointer for the lifetime of a Session.
+    // Continuity is the protocol/storage contract checked above and the durable
+    // Task/Role/Run identity checked below. This lets a compatible Controller or
+    // active release advance without invalidating a still-current Session.
+    if (options.checkController !== false) {
+        const call = options.callController ?? defaultCallController;
+        try {
+            const status = await call(descriptor.yuiHome, "controller.status", {});
+            assertControllerContinuityIdentity(status, descriptor.identity);
         }
-        if (activeRelease.buildId !== descriptor.buildId) {
-            throw new Error("Exact control-plane release changed since the descriptor was frozen "
-                + `(expected ${descriptor.buildId}, active ${activeRelease.buildId}).`);
+        catch (error) {
+            if (!isDefinitelyNotRunning(error))
+                throw error;
         }
-        if (descriptor.activeReleaseDigest !== undefined
-            && activeRelease.packageDigest !== descriptor.activeReleaseDigest) {
-            throw new Error("Exact control-plane release digest does not match the active release pointer.");
+    }
+    return descriptor;
+}
+/**
+ * Compatibility gate for an ordinary `yui` invocation inside a managed
+ * Session. The Session Manifest and durable runtime state authenticate the
+ * actor separately; this gate proves that the current CLI can safely share the
+ * Home with its storage and Controller without pinning package/build identity.
+ */
+export async function assertCompatibleControlPlanePreflight(input, options = {}) {
+    const home = canonicalPath(input.actualHome);
+    const identity = validateVersionIdentity(options.identity ?? yuiVersionIdentity());
+    const storage = (options.inspectStorage ?? inspectStorageSchema)(home);
+    if (storage.status !== "current") {
+        const compatibleRecordOnlyOlder = storage.status === "unsupported"
+            && storage.incompatibleComponent === "record"
+            && storage.direction === "older"
+            && storage.currentLayoutVersion === identity.storageLayoutVersion
+            && storage.currentAggregateSchemaVersion === identity.aggregateSchemaVersion;
+        if (!compatibleRecordOnlyOlder) {
+            throw new Error(`Managed control-plane storage is not current: ${storage.status}.`);
         }
+        (options.openCompatibleStore ?? openCompatibleFileTaskStore)(home).getConfig();
     }
-    else if (activeRelease !== null) {
-        throw new Error("Exact control-plane descriptor predates the active release; old Sessions "
-            + "cannot mutate a released control plane. Re-launch through the current release.");
+    if (storage.currentLayoutVersion !== identity.storageLayoutVersion) {
+        throw new Error("Managed control-plane storage layout is incompatible "
+            + `(expected ${identity.storageLayoutVersion}, found `
+            + `${storage.currentLayoutVersion ?? "unknown"}).`);
+    }
+    if (storage.currentAggregateSchemaVersion !== identity.aggregateSchemaVersion) {
+        throw new Error("Managed control-plane aggregate schema is incompatible "
+            + `(expected ${identity.aggregateSchemaVersion}, found `
+            + `${storage.currentAggregateSchemaVersion ?? "unknown"}).`);
     }
     if (options.checkController !== false) {
         const call = options.callController ?? defaultCallController;
         try {
-            const status = await call(descriptor.yuiHome, "controller.status", {});
-            assertControllerContinuityIdentity(status, descriptor.identity);
+            const status = await call(home, "controller.status", {});
+            assertControllerContinuityIdentity(status, identity);
         }
         catch (error) {
             if (!isDefinitelyNotRunning(error))
                 throw error;
         }
     }
-    return descriptor;
+    return identity;
 }
 export function assertControllerStatusIdentity(status, expected = yuiVersionIdentity()) {
     if (!isRecord(status) || status.running !== true) {
@@ -539,16 +562,3 @@ function isRecord(value) {
 function isDefinitelyNotRunning(error) {
     return isRecord(error) && error.code === "CONTROLLER_NOT_RUNNING";
 }
-function defaultReadActiveRelease(home) {
-    try {
-        const pointer = readActiveReleasePointer(home);
-        return pointer === null
-            ? null
-            : { buildId: pointer.buildId, packageDigest: pointer.packageDigest };
-    }
-    catch {
-        // A damaged pointer fails closed: treat it as an active release the
-        // descriptor cannot match, rather than silently skipping the gate.
-        return { buildId: "unknown", packageDigest: "unknown" };
-    }
-}

package/dist/runtime/firstProgressStopLoss.js

@@ -21,7 +21,9 @@ export function projectFirstProgressStopLoss(input) {
             ...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.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}` }))
         ]

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/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/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/storage/sqliteStore.js

@@ -48,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";
@@ -709,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,
@@ -721,7 +728,8 @@ 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),
+            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"),
@@ -729,7 +737,7 @@ export class SqliteTaskStore {
             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")
+                events: events.filter((event) => event.type === "review.completed")
             }
         };
     }
@@ -739,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

@@ -34,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";
@@ -409,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,
@@ -421,7 +423,7 @@ export class FileTaskStore {
             changeSets: values(aggregate.changeSets, "id"),
             integrations: values(aggregate.integrationAttempts, "id"),
             reviewRounds: values(aggregate.reviewRounds, "id"),
-            taskFinalReviewContractEvents: values(aggregate.events, "id")
+            taskFinalReviewContractEvents: events
                 .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),
             reviewConfig: this.getReviewConfig(),
             openInputRequests: values(aggregate.inputRequests, "id")
@@ -432,7 +434,7 @@ export class FileTaskStore {
                 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"))
+                events: events.filter((event) => (event.type === "review.completed"))
             }
         };
     }
@@ -451,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"),