@zq-silk/yui 0.8.6 → 0.8.8

package/dist/commands/taskCommands.js

@@ -5,6 +5,7 @@ import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds,
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { CliError, dataError, roleNotFound, runtimeError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { createTaskRecordRetirement, isTaskRecordRetired, taskRecordRetirement } from "../task/taskRecordRetirement.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { readCommandText } from "./textInput.js";
 import { assertTaskCompletionPublishedTreeProof } from "./taskCompletionGate.js";
@@ -1348,23 +1349,79 @@ function taskMessageCommand(args, store, options) {
         }
         if (messages.length === 0)
             return "No messages found.\n";
+        const retirements = new Map(store.listEvents(task.id).flatMap((event) => {
+            const retirement = taskRecordRetirement(event);
+            return retirement?.recordKind === "message"
+                ? [[retirement.recordId, retirement]]
+                : [];
+        }));
         const timeZone = store.getConfig().timeZone;
         return `${renderTable(`Task messages: ${task.id}`, [
             { header: "Message", minWidth: 7, maxWidth: 18 },
+            { header: "Status", minWidth: 6, maxWidth: 9 },
             { header: "Author", minWidth: 6, maxWidth: 18 },
             { header: "Created", minWidth: 10, maxWidth: 28 },
             { header: "Body", minWidth: 8, maxWidth: 72 }
         ], messages.map((message) => [
             message.id,
+            retirements.has(message.id) ? "retired" : "active",
             taskMessageAuthorLabel(message.author),
             presentTime(message.createdAt, timeZone),
             message.body
         ]), defaultTableWidth())}\n`;
     }
+    if (command === "retire") {
+        return retireMessage(rest, store, options);
+    }
     throw usageError(command === undefined
         ? "Task message command is required."
         : `Unknown command: task message ${command}`);
 }
