@zq-silk/yui 0.15.7 → 0.15.8

package/dist/message/messageContinuation.js

@@ -0,0 +1,204 @@
+import { isDeepStrictEqual } from "node:util";
+import { createRun, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { createRunInput } from "../context/runInputContract.js";
+import { contextContentDigest, contextSnapshotRef, createContextSnapshot } from "../context/contextSnapshot.js";
+import { roleSessionMayContinue } from "../executor/effectiveLaunch.js";
+import { enqueueRoleRunDispatch } from "../coordination/workMailboxQueue.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalization.js";
+import { sourceRunContextValue } from "../context/sourceRunContext.js";
+import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
+export function resolveMessageRecipient(store, taskId, roleName, scope) {
+    if (scope.reviewRoundId !== undefined) {
+        const round = store.getReviewRound(taskId, scope.reviewRoundId);
+        if (round === null)
+            throw new Error("ReviewRound is unavailable in this Task.");
+        if (scope.workItemId !== undefined && scope.workItemId !== round.workItemId)
+            throw new Error("ReviewRound WorkItem scope mismatch.");
+        scope = { reviewRoundId: scope.reviewRoundId, ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }) };
+    }
+    if (scope.workItemId === undefined && scope.reviewRoundId === undefined) {
+        throw new Error("Recipient requires --work-item or --review-round; Message does not establish an Assignment.");
+    }
+    const previous = store.listRuns(taskId).filter((run) => run.roleName === roleName && run.workItemId === scope.workItemId
+        && run.reviewRoundId === scope.reviewRoundId).at(-1);
+    if (previous === undefined)
+        throw new Error("No existing Dispatch owns this Role and work scope.");
+    return { roleName, ownerRunId: previous.id, ...scope };
+}
+/** Bounded diagnosis, not automatic ownership repair. */
+export function messageContinuationBlocker(store, message) {
+    const target = message.recipient;
+    if (target?.ownerRunId === undefined)
+        return "recipient-assignment-missing";
+    const task = store.getTask(message.taskId);
+    if (task?.status !== "active")
+        return `task-${task?.status ?? "missing"}`;
+    if (task.executionGate.state !== "enabled")
+        return "execution-disabled";
+    const owner = store.getRun(message.taskId, target.ownerRunId);
+    if (owner === null || owner.roleName !== target.roleName || owner.workItemId !== target.workItemId
+        || owner.reviewRoundId !== target.reviewRoundId)
+        return "owner-assignment-mismatch";
+    if (owner.result?.failureReason === "delivery-unknown")
+        return "owner-acceptance-unknown";
+    if (owner.executionGroupId !== undefined || owner.sourceExecutionGroupId !== undefined) {
+        return "replicated-assignment-requires-explicit-dispatch";
+    }
+    if (target.workItemId !== undefined) {
+        const work = store.getWorkItem(message.taskId, target.workItemId);
+        if (work?.status !== "open")
+            return `work-item-${work?.status ?? "missing"}`;
+        if (target.reviewRoundId === undefined && work.assignee !== target.roleName)
+            return "owner-changed";
+        if (target.reviewRoundId === undefined && !isDeepStrictEqual([...work.writeProjectIds].sort(), [...owner.effective.writeProjectIds].sort()))
+            return "assignment-scope-changed";
+        if (target.reviewRoundId === undefined && owner.workspace !== undefined) {
+            const workspace = target.roleName === "leader"
+                ? store.getTaskWorkspace(message.taskId) : store.getWorkItemWorkspace(message.taskId, target.workItemId);
+            const identity = (entries) => entries.map((entry) => ({
+                projectId: entry.projectId, path: entry.path, access: entry.access, branch: entry.branch
+            }));
+            if (workspace?.root !== owner.workspace.root
+                || !isDeepStrictEqual(identity(workspace.entries), identity(owner.workspace.entries))) {
+                return "assignment-workspace-changed";
+            }
+        }
+        const ownershipAt = message.handovers?.at(-1)?.at ?? message.createdAt;
+        if (target.reviewRoundId === undefined && store.listEvents(message.taskId).some((event) => event.type === "work.edited" && event.payload.workItemId === target.workItemId
+            && event.payload.fields?.split(",").includes("assignee")
+            && event.createdAt > ownershipAt && event.payload.previous !== event.payload.current))
+            return "owner-changed";
+    }
+    const latest = store.listRuns(message.taskId).filter((run) => run.workItemId === owner.workItemId && run.reviewRoundId === owner.reviewRoundId
+        && run.roleName === owner.roleName).at(-1);
+    if (latest !== undefined && latest.id !== owner.id
+        && latest.inputs[0]?.input.source.channel !== "message-continuation")
+        return "assignment-changed";
+    if (target.reviewRoundId !== undefined) {
+        const round = store.getReviewRound(message.taskId, target.reviewRoundId);
+        if (round === null)
+            return "review-round-missing";
+        if ((round.scope ?? "work-item") === "task") {
+            if (round.taskCandidate?.projects.some((project) => task.projectBindings.find((binding) => binding.projectId === project.projectId)?.currentCommit !== project.commit)) {
+                return "review-candidate-stale";
+            }
+        }
+        else {
+            const item = store.getWorkItem(message.taskId, round.workItemId);
+            if (item?.candidates.at(-1)?.id !== round.candidateId)
+                return "review-candidate-stale";
+        }
+        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
+        if (validation.disposition !== "applied")
+            return validation.reason ?? "review-candidate-stale";
+    }
+    return undefined;
+}
+/** Called in the Controller's ordinary reconciliation transaction. Messages
+ * remain the pending authority; Mailbox is only the existing scheduling hint.
+ * Reserving inputs and creating the next Run is one atomic effect. */
+export function prepareMessageContinuations(store, taskId, now, roleName) {
+    const pending = store.listMessages(taskId).filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+        && message.continuation?.runId === undefined);
+    for (const message of pending) {
+        const recipient = message.recipient;
+        const blocker = messageContinuationBlocker(store, message);
+        if (blocker !== undefined) {
+            markNotDelivered(store, message, blocker);
+            continue;
+        }
+        if (store.getActiveRun(taskId, recipient.roleName) !== null)
+            continue;
+        const owner = store.getRun(taskId, recipient.ownerRunId);
+        const sessions = store.getTaskRoleSessionSet(taskId, recipient.roleName);
+        const session = sessions?.sessions[owner.effective.agentId];
+        const provider = sessions?.providerBinding;
+        if (provider?.authority.owner === "human" || provider?.authority.owner === "unknown"
+            || (provider?.run !== null && provider?.run !== undefined
+                && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status)))
+            continue;
+        if (session?.status !== "active" || sessions?.activeAgentId !== owner.effective.agentId
+            || store.getRole(taskId, recipient.roleName)?.activeAgentId !== owner.effective.agentId
+            || !roleSessionMayContinue(session.effective, owner.effective)) {
+            markNotDelivered(store, message, "compatible-session-unavailable");
+            continue;
+        }
+        // Reuse the same current-Session authority gate as Task-local actions.
+        // Matching Agent/effective flags alone do not undo explicit revocation.
+        requireManagedTaskCaller(store, {
+            YUI_SESSION_SCOPE: "task", YUI_TASK_ID: taskId, YUI_ROLE: recipient.roleName,
+            YUI_NATIVE_SESSION_ID: session.nativeSessionId, YUI_WORKSPACE: owner.effective.workspace.root
+        });
+        const originalNativeSessionId = store.listEvents(taskId).filter((event) => event.type === "run.session-prepared"
+            && event.payload.runId === owner.id && event.payload.roleName === owner.roleName)
+            .at(-1)?.payload.nativeSessionId ?? owner.result?.provider?.conversationId;
+        if (originalNativeSessionId === undefined || originalNativeSessionId !== session.nativeSessionId) {
+            markNotDelivered(store, message, originalNativeSessionId === undefined
+                ? "owner-session-unobserved" : "owner-session-changed");
+            continue;
+        }
+        const batch = pending.filter((entry) => isDeepStrictEqual(entry.recipient, recipient)
+            && messageContinuationBlocker(store, entry) === undefined).slice(0, 16);
+        const previous = store.listRuns(taskId).filter((run) => run.roleName === owner.roleName
+            && run.workItemId === owner.workItemId && run.reviewRoundId === owner.reviewRoundId).at(-1);
+        const baselineRef = previous.inputs[0]?.input.contextSnapshotRef;
+        const baseline = baselineRef === undefined ? null : store.getContextSnapshot(taskId, baselineRef.id);
+        if (baseline === null || baseline.digest !== baselineRef.digest) {
+            markNotDelivered(store, message, "assignment-context-unavailable");
+            continue;
+        }
+        const runId = store.nextRunId(taskId);
+        const round = owner.reviewRoundId === undefined ? null : store.getReviewRound(taskId, owner.reviewRoundId);
+        const continuingRound = round === null ? null : (() => {
+            const { endedAt: _endedAt, failure: _failure, ...current } = round;
+            return { ...current, status: "running", reviewerRunId: runId };
+        })();
+        const priorMessages = baseline.resources.filter((entry) => entry.ref.store === "task-message").slice(-16);
+        const source = sourceRunContextValue(previous);
+        const resources = [...baseline.resources.filter((entry) => entry.ref.store !== "task-message" && entry.ref.store !== "source-run"
+                && !(continuingRound !== null && entry.ref.store === "review-round" && entry.ref.refId === continuingRound.id)),
+            ...(continuingRound === null ? [] : [{ ref: { layer: "L3", store: "review-round",
+                        refId: continuingRound.id, revision: now.toISOString(), digest: contextContentDigest(continuingRound),
+                        summary: `ReviewRound ${continuingRound.id}` }, value: continuingRound }]),
+            ...priorMessages,
+            { ref: { layer: "L4", store: "source-run", refId: previous.id,
+                    revision: previous.updatedAt, digest: contextContentDigest(source), summary: `Previous result ${previous.id}` }, value: source },
+            ...batch.map((entry) => ({
+                ref: { layer: "L4", store: "task-message", refId: entry.id,
+                    revision: entry.createdAt, digest: contextContentDigest(entry), summary: `Message ${entry.id}` },
+                value: entry
+            }))];
+        const latestSnapshot = store.listContextSnapshots(taskId).filter((entry) => entry.scope === baseline.scope && entry.scopeRef === baseline.scopeRef).at(-1);
+        const snapshot = createContextSnapshot({
+            ...baseline, id: store.nextContextSnapshotId(taskId),
+            sequence: (latestSnapshot?.sequence ?? baseline.sequence) + 1,
+            parentRef: contextSnapshotRef(baseline), frozenAt: now, frozenBy: "controller",
+            resources, refs: resources.map(({ ref }) => ref)
+        });
+        store.saveContextSnapshot(snapshot);
+        const run = withRunContextSnapshot(createRun(runId, taskId, recipient.roleName, "resume", createRunInput({ source: { type: "yui", channel: "message-continuation" },
+            directive: `Continue the same Assignment in its existing workspace. Read Messages ${batch.map((m) => m.id).join(", ")} from this exact Context. Message receipt is not implementation or acceptance.`,
+            deltaRefIds: batch.map((entry) => entry.id) }), now, copyAssignment(owner)), contextSnapshotRef(snapshot), batch.map((entry) => entry.id));
+        store.saveRun(run);
+        store.saveActiveRun(run);
+        if (continuingRound !== null)
+            store.saveReviewRound(taskId, continuingRound);
+        for (const entry of batch)
+            store.updateMessage(taskId, { ...entry, continuation: { runId } });
+        enqueueRoleRunDispatch(store, { taskId, roleName: run.roleName, runId,
+            reason: "message-continuation", occurredAt: now });
+        store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "message.continuation", { runId, roleName: run.roleName, messageIds: batch.map((entry) => entry.id).join(",") }, now));
+    }
+}
+function copyAssignment(run) {
+    return { purpose: run.purpose, effective: run.effective,
+        ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+        ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId }),
+        ...(run.workspace === undefined ? {} : { workspace: run.workspace }) };
+}
+function markNotDelivered(store, message, reason) {
+    if (message.continuation?.notDeliveredReason === reason)
+        return;
+    store.updateMessage(message.taskId, { ...message, continuation: { notDeliveredReason: reason } });
+}

