@zq-silk/yui 0.8.6 → 0.8.7

package/dist/commands/taskContextCommand.js

@@ -8,6 +8,7 @@ import { taskDeliveryPath } from "../task/task.js";
 import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 const RECENT_RECORD_LIMIT = 5;
 const RELATED_RECORD_LIMIT = 5;
 const SUMMARY_TEXT_LIMIT = 400;
@@ -41,7 +42,8 @@ export function runTaskContextCommand(args, store) {
                 roleName: role.name
             }))
         ].filter((mailbox) => mailbox !== null);
-        const agentRuns = chronological(reader.listAgentRuns(task.id));
+        const events = reader.listEvents(task.id);
+        const agentRuns = chronological(operationalTaskRecords(reader.listAgentRuns(task.id), events, "agent-run"));
         const reviewRounds = chronological(reader.listReviewRounds(task.id));
         const changeSets = chronological(reader.listChangeSets(task.id));
         const integrations = chronological(reader.listIntegrationAttempts(task.id));
@@ -70,10 +72,10 @@ export function runTaskContextCommand(args, store) {
             changeSets,
             integrations,
             publications,
-            messages: reader.listMessages(task.id),
+            messages: operationalTaskRecords(reader.listMessages(task.id), events, "message"),
             openInputRequests: inputRequests.filter((request) => request.status === "open"),
             resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
-            events: reader.listEvents(task.id),
+            events,
             nextAction: projectNextAction(nextActionFacts)
         };
     });

package/dist/commands/taskNextActionCommand.js

@@ -4,6 +4,7 @@ import { projectCompletionReadiness } from "../task/completionReadiness.js";
 import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
 import { taskDeliveryPath } from "../task/task.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
  * Folds the existing durable records into exactly one protocol-level next
@@ -57,9 +58,10 @@ export function runTaskNextActionCommand(args, store) {
                 throw taskNotFound(taskId);
             completionReadiness = projectCompletionReadiness(readinessFacts);
         }