+function retireMessage(args, store, options) {
+    const usage = "Task message retire usage: yui task message retire <task>/<message> --reason <text>.";
+    const parsed = parseTail(args, new Set(["--reason"]), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const reason = requiredOption(parsed.options, "--reason");
+    const reference = taskRecordReference(parsed.positionals[0], "message", "Message reference", options);
+    const now = clock(options);
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, reference.taskId);
+        assertTaskOpen(task);
+        const actor = taskActor(options, task.id);
+        if (actor === "leader") {
+            throw usageError("Only the user or global Operator may retire a Task Message.");
+        }
+        const message = tx.listMessages(task.id).find(({ id }) => id === reference.localId);
+        if (message === undefined) {
+            throw dataError(`Task Message not found: ${task.id}/${reference.localId}.`);
+        }
+        const events = tx.listEvents(task.id);
+        if (isTaskRecordRetired(events, "message", message.id)) {
+            return { task, message, changed: false };
+        }
+        // Remove an isolated pending wake for this exact directive. A merged batch
+        // is retained because its other signals remain actionable; context and
+        // actionability projections still filter the retired message below.
+        try {
+            settleExactWorkExecution(tx, leaderMailbox(task.id), messageRef(task.id, message.id));
+        }
+        catch {
+            // Merged pending work cannot be split without losing unrelated signals.
+        }
+        tx.saveEvent(task.id, createTaskRecordRetirement({
+            eventId: tx.nextEventId(task.id),
+            taskId: task.id,
+            recordKind: "message",
+            recordId: message.id,
+            reason,
+            retiredBy: actor
+        }, now));
+        return { task, message, changed: true };
+    });
+    if (result.changed)
+        options.runtime?.notifyStateChanged(result.task.id);
+    return `Retired Task Message ${result.task.id}/${result.message.id}\n`;
+}
 /**
  * Issue 05: force-wake escape hatch. Bypasses the actionability digest and
  * enqueues exactly one Leader wakeup with an auditable reason. The reason is
@@ -2659,9 +2716,7 @@ function retireWork(args, store, options) {
         if (task.status !== "active") {
             throw usageError(`Task is not active: ${task.id}/${task.status}.`);
         }
-        if (taskActor(options, task.id) !== "leader") {
-            throw usageError("Only the Task Leader may retire a Work Item.");
-        }
+        const actor = taskActor(options, task.id);
         if (replacementWorkItemId !== undefined) {
             const replacement = requireWorkItem(tx, replacementWorkItemId, options);
             if (replacement.taskId !== task.id) {
@@ -2701,7 +2756,7 @@ function retireWork(args, store, options) {
             }
         }
         const next = retireWorkItem(item, {
-            by: "leader",
+            by: actor,
             summary,
             ...(replacementWorkItemId === undefined ? {} : { replacementWorkItemId })
         }, now);
@@ -2713,8 +2768,16 @@ function retireWork(args, store, options) {
                 ...(replacementWorkItemId === undefined
                     ? {}
                     : { replacementWorkItemId }),
-                ...leaderActionEventPayload(tx, task.id, options)
+                ...(actor === "leader" ? leaderActionEventPayload(tx, task.id, options) : { retiredBy: actor })
             }, now);
+            tx.saveEvent(task.id, createTaskRecordRetirement({
+                eventId: tx.nextEventId(task.id),
+                taskId: task.id,
+                recordKind: "work-item",
+                recordId: next.id,
+                reason: summary,
+                retiredBy: actor
+            }, now));
         }
         return next;
     });
@@ -3801,10 +3864,64 @@ function taskRunCommand(args, store, options) {
         return yieldRunStatus(rest, store, options);
     if (command === "checkpoint")
         return output(checkpointRun(rest, store, options));
+    if (command === "retire")
+        return retireRun(rest, store, options);
     throw usageError(command === undefined
         ? "Task run command is required."
         : `Unknown command: task run ${command}`);
 }
+function retireRun(args, store, options) {
+    const usage = "Task run retire usage: yui task run retire <task>/<run> --reason <text>.";
+    const parsed = parseTail(args, new Set(["--reason"]), usage);
+    exactPositionals(parsed.positionals, 1, usage);
+    const reason = requiredOption(parsed.options, "--reason");
+    const reference = taskRecordReference(parsed.positionals[0], "agentRun", "Agent Run reference", options);
+    const now = clock(options);
+    const result = store.transaction((tx) => {
+        const task = requireTask(tx, reference.taskId);
+        assertTaskOpen(task);
+        const actor = taskActor(options, task.id);
+        if (actor === "leader") {
+            throw usageError("Only the user or global Operator may retire an Agent Run.");
+        }
+        let run = tx.getAgentRun(task.id, reference.localId);
+        if (run === null)
+            throw dataError(`Agent Run not found: ${task.id}/${reference.localId}.`);
+        const events = tx.listEvents(task.id);
+        if (isTaskRecordRetired(events, "agent-run", run.id)) {
+            return { task, run, changed: false };
+        }
+        if (run.status === "active") {
+            const terminal = terminalizeExactTaskRun(tx, {
+                taskId: task.id,
+                roleName: run.roleName,
+                agentId: run.effective.agentId,
+                runId: run.id,
+                receiptId: agentRunDeliveryReceiptId(run),
+                outcome: { status: "failed", summary: `Agent Run retired: ${reason}` }
+            }, now);
+            if (terminal.disposition !== "applied" || terminal.run === null) {
+                throw usageError(`Agent Run changed during retirement: ${run.id}/${terminal.reason ?? "obsolete"}.`);
+            }
+            run = terminal.run;
+        }
+        tx.saveEvent(task.id, createTaskRecordRetirement({
+            eventId: tx.nextEventId(task.id),
+            taskId: task.id,
+            recordKind: "agent-run",
+            recordId: run.id,
+            reason,
+            retiredBy: actor
+        }, now));
+        return { task, run, changed: true };
+    });
+    if (result.changed)
+        options.runtime?.notifyStateChanged(result.task.id);
+    return output(`Retired Agent Run ${result.task.id}/${result.run.id}\n`, {
+        agentRun: result.run,
+        retired: true
+    });
+}
 function runContextCommand(args, store, options) {
     const [first, ...rest] = args;
     if (first === "expand") {
@@ -3878,6 +3995,7 @@ function listRuns(args, store, options) {
     const runs = store.listAgentRuns(item.taskId).filter((run) => run.workItemId === item.id);
     if (runs.length === 0)
         return "No runs found.\n";
+    const events = store.listEvents(item.taskId);
     return `${renderTable(`Runs: ${item.id}`, [
         { header: "Run", minWidth: 6, maxWidth: 20 },
         { header: "Role", minWidth: 4, maxWidth: 22 },
@@ -3887,6 +4005,7 @@ function listRuns(args, store, options) {
         { header: "Profile", minWidth: 7, maxWidth: 8 },
         { header: "Permission", minWidth: 8, maxWidth: 16 },
         { header: "Status", minWidth: 6, maxWidth: 12 },
+        { header: "History", minWidth: 7, maxWidth: 9 },
         { header: "Summary", minWidth: 8, maxWidth: 58 }
     ], runs.map((run) => [
         run.id,
@@ -3897,6 +4016,7 @@ function listRuns(args, store, options) {
         run.effective.profileAccess,
         run.effective.permission.strategy,
         run.status,
+        isTaskRecordRetired(events, "agent-run", run.id) ? "retired" : "active",
         run.summary ?? "-"
     ]), defaultTableWidth())}\n`;
 }
@@ -4907,14 +5027,21 @@ function showRun(args, store, options) {
         const facts = readRunRecoveryFacts(tx, run.taskId, run.id);
         if (facts === null)
             throw usageError(`Agent Run not found: ${run.taskId}/${run.id}.`, usage);
-        return { run, recovery: projectRunRecovery(facts) };
+        const retirement = tx.listEvents(run.taskId)
+            .map(taskRecordRetirement)
+            .find((entry) => entry?.recordKind === "agent-run" && entry.recordId === run.id) ?? null;
+        return { run, recovery: projectRunRecovery(facts), retirement };
     });
     if (asJson) {
         return { kind: "output", output: `${JSON.stringify(data, null, 2)}\n`, data };
     }
-    return { kind: "output", output: renderRunShow(data.run, data.recovery), data };
+    return {
+        kind: "output",
+        output: renderRunShow(data.run, data.recovery, data.retirement),
+        data
+    };
 }
-function renderRunShow(run, recovery) {
+function renderRunShow(run, recovery, retirement) {
     const lines = [
         `Run: ${run.id}`,
         `Task: ${run.taskId}`,
@@ -4922,6 +5049,10 @@ function renderRunShow(run, recovery) {
         `Purpose: ${run.purpose}`,
         `Mode: ${run.mode}`,
         `Status: ${run.status}`,
+        ...(retirement === null ? [] : [
+            `History: retired by ${retirement.retiredBy}`,
+            `Retirement reason: ${retirement.reason}`
+        ]),
         `Effective: ${run.effective.agentId}/${run.effective.adapterId} r${run.effective.sourceDesiredRevision}`,
         `Created: ${run.createdAt}`,
         ...(run.pushedAt === undefined ? [] : [`Pushed: ${run.pushedAt}`]),
@@ -6065,7 +6196,8 @@ function taskRecordReference(value, kind, label, options) {
 function assertWorkItemDependenciesCompleted(store, item) {
     for (const dependencyId of item.dependsOn) {
         const dependency = store.getWorkItem(item.taskId, dependencyId);
-        if (dependency === null || dependency.status !== "completed") {
+        if (dependency === null
+            || (dependency.status !== "completed" && dependency.status !== "retired")) {
             throw usageError(`Work Item dependency is not completed: ${dependencyId}.`);
         }
     }

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 },