@zq-silk/yui 0.8.3 → 0.8.7

package/dist/commands/taskCompletionGate.js

@@ -2,13 +2,16 @@ import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { taskDeliveryPath } from "../task/task.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
+import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any
  * durable state. The explicit Publication must be the current verified merged
- * record, bind the exact reviewed physical Task head, and name an
- * ancestry-divergent commit with the exact same Git tree.
+ * record, bind the exact physical Task head (and, for integrated delivery, its
+ * completed final Review), and name an ancestry-divergent commit with the
+ * exact same Git tree.
  */
 export async function verifyTaskCompletionPublishedTree(taskId, publicationId, store, options = {}) {
     const task = store.getTask(taskId);
@@ -27,10 +30,11 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         throw usageError(`Publication ${publication.id} must record exact local and remote commits.`);
     }
     const workspace = requireTaskWorkspace(store, task);
-    const latestReview = latestTaskFinalReview(store, task.id);
-    if (latestReview === undefined
-        || latestReview.status !== "completed"
-        || latestReview.taskCandidate === undefined) {
+    const integrated = taskDeliveryPath(task) === "integrated";
+    const latestReview = integrated ? latestTaskFinalReview(store, task.id) : undefined;
+    if (integrated && (latestReview === undefined
+        || !isSemanticReviewRound(latestReview, store)
+        || latestReview.taskCandidate === undefined)) {
         throw usageError(`Task ${task.id} requires a latest completed Task-final Review before accepting a published tree.`);
     }
     const git = options.git ?? new NodeGitWorkspace();
@@ -40,18 +44,21 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         if (entry === undefined || entry.access !== "write") {
             throw usageError(`Task ${task.id} has no writable managed main workspace for Project ${taskBinding.projectId}.`);
         }
-        const reviewedCommit = latestReview.taskCandidate.projects.find(({ projectId }) => (projectId === taskBinding.projectId))?.commit;
-        if (reviewedCommit === undefined) {
-            throw usageError(`Task-final Review ${latestReview.id} omitted Project ${taskBinding.projectId}.`);
-        }
         const actualCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        if (actualCommit !== reviewedCommit) {
-            throw usageError(`Task-final Review ${latestReview.id} does not match Task head `
-                + `${taskBinding.projectId}@${actualCommit}.`);
+        if (latestReview !== undefined) {
+            const reviewedCommit = latestReview.taskCandidate.projects.find(({ projectId }) => (projectId === taskBinding.projectId))?.commit;
+            if (reviewedCommit === undefined) {
+                throw usageError(`Task-final Review ${latestReview.id} omitted Project ${taskBinding.projectId}.`);
+            }
+            if (actualCommit !== reviewedCommit) {
+                throw usageError(`Task-final Review ${latestReview.id} does not match Task head `
+                    + `${taskBinding.projectId}@${actualCommit}.`);
+            }
         }
         actualHeads.set(taskBinding.projectId, actualCommit);
     }
-    if (actualHeads.size !== latestReview.taskCandidate.projects.length) {
+    if (latestReview !== undefined
+        && actualHeads.size !== latestReview.taskCandidate.projects.length) {
         throw usageError(`Task-final Review ${latestReview.id} Project set does not match Task ${task.id}.`);
     }
     const entry = workspaceProjectEntry(workspace, publication.projectId);
@@ -94,7 +101,7 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         taskId: task.id,
         projectId: publication.projectId,
         publicationId: publication.id,
-        reviewRoundId: latestReview.id,
+        ...(latestReview === undefined ? {} : { reviewRoundId: latestReview.id }),
         localCommit,
         remoteCommit,
         tree: localTree
@@ -115,13 +122,18 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
         || publication.remoteCommit !== proof.remoteCommit) {
         throw usageError(`Publication evidence changed before Task completion: ${publication.id}.`);
     }
-    const latestReview = latestTaskFinalReview(store, task.id);
-    if (latestReview === undefined
-        || latestReview.id !== proof.reviewRoundId
-        || latestReview.status !== "completed"
-        || latestReview.taskCandidate === undefined
-        || !sameTaskCandidate(latestReview.taskCandidate, actualCandidate)) {
-        throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
+    if (taskDeliveryPath(task) === "integrated") {
+        const latestReview = latestTaskFinalReview(store, task.id);
+        if (latestReview === undefined
+            || latestReview.id !== proof.reviewRoundId
+            || !isSemanticReviewRound(latestReview, store)
+            || latestReview.taskCandidate === undefined
+            || !sameTaskCandidate(latestReview.taskCandidate, actualCandidate)) {
+            throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
+        }
+    }
+    else if (proof.reviewRoundId !== undefined) {
+        throw usageError(`Direct published-tree proof unexpectedly binds a final Review: ${task.id}.`);
     }
     const actualCommit = actualCandidate.projects.find(({ projectId }) => (projectId === proof.projectId))?.commit;
     if (actualCommit !== proof.localCommit) {
@@ -321,7 +333,7 @@ async function hasCompletedTaskFinalReviewForCurrentCandidate(store, task, works
         .filter((round) => (round.scope ?? "work-item") === "task")
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
     const latest = rounds.at(-1);
-    if (latest === undefined || latest.status !== "completed")
+    if (latest === undefined || !isSemanticReviewRound(latest, store))
         return false;
     if (latest.taskCandidate === undefined)
         return false;
@@ -354,7 +366,7 @@ function latestCommittedIntegration(store, taskId, projectId) {
 function hasFrozenTaskBaseline(store, taskId, projectId, currentCommit) {
     return store.listReviewRounds(taskId)
         .some((round) => ((round.scope ?? "work-item") === "task"
-        && round.status === "completed"
+        && isSemanticReviewRound(round, store)
         && round.taskCandidate !== undefined
         && round.taskCandidate.projects.some((entry) => (entry.projectId === projectId && entry.commit === currentCommit))));
 }

package/dist/commands/taskContextCommand.js

@@ -4,9 +4,11 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
+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;
@@ -40,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));
@@ -51,6 +54,7 @@ export function runTaskContextCommand(args, store) {
         }
         return {
             task,
+            deliveryPath: taskDeliveryPath(task),
             execution,
             reviewConfig: reader.getReviewConfig(),
             brief: reader.getTaskBrief(task.id),
@@ -68,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)
         };
     });