+        const events = reader.listEvents(taskId);
         const orchestration = projectTaskOrchestration({
             task: reader.getTask(taskId),
-            runs: reader.listAgentRuns(taskId),
+            runs: operationalTaskRecords(reader.listAgentRuns(taskId), events, "agent-run"),
             roleSessionSets: reader.listRoleSessionSets(taskId),
             workItems: reader.listWorkItems(taskId),
             changeSets: reader.listChangeSets(taskId),
@@ -69,7 +71,7 @@ export function runTaskNextActionCommand(args, store) {
             durableJobs: reader.listDurableJobs(taskId),
             publications: reader.listPublicationReferences(taskId),
             decisions: reader.listDecisions(taskId),
-            events: reader.listEvents(taskId),
+            events,
             managedWorkspaces: reader.listManagedWorkspaces(taskId)
         });
         return {

package/dist/commands/taskOverviewCommand.js

@@ -226,7 +226,8 @@ function collectBlockers(workItems, openInputRequests, attention) {
         }
         if (item.status !== "pending")
             continue;
-        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"));
+        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"
+            && workById.get(dependency)?.status !== "retired"));
         if (dependencies.length === 0)
             continue;
         blockers.push({

package/dist/commands/taskRoleRuntimeStatus.js

@@ -7,6 +7,7 @@ import { classifyRuntimeHealth, projectRuntimeMailbox, projectRuntimeObservation
 import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -140,7 +141,7 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
     // Issue 09: the last Run outcome is a separate axis from the Session
     // lifecycle. A Session that stops after its Run yielded must not retroactively
     // turn that Run into a failure; the status display keeps both visible.
-    const lastRun = store.listAgentRuns(taskId)
+    const lastRun = operationalTaskRecords(store.listAgentRuns(taskId), store.listEvents(taskId), "agent-run")
         .filter((candidate) => candidate.roleName === role.name)
         .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]
         ?? null;

package/dist/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_BOOTSTRAP_MAX_DELTAS } from "./runContextContract.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
@@ -213,9 +214,12 @@ function collectAuthorizedContext(store, run) {
         if (view === "worker") {
             for (const dependencyId of item.dependsOn) {
                 const dependency = store.getWorkItem(task.id, dependencyId);
-                if (dependency === null || dependency.status !== "completed") {
+                if (dependency === null
+                    || (dependency.status !== "completed" && dependency.status !== "retired")) {
                     throw new Error(`Run WorkItem dependency is not accepted: ${dependencyId}.`);
                 }
+                if (dependency.status === "retired")
+                    continue;
                 result.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
             }
         }
@@ -242,7 +246,8 @@ function collectAuthorizedContext(store, run) {
         }
     }
     if (view === "leader") {
-        for (const item of store.listWorkItems(task.id)) {
+        const events = store.listEvents(task.id);
+        for (const item of store.listWorkItems(task.id).filter(({ status }) => status !== "retired")) {
             result.push(materialize("L3", "work-item", item.id, item));
         }
         for (const decision of store.listDecisions(task.id)) {
@@ -257,14 +262,13 @@ function collectAuthorizedContext(store, run) {
         for (const finding of store.listReviewFindings(task.id)) {
             result.push(materialize("L3", "review-finding", finding.id, finding));
         }
-        for (const agentRun of store.listAgentRuns(task.id).slice(-24)) {
+        for (const agentRun of operationalTaskRecords(store.listAgentRuns(task.id), events, "agent-run").slice(-24)) {
             result.push(materialize("L4", "agent-run", agentRun.id, agentRun));
         }
-        for (const message of store.listMessages(task.id).slice(-16)) {
+        for (const message of operationalTaskRecords(store.listMessages(task.id), events, "message").slice(-16)) {
             result.push(materialize("L4", "task-message", message.id, message));
         }
         const publishedTreeAuthorizations = [];
-        const events = store.listEvents(task.id);
         for (let index = events.length - 1; index >= 0; index -= 1) {
             const event = events[index];
             if (event.type === "task.completed" || event.type === "task.reopened")

package/dist/context/sessionBootstrapManifest.js

@@ -1,10 +1,15 @@
 import { createHash } from "node:crypto";
-import { chmodSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { exactControlPlaneCommandPrefix, exactControlPlaneDigest, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
+import { chmodSync, existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { exactControlPlaneDigest, serializeExactDescriptor } from "../runtime/exactControlPlane.js";
 import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
 export { SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, SESSION_CONTEXT_PROTOCOL, sessionManifestCompatibilityDigest } from "./sessionProtocolIdentity.js";
+const ORDINARY_SESSION_CLI = [
+    "#!/bin/sh",
+    "exec yui \"$@\"",
+    ""
+].join("\n");
 /** Read back one immutable Session Manifest and verify its content digest. */
 export function readSessionBootstrapManifest(path) {
     const source = resolve(path);
@@ -79,11 +84,10 @@ export function materializeSessionBootstrap(input) {
     const controlDigest = exactControlPlaneDigest(input.controlPlane);
     const descriptorPath = resolve(join(home, "runtime", "control-plane", `${controlDigest}.json`));
     writeImmutableText(descriptorPath, `${serializeExactDescriptor(input.controlPlane)}\n`);
-    const sessionCliContent = [
-        "#!/bin/sh",
-        `exec ${exactControlPlaneCommandPrefix(input.controlPlane)} \"$@\"`,
-        ""
-    ].join("\n");
+    // Session identity is carried by the immutable Manifest and durable Role/
+    // Run fences. Resolve the ordinary CLI on every invocation so package or
+    // release upgrades do not invalidate a still-current native Session.
+    const sessionCliContent = ORDINARY_SESSION_CLI;
     const sessionCliDigest = digest(sessionCliContent);
     const sessionCliPath = resolve(join(home, "runtime", "session-cli", `yui-${sessionCliDigest}.sh`));
     writeImmutableText(sessionCliPath, sessionCliContent);
@@ -122,11 +126,11 @@ export function materializeSessionBootstrap(input) {
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
         contextProtocol: input.owner.scope === "global"
             ? {
-                loadCommand: `\"${sessionCliPath}\" session context \"$YUI_ROLE\" --json`
+                loadCommand: "yui session context \"$YUI_ROLE\" --json"
             }
             : {
-                loadCommand: `\"${sessionCliPath}\" task run context \"$YUI_TASK_ID/<run-id>\" --json`,
-                expandCommand: `\"${sessionCliPath}\" task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --store <store> --mode full --json`
+                loadCommand: "yui task run context \"$YUI_TASK_ID/<run-id>\" --json",
+                expandCommand: "yui task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --store <store> --mode full --json"
             }
     };
     const manifest = Object.freeze({ ...body, digest: digest(body) });
@@ -140,6 +144,68 @@ export function materializeSessionBootstrap(input) {
         descriptorPath
     });
 }
+/**
+ * Converts wrappers produced before the protocol-compatible Session CLI to an
+ * ordinary `yui` invocation. Only a valid Session Manifest may nominate a
+ * wrapper, and only the exact legacy two-line wrapper shape is changed. The
+ * Manifest and its frozen descriptor stay immutable and continue to
+ * authenticate the Session; repeated refreshes are no-ops.
+ */
+export function refreshManagedSessionCliWrappers(homeInput) {
+    const home = resolve(homeInput);
+    const manifestDirectory = resolve(join(home, "runtime", "session-manifests"));
+    const sessionCliDirectory = resolve(join(home, "runtime", "session-cli"));
+    if (!existsSync(manifestDirectory)) {
+        return Object.freeze({ refreshed: 0, current: 0, skipped: 0 });
+    }
+    const wrapperPaths = new Set();
+    let skipped = 0;
+    for (const name of readdirSync(manifestDirectory).filter((entry) => entry.endsWith(".json"))) {
+        const manifestPath = resolve(join(manifestDirectory, name));
+        try {
+            const manifest = readSessionBootstrapManifest(manifestPath);
+            if (manifestPath !== resolve(join(manifestDirectory, `${manifest.digest}.json`))) {
+                skipped += 1;
+                continue;
+            }
+            const wrapperPath = resolve(manifest.controlPlane.sessionCliPath);
+            if (dirname(wrapperPath) !== sessionCliDirectory) {
+                skipped += 1;
+                continue;
+            }
+            wrapperPaths.add(wrapperPath);
+        }
+        catch {
+            // Historical or incomplete manifests are audit material. They must not
+            // block current Sessions or an otherwise compatible package update.
+            skipped += 1;
+        }
+    }
+    let refreshed = 0;
+    let current = 0;
+    for (const wrapperPath of wrapperPaths) {
+        if (!existsSync(wrapperPath)) {
+            skipped += 1;
+            continue;
+        }
+        const content = readFileSync(wrapperPath, "utf8");
+        if (content === ORDINARY_SESSION_CLI) {
+            current += 1;
+            continue;
+        }
+        if (!isLegacyExactSessionCli(content)) {
+            skipped += 1;
+            continue;
+        }
+        writeTextFileAtomically(wrapperPath, ORDINARY_SESSION_CLI);
+        chmodSync(wrapperPath, 0o700);
+        refreshed += 1;
+    }
+    return Object.freeze({ refreshed, current, skipped });
+}
+function isLegacyExactSessionCli(content) {
+    return /^#!\/bin\/sh\nexec [^\n]+ '--yui-control' '[a-f0-9]{64}' "\$@"\n$/u.test(content);
+}
 function writeImmutableText(path, content) {
     writeTextFileAtomically(path, content);
     chmodSync(path, 0o600);

package/dist/context/wakeNotification.js

@@ -1,4 +1,5 @@
 import { renderWakeReason } from "../scheduler/wakeReason.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 /**
  * Issue 04 (context token budget) — long-term design:
  *
@@ -25,12 +26,13 @@ export function buildTaskWakeEnvelope(reader, request) {
         throw new Error(`Wake envelope ${request.wakeId} must carry at least one reason.`);
     }
     const fromTime = Date.parse(request.fromCursor);
+    const events = reader.listEvents(request.taskId);
     const counts = {
-        events: reader.listEvents(request.taskId)
+        events: events
             .filter((record) => Date.parse(record.createdAt) > fromTime).length,
-        messages: reader.listMessages(request.taskId)
+        messages: operationalTaskRecords(reader.listMessages(request.taskId), events, "message")
             .filter((record) => Date.parse(record.createdAt) > fromTime).length,
-        runs: reader.listAgentRuns(request.taskId)
+        runs: operationalTaskRecords(reader.listAgentRuns(request.taskId), events, "agent-run")
             .filter((record) => Date.parse(record.createdAt) > fromTime).length
     };
     const lines = [

package/dist/controller/clientRuntime.js

@@ -7,7 +7,7 @@ import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/exactControlPlane.js";
 import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
-import { YUI_VERSION, yuiVersionIdentity } from "../version.js";
+import { yuiVersionIdentity } from "../version.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
 import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
 import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
@@ -137,12 +137,8 @@ function assertCompatibleControllerStatus(status, expectedVersion) {
             + "Run `yui controller restart` before writing new task records.");
     }
     const actualVersion = statusRecord.version;
-    const expected = expectedVersion ?? YUI_VERSION;
-    const versionMismatch = expectedVersion === undefined
-        ? typeof actualVersion === "string" && actualVersion !== expected
-        : actualVersion !== expected;
-    if (versionMismatch) {
-        throw new Error(`Controller version is incompatible (expected ${expected}, found ${typeof actualVersion === "string" ? actualVersion : "unknown"}). `
+    if (expectedVersion !== undefined && actualVersion !== expectedVersion) {
+        throw new Error(`Controller version is incompatible (expected ${expectedVersion}, found ${typeof actualVersion === "string" ? actualVersion : "unknown"}). `
             + "Run `yui controller restart` before writing new task records.");
     }
     // Ordinary callers must authenticate the complete control-plane identity.
@@ -151,7 +147,11 @@ function assertCompatibleControllerStatus(status, expectedVersion) {
     // path authenticates its executable, argv, and version immediately after
     // readiness in ensureFileTaskControllerIdentity.
     if (expectedVersion === undefined) {
-        assertControllerStatusIdentity(status, yuiVersionIdentity());
+        const identity = yuiVersionIdentity();
+        assertControllerStatusIdentity(status, {
+            ...identity,
+            version: typeof actualVersion === "string" ? actualVersion : identity.version
+        });
     }
 }
 function spawnDetachedFileTaskController(home, environment) {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -6,6 +6,7 @@ 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 { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
 import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
 import { rolloverTaskRoleSessionForContextBudget } from "../lifecycle/contextBudgetRollover.js";
@@ -596,7 +597,7 @@ export class FileSchedulerStoreAdapter {
             const latest = latestTaskWake(reader.listTaskWakes(taskId));
             const fromCursor = latest?.toCursor ?? fallbackWakeCursor({
                 taskCreatedAt: task.createdAt,
-                leaderRunCreatedAt: reader.listAgentRuns(taskId)
+                leaderRunCreatedAt: operationalTaskRecords(reader.listAgentRuns(taskId), reader.listEvents(taskId), "agent-run")
                     .filter((run) => run.roleName === "leader")
                     .at(-1)?.createdAt
             });
@@ -3706,7 +3707,7 @@ function bindTaskRoleRunInFlight(store, role, run, now) {
         agentId,
         runId: run.id,
         receiptId: agentRunDeliveryReceiptId(run)
-    }, now);
+    }, now, run.mode);
     store.saveRoleSessionSet(updated);
 }
 function markTaskRoleRunPushedInFlight(store, role, run, now) {

package/dist/executor/agentExecutor.js

@@ -292,7 +292,7 @@ export function roleAgentSessionResumeMode(set, agentId, desired, workspace) {
     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) {
+export function bindTaskRoleRun(set, fence, preparedAt, mode) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);
     const normalized = normalizeTaskRoleRunFence(fence);
@@ -305,9 +305,9 @@ export function bindTaskRoleRun(set, fence, preparedAt) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    const providerBinding = set.providerBinding === null
-        ? null
-        : rebindProviderRuntimeRun(set.providerBinding, normalized.runId);
+    const providerBinding = mode === "resume" && set.providerBinding !== null
+        ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
+        : null;
     const updated = {
         ...set,
         inFlight: { ...normalized, preparedAt: timestamp },

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/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];