package/dist/observability/executionAudit.js

@@ -2,7 +2,7 @@
  * Read-only execution audit aggregator (Issue 11 §3).
  *
  * The audit answers "what happened in this Home" from durable records alone:
- * Turns/failures/durations, wake reasons, Runtime generations, Review execution
+ * AgentRuns/failures/durations, wake reasons, Runtime count, Review execution
  * vs semantic failures, Integration failure classes and gate reuse, telemetry
  * volume, and the longest/stale executions. It never writes Task state, never
  * wakes a Leader, and never takes the storage write lock — it only calls the
@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { classifyTurnFailure, classifyIntegrationAttempt, classifyReviewRound, countFaultClasses } from "./faultClassification.js";
+import { classifyRunFailure, classifyIntegrationAttempt, classifyReviewRound, countFaultClasses } from "./faultClassification.js";
 import { RUNTIME_LAUNCH_KINDS, RUNTIME_LAUNCH_PHASES } from "../runtime/launchDiagnostics.js";
 import { UNSUPPORTED } from "./runtimeIdentity.js";
 import { projectTaskOrchestration } from "./orchestrationMetrics.js";
@@ -86,10 +86,10 @@ function roleBucket(roleName) {
     }
     return "other";
 }
-function durationMs(turn) {
-    if (turn.result === undefined)
+function durationMs(run) {
+    if (run.result === undefined)
         return 0;
-    return Math.max(0, Date.parse(turn.result.completedAt) - Date.parse(turn.createdAt));
+    return Math.max(0, Date.parse(run.result.completedAt) - Date.parse(run.createdAt));
 }
 function emptyLaunchFailureCounts() {
     const counts = {
@@ -116,35 +116,35 @@ function addLaunchFailureCounts(counts, summary) {
 }
 /**
  * Issue 09: classify a terminal Session (stopped/broken) by its relationship
- * to the last Turn it carried. Turns and Sessions are separate axes: a Session
- * that stops after its Turn completed is a post-completion stop, not a Turn
+ * to the last AgentRun it carried. AgentRuns and Sessions are separate axes: a Session
+ * that stops after its AgentRun completed is a post-completion stop, not a AgentRun
  * failure. Correlation is by Role + Agent + Adapter (the durable identity a
- * Turn and its Session share) and the Session's terminal update timestamp.
+ * AgentRun and its Session share) and the Session's terminal update timestamp.
  */
-function classifyTerminalSessionTurnRelation(turns, roleName, session, counts) {
+function classifyTerminalSessionRunRelation(runs, roleName, session, counts) {
     const terminalAt = Date.parse(session.updatedAt);
-    const carried = turns
-        .filter((turn) => (turn.roleName === roleName
-        && turn.effective.agentId === session.agentId
-        && turn.effective.adapterId === session.adapterId
-        && Date.parse(turn.createdAt) <= terminalAt))
+    const carried = runs
+        .filter((run) => (run.roleName === roleName
+        && run.effective.agentId === session.agentId
+        && run.effective.adapterId === session.adapterId
+        && Date.parse(run.createdAt) <= terminalAt))
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
-    const lastTurn = carried[0];
-    if (lastTurn === undefined) {
-        counts.noTurn += 1;
+    const lastRun = carried[0];
+    if (lastRun === undefined) {
+        counts.noRun += 1;
         return;
     }
-    if (lastTurn.status === "completed"
-        && lastTurn.result !== undefined
-        && Date.parse(lastTurn.result.completedAt) <= terminalAt) {
-        counts.postTurnCompleted += 1;
+    if (lastRun.status === "completed"
+        && lastRun.result !== undefined
+        && Date.parse(lastRun.result.completedAt) <= terminalAt) {
+        counts.postRunCompleted += 1;
         return;
     }
-    if (lastTurn.status === "failed") {
-        counts.turnFailed += 1;
+    if (lastRun.status === "failed") {
+        counts.runFailed += 1;
         return;
     }
-    counts.activeTurn += 1;
+    counts.activeRun += 1;
 }
 function ok(data) {
     return { status: "ok", data };
@@ -182,7 +182,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             homeIdentity: UNSUPPORTED,
             scope,
             tasks: section,
-            turns: section,
+            runs: section,
             wakes: section,
             sessions: section,
             reviews: section,
@@ -228,7 +228,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
-    const turns = (() => {
+    const runs = (() => {
         try {
             let total = 0;
             let active = 0;
@@ -241,30 +241,30 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             const failures = [];
             const launchFailures = emptyLaunchFailureCounts();
             for (const taskId of taskIds) {
-                for (const turn of store.listTurns(taskId)) {
-                    if (!inWindow(turn.createdAt, options))
+                for (const run of store.listRuns(taskId)) {
+                    if (!inWindow(run.createdAt, options))
                         continue;
                     total += 1;
-                    byRole[roleBucket(turn.roleName)] += 1;
-                    if (turn.purpose === "review")
+                    byRole[roleBucket(run.roleName)] += 1;
+                    if (run.purpose === "review")
                         byPurpose.review += 1;
                     else
                         byPurpose.execution += 1;
-                    const duration = durationMs(turn);
-                    if (turn.status === "active") {
+                    const duration = durationMs(run);
+                    if (run.status === "active") {
                         active += 1;
-                        cumulativeDurationMs += Math.max(0, Date.now() - Date.parse(turn.createdAt));
+                        cumulativeDurationMs += Math.max(0, Date.now() - Date.parse(run.createdAt));
                     }
-                    else if (turn.status === "completed") {
+                    else if (run.status === "completed") {
                         completed += 1;
                         cumulativeDurationMs += duration;
                     }
-                    else if (turn.status === "failed") {
+                    else if (run.status === "failed") {
                         failedCount += 1;
                         failedDurationMs += duration;
                         cumulativeDurationMs += duration;
-                        addLaunchFailureCounts(launchFailures, turn.result?.diagnostic);
-                        failures.push(classifyTurnFailure(turn));
+                        addLaunchFailureCounts(launchFailures, run.result?.diagnostic);
+                        failures.push(classifyRunFailure(run));
                     }
                 }
             }
@@ -288,18 +288,18 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
     })();
     const wakes = (() => {
         try {
-            let leaderTurns = 0;
+            let leaderRuns = 0;
             let withWakeReasons = 0;
             let suppressedWakes = 0;
             const byReason = new Map();
             for (const taskId of taskIds) {
-                for (const turn of store.listTurns(taskId)) {
-                    if (turn.roleName !== "leader")
+                for (const run of store.listRuns(taskId)) {
+                    if (run.roleName !== "leader")
                         continue;
-                    if (!inWindow(turn.createdAt, options))
+                    if (!inWindow(run.createdAt, options))
                         continue;
-                    leaderTurns += 1;
-                    const match = WAKE_REASON_PATTERN.exec(turn.inputs[0].input.directive ?? "");
+                    leaderRuns += 1;
+                    const match = WAKE_REASON_PATTERN.exec(run.inputs[0].input.directive ?? "");
                     if (match === null)
                         continue;
                     withWakeReasons += 1;
@@ -317,12 +317,12 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 }
             }
             return ok({
-                leaderTurns,
+                leaderRuns,
                 withWakeReasons,
                 byReason: Object.fromEntries([...byReason.entries()].sort((left, right) => right[1] - left[1])),
                 // Scheduler single-flight suppression: wakes that were coalesced
                 // because the Role runtime lifecycle lane was busy. These are
-                // scheduler outcomes, never failed Turns.
+                // scheduler outcomes, never failed AgentRuns.
                 suppressedWakes: { status: "ok", data: suppressedWakes }
             });
         }
@@ -332,7 +332,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
     })();
     const sessions = (() => {
         try {
-            let generations = 0;
+            let count = 0;
             let broken = 0;
             let stopped = 0;
             let other = 0;
@@ -340,18 +340,18 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let conversationSwitches = 0;
             let lifecycleEvents = 0;
             let stopFailures = 0;
-            const terminalByTurnRelation = {
-                postTurnCompleted: 0,
-                turnFailed: 0,
-                activeTurn: 0,
-                noTurn: 0
+            const terminalByRunRelation = {
+                postRunCompleted: 0,
+                runFailed: 0,
+                activeRun: 0,
+                noRun: 0
             };
             for (const taskId of taskIds) {
-                const turns = store.listTurns(taskId);
+                const runs = store.listRuns(taskId);
                 for (const set of store.listRoleSessionSets(taskId)) {
                     const history = Array.isArray(set.history) ? set.history : [];
                     for (const session of [...history, ...Object.values(set.sessions)]) {
-                        generations += 1;
+                        count += 1;
                         if (session.status === "ended" && session.endReason === "failed")
                             broken += 1;
                         else if (session.status === "ended")
@@ -359,7 +359,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         else
                             other += 1;
                         if (session.status === "ended") {
-                            classifyTerminalSessionTurnRelation(turns, set.owner.roleName, session, terminalByTurnRelation);
+                            classifyTerminalSessionRunRelation(runs, set.owner.roleName, session, terminalByRunRelation);
                         }
                     }
                 }
@@ -379,7 +379,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 }
             }
             return ok({
-                generations,
+                count,
                 broken,
                 stopped,
                 other,
@@ -387,7 +387,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 conversationSwitches,
                 lifecycleEvents,
                 stopFailures,
-                terminalByTurnRelation
+                terminalByRunRelation
             });
         }
         catch (error) {
@@ -577,7 +577,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     entries.push({
                         taskId,
                         eventId: event.id,
-                        turnId: event.payload.turnId ?? "",
+                        runId: event.payload.runId ?? "",
                         roleName: event.payload.roleName ?? "",
                         source: event.payload.source ?? "unknown",
                         phase: event.payload.phase ?? "unknown",
@@ -591,8 +591,6 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                             registrationDisposition: event.payload.registrationDisposition,
                             errorName: event.payload.errorName,
                             causeName: event.payload.causeName,
-                            expectedRuntimeGenerationId: event.payload.expectedRuntimeGenerationId,
-                            observedRuntimeGenerationId: event.payload.observedRuntimeGenerationId,
                             attemptId: event.payload.attemptId
                         }),
                         createdAt: event.createdAt
@@ -619,7 +617,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     if (!inWindow(item.createdAt, options))
                         continue;
                     total += 1;
-                    if (item.status === "completed")
+                    if (item.status === "accepted")
                         completed += 1;
                     else if (item.status === "retired")
                         retired += 1;
@@ -639,7 +637,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     return [];
                 return [projectTaskOrchestration({
                         task,
-                        turns: withinWindow(store.listTurns(taskId), options),
+                        runs: withinWindow(store.listRuns(taskId), options),
                         roleSessionSets: sessionSetsWithinWindow(store.listRoleSessionSets(taskId), options),
                         workItems: withinWindow(store.listWorkItems(taskId), options),
                         changeSets: withinWindow(store.listChangeSets(taskId), options),
@@ -704,7 +702,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let processExitObservations = 0;
             let compactionEvents = 0;
             for (const taskId of taskIds) {
-                for (const run of store.listTurns(taskId)) {
+                for (const run of store.listRuns(taskId)) {
                     if (!inWindow(run.createdAt, options))
                         continue;
                     const version = String(run.effective.contextProtocolVersion);
@@ -756,21 +754,21 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         try {
             const entries = [];
             for (const taskId of taskIds) {
-                for (const turn of store.listTurns(taskId)) {
-                    if (!inWindow(turn.createdAt, options))
+                for (const run of store.listRuns(taskId)) {
+                    if (!inWindow(run.createdAt, options))
                         continue;
-                    const duration = turn.status === "active"
-                        ? Math.max(0, Date.now() - Date.parse(turn.createdAt))
-                        : durationMs(turn);
+                    const duration = run.status === "active"
+                        ? Math.max(0, Date.now() - Date.parse(run.createdAt))
+                        : durationMs(run);
                     if (duration <= 0)
                         continue;
                     entries.push({
                         taskId,
-                        turnId: turn.id,
-                        roleName: turn.roleName,
-                        status: turn.status,
+                        runId: run.id,
+                        roleName: run.roleName,
+                        status: run.status,
                         durationMs: duration,
-                        startedAt: turn.createdAt
+                        startedAt: run.createdAt
                     });
                 }
             }
@@ -788,7 +786,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         homeIdentity,
         scope,
         tasks,
-        turns,
+        runs,
         wakes,
         sessions,
         reviews,

package/dist/observability/faultClassification.js

@@ -20,8 +20,8 @@ function excerpt(text, max = 160) {
     const normalized = text.replace(/\s+/g, " ").trim();
     return normalized.length <= max ? normalized : `${normalized.slice(0, max)}…`;
 }
-/** Classify a failed Turn without inspecting Agent-authored output. */
-export function classifyTurnFailure(run) {
+/** Classify a failed AgentRun without inspecting Agent-authored output. */
+export function classifyRunFailure(run) {
     if (run.status !== "failed")
         return NO_FAULT;
     const failureReason = run.result?.failureReason;

package/dist/observability/orchestrationMetrics.js

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
-import { isCompletedReviewExecutionFromTurns } from "../review/reviewAcceptance.js";
+import { isCompletedReviewExecutionFromRuns } from "../review/reviewAcceptance.js";
 import { projectFirstProgressAdvisory } from "../runtime/firstProgressAdvisory.js";
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
@@ -48,10 +48,10 @@ export function projectTaskOrchestration(facts) {
         timeToFirstProjectCommitMs: firstCommitAt === undefined
             ? null
             : Math.max(0, Date.parse(firstCommitAt) - Date.parse(facts.task.createdAt)),
-        turns: {
-            total: facts.turns.length,
-            byStatus: counts(facts.turns.map(({ status }) => status)),
-            byRole: counts(facts.turns.map(({ roleName }) => roleName))
+        runs: {
+            total: facts.runs.length,
+            byStatus: counts(facts.runs.map(({ status }) => status)),
+            byRole: counts(facts.runs.map(({ roleName }) => roleName))
         },
         workItems: facts.workItems.length,
         reviews: {
@@ -65,7 +65,7 @@ export function projectTaskOrchestration(facts) {
             repeatedIdentities,
             evidenceReuses: facts.integrations.filter((attempt) => ((attempt.checks ?? []).some(({ details }) => details?.startsWith("Reused successful check evidence from ")))).length
         },
-        providerGenerationsBeforeFirstProgress: firstProgress.generationsBeforeFirstProgress,
+        providerSessionsBeforeFirstProgress: firstProgress.sessionsBeforeFirstProgress,
         publicationToCompletionMs: publicationAt === undefined || facts.task.completedAt === undefined
             ? null
             : Math.max(0, Date.parse(facts.task.completedAt) - Date.parse(publicationAt)),
@@ -91,7 +91,7 @@ function projectAdvisories(facts, fullRounds, repeatedIdentities, firstProgressA
                 .map(({ id }) => `durable-job:${id}`)
         });
     }
-    const completedFull = fullRounds.filter((round) => (isCompletedReviewExecutionFromTurns(round, facts.turns)))
+    const completedFull = fullRounds.filter((round) => (isCompletedReviewExecutionFromRuns(round, facts.runs)))
         .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
     const recent = completedFull.slice(-3);
     const sameCandidate = recent.length === 3
@@ -108,7 +108,7 @@ function projectAdvisories(facts, fullRounds, repeatedIdentities, firstProgressA
     if (firstProgressAttention) {
         result.push({
             code: "provider-first-progress-advisory",
-            reason: "Two fresh Leader generations produced no first durable progress; consider Operator attention before another generation.",
+            reason: "Two fresh Leader Sessions produced no first durable progress; consider Operator attention before another Session.",
             refs: [facts.task.id]
         });
     }

package/dist/operator/operatorSessionHistory.js

@@ -1,3 +1,4 @@
+import { agentAdapterLabel as adapterLabel } from "../agent/adapterCatalog.js";
 import { normalizeRoleAgentSessionText, roleAgentSessionRef, validateRoleSessionSet } from "../executor/agentExecutor.js";
 /** Separates the one selected writer authority from retained conversations. */
 export function projectOperatorStatus(sessions, activeAgentId, activeAdapterId) {
@@ -141,13 +142,6 @@ function optionalDisplayText(value) {
     const normalized = normalizeRoleAgentSessionText(value);
     return normalized.length === 0 ? undefined : normalized;
 }
-function adapterLabel(adapterId) {
-    return adapterId === "codex"
-        ? "Codex"
-        : adapterId === "claude"
-            ? "Claude"
-            : adapterId;
-}
 function requireText(value, label) {
     if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
         throw new Error(`${label} is required.`);

package/dist/output/agentConfigurationPresentation.js

@@ -1,4 +1,5 @@
 import { renderAgentConfigurationResolutionNotice } from "../cli/agentConfigurationPicker.js";
+import { agentHandshakeLine } from "./agentRunConfigurationPresentation.js";
 import { defaultTableWidth, renderTable } from "./table.js";
 export function renderAgentConfigurationCatalog(resolved) {
     const { catalog } = resolved;
@@ -11,13 +12,17 @@ export function renderAgentConfigurationCatalog(resolved) {
         model.serviceTiers?.map((tier) => tier.value).join(", ") || "none reported"
     ]);
     const fieldRows = catalog.fields
-        .filter((field) => field.key !== "model" && field.key !== "effort")
+        .filter((field) => modelRows.length === 0 || (field.key !== "model" && field.key !== "effort"))
         .map((field) => [
         field.key,
         field.choices.map((choice) => choice.value).join(", ") || "none reported",
+        // An available field can still carry a reason, and for ACP it always does:
+        // the values are enumerated per Session, so the probe deliberately lists
+        // none. Dropping that sentence left "none reported" looking like a failed
+        // query rather than a deliberate boundary, so it is shown either way.
         field.available === false
             ? `unavailable${field.reason === undefined ? "" : `: ${field.reason}`}`
-            : "available",
+            : field.reason === undefined ? "available" : `available: ${field.reason}`,
         field.allowCustom ? "yes" : "no"
     ]);
     const sections = [
@@ -39,5 +44,5 @@ export function renderAgentConfigurationCatalog(resolved) {
                     { header: "Custom", minWidth: 6, maxWidth: 8 }
                 ], fieldRows, defaultTableWidth())])
     ];
-    return `${sections.join("\n\n")}\n${renderAgentConfigurationResolutionNotice(resolved)}`;
+    return `${sections.join("\n\n")}\n${agentHandshakeLine(catalog.handshake)}\n${renderAgentConfigurationResolutionNotice(resolved)}`;
 }