@@ -137,9 +141,12 @@ export function runTaskContextCommand(args, store) {
         ...(managedWorkspaces.length === 0
             ? ["  None."]
             : managedWorkspaces.map((workspace) => (`  ${managedWorkspaceLabel(workspace)}: ${workspace.root} (${workspace.entries.filter(({ access }) => access === "write").length} writable / ${workspace.entries.length} Projects)`))),
+        `Delivery: ${taskDeliveryPath(task)}`,
         `Completion evidence: ${task.requireIntegration
             ? "WorkItem, ChangeSet, and committed Integration required"
-            : "delivery integration not required"}`,
+            : task.projectBindings.length > 0
+                ? "clean committed Task main required"
+                : "no Project evidence required"}`,
         `Global review: ${reviewConfig === null
             ? "disabled"
             : `${reviewConfig.roleName} (${reviewConfig.trigger})`}`,

package/dist/commands/taskInputCommands.js

@@ -8,6 +8,8 @@ import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
+import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { isLinuxProcessLive, listOwnedProcessTree } from "../runtime/sessionOwnerIdentity.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const LEADER_ROLE = "leader";
 export function runTaskInputCommand(args, store, options) {
@@ -270,16 +272,33 @@ export function isCurrentGlobalOperator(store, environment) {
     const role = store.getGlobalRole("operator");
     if (role === null)
         return false;
-    const sessions = store.getGlobalRoleSessionSet(role.name);
-    const session = activeLiveRoleAgentSession(sessions);
-    if (sessions === null || session === null || sessions.activeAgentId !== role.activeAgentId) {
-        return false;
-    }
     const agentId = exactIdentity(environment.YUI_AGENT_ID);
     const adapterId = exactIdentity(environment.YUI_ADAPTER_ID);
     const launchId = exactIdentity(environment.YUI_LAUNCH_ID);
     const nativeSessionId = exactIdentity(environment.YUI_NATIVE_SESSION_ID);
     const binding = role.agentBindings[role.activeAgentId];
+    if (agentId === undefined
+        || adapterId === undefined
+        || launchId === undefined
+        || binding === undefined
+        || binding.agentId !== agentId
+        || binding.adapterId !== adapterId)
+        return false;
+    const sessions = store.getGlobalRoleSessionSet(role.name);
+    const session = activeLiveRoleAgentSession(sessions);
+    if (sessions === null || session === null || sessions.activeAgentId !== role.activeAgentId) {
+        // Codex learns its native Session ID only after the first Turn. During
+        // that narrow bootstrap window, authenticate against the durable launch
+        // reservation and its strongly attributed live process owner instead.
+        return nativeSessionId === undefined
+            && binding.adapterId === "codex"
+            && currentProcessBelongsToReservedGlobalLaunch(store, {
+                roleName: role.name,
+                agentId,
+                adapterId,
+                launchId
+            });
+    }
     // A fresh Codex launch discovers its native Session asynchronously. Its
     // launch envelope therefore cannot carry YUI_NATIVE_SESSION_ID, but the
     // durable Session still binds that provider identity to the exact launch
@@ -292,11 +311,7 @@ export function isCurrentGlobalOperator(store, environment) {
             && session.adapterId === "codex"
             && session.launchId !== undefined
             && session.launchId === launchId));
-    return agentId !== undefined
-        && adapterId !== undefined
-        && launchId !== undefined
-        && binding !== undefined
-        && binding.agentId === session.agentId
+    return binding.agentId === session.agentId
         && binding.adapterId === session.adapterId
         && session.agentId === agentId
         && session.adapterId === adapterId
@@ -304,6 +319,29 @@ export function isCurrentGlobalOperator(store, environment) {
         && session.launchId === launchId
         && nativeSessionMatches;
 }
+function currentProcessBelongsToReservedGlobalLaunch(store, input) {
+    if (store.getSessionOwner === undefined || store.getWorkMailbox === undefined)
+        return false;
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
+        scope: "global",
+        roleName: input.roleName
+    }));
+    if (!isRuntimeLaunchReservation(mailbox?.processing, input.launchId)
+        || hasRuntimeCleanupObligation(mailbox))
+        return false;
+    const owner = store.getSessionOwner(input.launchId);
+    if (owner === null
+        || owner.owner.scope !== "global"
+        || owner.owner.roleName !== input.roleName
+        || owner.agentId !== input.agentId
+        || owner.adapterId !== input.adapterId
+        || owner.launchId !== input.launchId
+        || owner.providerRoot.attribution !== "launch-env"
+        || !isLinuxProcessLive(owner.providerRoot.pid, owner.providerRoot.startIdentity)) {
+        return false;
+    }
+    return listOwnedProcessTree(owner.providerRoot.pid, owner.providerRoot.processGroupId).some(({ pid }) => pid === process.pid);
+}
 function inputAnswerer(environment) {
     const env = environment ?? {};
     if (env.YUI_SESSION_SCOPE === undefined && env.YUI_ROLE === undefined)

package/dist/commands/taskNextActionCommand.js

@@ -2,6 +2,9 @@ import { taskNotFound, usageError } from "../errors/cliError.js";
 import { projectNextAction } from "../task/nextAction.js";
 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
@@ -55,7 +58,30 @@ export function runTaskNextActionCommand(args, store) {
                 throw taskNotFound(taskId);
             completionReadiness = projectCompletionReadiness(readinessFacts);
         }
-        return { action, repairWave, completionReadiness, knowledgeProposals };
+        const events = reader.listEvents(taskId);
+        const orchestration = projectTaskOrchestration({
+            task: reader.getTask(taskId),
+            runs: operationalTaskRecords(reader.listAgentRuns(taskId), events, "agent-run"),
+            roleSessionSets: reader.listRoleSessionSets(taskId),
+            workItems: reader.listWorkItems(taskId),
+            changeSets: reader.listChangeSets(taskId),
+            reviewRounds: reader.listReviewRounds(taskId),
+            reviewFindings: reader.listReviewFindings(taskId),
+            integrations: reader.listIntegrationAttempts(taskId),
+            durableJobs: reader.listDurableJobs(taskId),
+            publications: reader.listPublicationReferences(taskId),
+            decisions: reader.listDecisions(taskId),
+            events,
+            managedWorkspaces: reader.listManagedWorkspaces(taskId)
+        });
+        return {
+            deliveryPath: taskDeliveryPath(facts.task),
+            action,
+            repairWave,
+            completionReadiness,
+            knowledgeProposals,
+            orchestration
+        };
     });
     if (asJson) {
         return {
@@ -66,7 +92,7 @@ export function runTaskNextActionCommand(args, store) {
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.repairWave, data.completionReadiness, data.knowledgeProposals),
+        output: renderNextAction(data.action, data.deliveryPath, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
         data
     };
 }
@@ -84,9 +110,10 @@ function repairWaveFor(action, facts) {
         return null;
     return planRepairWave(round.id, findings);
 }
-function renderNextAction(action, repairWave, completionReadiness, knowledgeProposals) {
+function renderNextAction(action, deliveryPath, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
     const lines = [
         `Task: ${action.taskId}`,
+        `Delivery: ${deliveryPath}`,
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         ...(action.refs.length === 0
@@ -131,6 +158,10 @@ function renderNextAction(action, repairWave, completionReadiness, knowledgeProp
             lines.push(`Completion readiness: ${completionReadiness.blockers.length} blocker(s)`, ...completionReadiness.blockers.map((blocker) => `  ${blocker.code} (${blocker.ref.kind} ${blocker.ref.id}): ${blocker.reason}`
                 + ` — fix: ${blocker.fix}`));
         }
+        if (completionReadiness.advisories.length > 0) {
+            lines.push(`Completion advisories (non-blocking): ${completionReadiness.advisories.length}`, ...completionReadiness.advisories.map((advisory) => `  ${advisory.code} (${advisory.ref.kind} ${advisory.ref.id}): ${advisory.reason}`
+                + ` — fix before archive: ${advisory.fix}`));
+        }
     }
     if (repairWave !== null) {
         lines.push(`Repair wave (${repairWave.openFindingCount} open finding(s), ${repairWave.groups.length} group(s)):`, ...repairWave.groups.map((group) => `  ${group.id}: findings ${group.findingIds.join(", ")}`
@@ -141,5 +172,9 @@ function renderNextAction(action, repairWave, completionReadiness, knowledgeProp
         lines.push(`Knowledge proposals (non-blocking): ${knowledgeProposals.length} pending`, ...knowledgeProposals.map((proposal) => `  ${proposal.projectId}/${proposal.proposalId}: ${proposal.title}`
             + ` — review: yui project knowledge proposals list ${proposal.projectId}`));
     }
+    if (orchestrationAdvisories.length > 0) {
+        lines.push(`Orchestration advisories (non-blocking): ${orchestrationAdvisories.length}`, ...orchestrationAdvisories.map((advisory) => `  ${advisory.code}: ${advisory.reason}`
+            + (advisory.refs.length === 0 ? "" : ` — refs ${advisory.refs.join(", ")}`)));
+    }
     return `${lines.join("\n")}\n`;
 }

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,20 +1,93 @@
 import { createHash } from "node:crypto";
-import { chmodSync } 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);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(source, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Session Manifest is unreadable: ${source}.`, { cause: error });
+    }
+    if (parsed === null || typeof parsed !== "object") {
+        throw new Error("Session Manifest is invalid.");
+    }
+    const record = parsed;
+    const claimedDigest = requireDigest(record.digest, "Session Manifest digest");
+    const { digest: _digest, ...body } = record;
+    if (digest(body) !== claimedDigest) {
+        throw new Error("Session Manifest digest does not match its immutable content.");
+    }
+    if (record.schemaVersion !== SESSION_BOOTSTRAP_MANIFEST_SCHEMA_VERSION
+        || record.protocol !== SESSION_CONTEXT_PROTOCOL
+        || record.owner === null
+        || typeof record.owner !== "object"
+        || (record.owner.scope !== "global"
+            && record.owner.scope !== "task")
+        || typeof record.effectiveRevision !== "number"
+        || !Number.isSafeInteger(record.effectiveRevision)
+        || record.effectiveRevision < 1
+        || (record.roleKind !== "operator"
+            && record.roleKind !== "global"
+            && record.roleKind !== "leader"
+            && record.roleKind !== "worker"
+            && record.roleKind !== "reviewer")
+        || record.controlPlane === null
+        || typeof record.controlPlane !== "object"
+        || !Array.isArray(record.skills)
+        || record.roleProfileRef === null
+        || typeof record.roleProfileRef !== "object"
+        || record.contextProtocol === null
+        || typeof record.contextProtocol !== "object") {
+        throw new Error("Session Manifest shape is invalid.");
+    }
+    const owner = record.owner;
+    if (owner.scope === "task" && typeof owner.taskId !== "string") {
+        throw new Error("Task Session Manifest owner is invalid.");
+    }
+    const control = record.controlPlane;
+    requireText(control.descriptorPath, "Session Manifest control descriptor path");
+    requireText(control.sessionCliPath, "Session Manifest CLI path");
+    requireDigest(control.digest, "Session Manifest control-plane digest");
+    for (const skill of record.skills) {
+        if (skill === null || typeof skill !== "object") {
+            throw new Error("Session Manifest Skill entry is invalid.");
+        }
+        const entry = skill;
+        requireText(entry.id, "Session Manifest Skill id");
+        requireText(entry.path, "Session Manifest Skill path");
+        requireDigest(entry.digest, "Session Manifest Skill digest");
+    }
+    const profile = record.roleProfileRef;
+    requireDigest(profile.digest, "Session Manifest Role Profile digest");
+    requireText(profile.path, "Session Manifest Role Profile path");
+    const protocol = record.contextProtocol;
+    requireText(protocol.loadCommand, "Session Manifest Context load command");
+    if (protocol.expandCommand !== undefined) {
+        requireText(protocol.expandCommand, "Session Manifest Context expand command");
+    }
+    return Object.freeze(parsed);
+}
 export function materializeSessionBootstrap(input) {
     const home = resolve(input.yuiHome);
     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);
@@ -53,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) });
@@ -71,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);
@@ -79,3 +214,15 @@ function digest(value) {
     const bytes = typeof value === "string" ? value : JSON.stringify(value);
     return createHash("sha256").update(bytes).digest("hex");
 }
+function requireDigest(value, label) {
+    if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}

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 = [