@zq-silk/yui 0.14.1 → 0.14.2

package/dist/lifecycle/canonicalLifecycleEvent.js

@@ -18,7 +18,7 @@ const TURN_SCOPED_PHASES = new Set([
 /**
  * Phases that assert durable provider truth about a Turn. Every one must carry
  * the complete turn-scoped identity — turnId AND the generation fences
- * (nativeSessionId + launchId) AND, where the transport owns it, the receiptId —
+ * (nativeSessionId + runtimeGenerationId) AND, where the transport owns it, the receiptId —
  * because a missing or wrong fence must fail closed rather than advance a Turn or
  * its successor.
  */
@@ -86,8 +86,8 @@ export function createCanonicalLifecycleEvent(input) {
         if (fence.nativeSessionId === undefined) {
             throw new CanonicalLifecycleError(`Phase ${input.phase} requires a nativeSessionId fence.`);
         }
-        if (fence.launchId === undefined) {
-            throw new CanonicalLifecycleError(`Phase ${input.phase} requires a launchId fence.`);
+        if (fence.runtimeGenerationId === undefined) {
+            throw new CanonicalLifecycleError(`Phase ${input.phase} requires a runtimeGenerationId fence.`);
         }
     }
     if (input.phase === "prompt-pushed" && fence.receiptId === undefined) {
@@ -156,8 +156,8 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
             // exact launch fence and only when none is bound yet.
             if (expectation.boundNativeSessionId === undefined
                 && event.fence.nativeSessionId !== undefined
-                && event.fence.launchId !== undefined
-                && event.fence.launchId === expectation.fence.launchId) {
+                && event.fence.runtimeGenerationId !== undefined
+                && event.fence.runtimeGenerationId === expectation.fence.runtimeGenerationId) {
                 return { outcome: "bind-native-session", nativeSessionId: event.fence.nativeSessionId };
             }
             return { outcome: "mark-session-started" };
@@ -222,7 +222,7 @@ export function foldCanonicalLifecycleEvent(event, expectation) {
  * Returns null when the event belongs to the expected generation/Turn, or a
  * mismatch reason otherwise. Owner/adapter and turn-scoped turnId are always
  * compared. Provider-truth phases (acceptance/progress/terminal) require the
- * COMPLETE generation fence — nativeSessionId, launchId, and (for acceptance)
+ * COMPLETE generation fence — nativeSessionId, runtimeGenerationId, and (for acceptance)
  * receiptId must be present and equal, so a missing or wrong generation/receipt
  * fails closed rather than advancing a Turn or its successor. Where a native id
  * is already bound, every turn-scoped fact must match it.
@@ -256,10 +256,11 @@ function matchesFence(expectation, event) {
     if (PROVIDER_TRUTH_PHASES.has(phase)) {
         if (actual.nativeSessionId === undefined)
             return "fence-mismatch:missing-native-session";
-        if (actual.launchId === undefined)
-            return "fence-mismatch:missing-launch";
-        if (expected.launchId !== undefined && actual.launchId !== expected.launchId) {
-            return "fence-mismatch:launchId";
+        if (actual.runtimeGenerationId === undefined) {
+            return "fence-mismatch:missing-runtime-generation";
+        }
+        if (expected.runtimeGenerationId !== undefined && actual.runtimeGenerationId !== expected.runtimeGenerationId) {
+            return "fence-mismatch:runtimeGenerationId";
         }
         // Once a native id is bound, every provider-truth fact must match it. Before
         // binding (discovery still open) the expected fence's own nativeSessionId, if
@@ -290,10 +291,10 @@ function matchesFence(expectation, event) {
         && actual.nativeSessionId !== expected.nativeSessionId) {
         return "fence-mismatch:nativeSessionId";
     }
-    if (actual.launchId !== undefined
-        && expected.launchId !== undefined
-        && actual.launchId !== expected.launchId) {
-        return "fence-mismatch:launchId";
+    if (actual.runtimeGenerationId !== undefined
+        && expected.runtimeGenerationId !== undefined
+        && actual.runtimeGenerationId !== expected.runtimeGenerationId) {
+        return "fence-mismatch:runtimeGenerationId";
     }
     if (phase === "prompt-pushed"
         && actual.receiptId !== undefined
@@ -319,7 +320,7 @@ function normalizeFence(fence) {
         ...(fence.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireFenceText(fence.nativeSessionId, "nativeSessionId") }),
-        ...(fence.launchId === undefined ? {} : { launchId: requireFenceText(fence.launchId, "launchId") }),
+        ...(fence.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: requireFenceText(fence.runtimeGenerationId, "runtimeGenerationId") }),
         ...(fence.receiptId === undefined ? {} : { receiptId: requireFenceText(fence.receiptId, "receiptId") })
     });
 }

package/dist/lifecycle/exactTurnTerminalization.js

@@ -1,9 +1,12 @@
 import { isDeepStrictEqual } from "node:util";
 import { completeProcessing } from "../coordination/workMailbox.js";
+import { captureRoleTurnDispatch, settleRoleTurnDispatch } from "../coordination/workMailboxQueue.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
-import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { completeTurn, failTurn } from "../turn/turn.js";
-import { recordExecutionLaneResult, resolveExecutionGroup } from "../execution/executionGroup.js";
+import { boundedTurnFailureDiagnostic } from "../domain/agentResultTransport.js";
+import { updateExecutionLane, updateWorkItemExecutionLane } from "../execution/workItemExecution.js";
+import { reconcileWorkItemMainTurns } from "../execution/workItemMainTurn.js";
+import { reconcileReviewMainTurns } from "../execution/reviewMainTurn.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
 import { latestTurnDurableProgressAt } from "../scheduler/roleTurnStall.js";
@@ -30,7 +33,8 @@ export function validateExactTurnReviewRound(store, turn, options = {}) {
         return { disposition: "obsolete", round, reason: "review-round-terminal" };
     }
     const lane = round.executionGroup?.lanes.find(({ id }) => id === turn.executionLaneId);
-    const exactReviewerTurn = round.reviewerTurnId === turn.id || lane?.turnId === turn.id;
+    const exactReviewerTurn = round.reviewerTurnId === turn.id
+        || lane?.currentTurnId === turn.id;
     const exactReviewerRole = round.reviewerRoleName === turn.roleName || lane?.roleName === turn.roleName;
     if (!exactReviewerTurn
         || !exactReviewerRole
@@ -69,7 +73,7 @@ export function validateExactTurnReviewRound(store, turn, options = {}) {
     }
     if (turn.workspace.owner.type === "execution-lane") {
         if (lane === undefined
-            || lane.turnId !== turn.id
+            || lane.currentTurnId !== turn.id
             || lane.roleName !== turn.roleName
             || lane.workspace?.root !== turn.workspace.root
             || lane.workspace.writableProjectIds.length !== turn.workspace.entries.length
@@ -138,66 +142,16 @@ export function terminalizeExactTurnReviewRound(store, input, now) {
         return validation;
     }
     const reviewRound = validation.round;
-    let groupedRound = input.turn.executionGroupId !== undefined
-        && input.turn.executionLaneId !== undefined
-        && reviewRound.executionGroup !== undefined
-        ? updateReviewExecutionGroup(reviewRound, recordExecutionLaneResult(reviewRound.executionGroup, input.turn.executionLaneId, {
-            summary: input.outcome.summary,
-            ...(input.reviewResult?.report === undefined ? {} : { report: input.reviewResult.report }),
-            ...(input.reviewResult?.checks === undefined
-                ? {}
-                : {
-                    checks: input.reviewResult.checks.map(({ name, outcome, details }) => ({
-                        name,
-                        outcome,
-                        ...(details === undefined ? {} : { details })
-                    }))
-                }),
-            ...(input.reviewResult?.findings === undefined
-                ? {}
-                : { findings: input.reviewResult.findings }),
-            ...(input.reviewResult?.evidence === undefined
-                ? {}
-                : { evidence: input.reviewResult.evidence }),
-            ...(input.reviewResult?.evidenceCommit === undefined
-                ? {}
-                : { evidenceCommit: input.reviewResult.evidenceCommit }),
-            ...(input.reviewResult?.gitSnapshot === undefined
-                ? {}
-                : { gitSnapshot: input.reviewResult.gitSnapshot })
-        }, input.outcome.status, now))
-        : reviewRound;
-    if (input.settleFailedExecutionGroup === true
-        && input.outcome.status === "failed"
-        && groupedRound.executionGroup !== undefined
-        && groupedRound.executionGroup.resolution === undefined
-        && groupedRound.executionGroup.lanes.every((lane) => (lane.status === "completed"
-            || lane.status === "failed"
-            || lane.status === "skipped"))) {
-        groupedRound = updateReviewExecutionGroup(groupedRound, resolveExecutionGroup(groupedRound.executionGroup, {
-            decision: "blocked",
-            summary: input.outcome.summary
-        }, now));
-    }
-    const groupedMultiLane = groupedRound.executionGroup !== undefined
-        && (groupedRound.executionGroup.lanes.length > 1
-            || groupedRound.executionGroup.strategy.mode === "adaptive");
-    if (groupedMultiLane
-        && groupedRound.executionGroup !== undefined
-        && groupedRound.executionGroup.resolution === undefined) {
-        // A panel Lane only contributes evidence.  The Leader must see every
-        // terminal Lane and explicitly resolve the Group before this ReviewRound
-        // can become terminal.
-        store.saveReviewRound(input.taskId, groupedRound);
-        return { disposition: "applied", round: groupedRound };
-    }
-    const terminal = finishReviewRound(groupedRound, input.outcome.status, input.outcome.summary, now, input.reviewResult);
+    if (input.turn.executionGroupId !== undefined
+        && input.turn.executionLaneId !== undefined) {
+        // Producer Turns own only their immutable Turn result. The unified Group
+        // is advanced after that result is validated and stored below.
+        return { disposition: "applied", round: reviewRound };
+    }
+    const terminal = finishReviewRound(reviewRound, input.outcome.status, now, input.outcome.status === "failed"
+        ? { kind: "execution", message: input.outcome.diagnostic }
+        : undefined);
     store.saveReviewRound(input.taskId, terminal);
-    // Issue 06: a completed (semantic) Round feeds the finding ledger; a failed
-    // execution attempt is skipped by the classifier and never creates findings.
-    if (terminal.status === "completed") {
-        reconcileReviewFindingsAfterReview(store, input.taskId, terminal.id, now);
-    }
     return { disposition: "applied", round: terminal };
 }
 /**
@@ -248,9 +202,8 @@ export function retireExactActiveTurn(store, input, now) {
         agentId: input.agentId,
         turnId: input.turnId,
         ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        settleFailedExecutionGroup: true,
-        outcome: { status: "failed", summary: input.reason, failureReason: "missing-result" }
+        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
+        outcome: { status: "failed", diagnostic: input.reason, failureReason: "missing-result" }
     };
     const session = sessions?.sessions[input.agentId];
     const providerBinding = sessions?.providerBinding;
@@ -310,24 +263,54 @@ export function terminalizeExactTaskTurn(store, input, now) {
     if (reviewValidation.disposition !== "applied") {
         return obsolete(turn, reviewValidation.reason ?? "review-round-mismatch");
     }
+    const requiredSnapshotProjects = [...new Set(turn.effective.writeProjectIds)].sort();
+    const observedSnapshotProjects = input.systemEvidence?.workspaceSnapshot?.projects
+        .map(({ projectId }) => projectId)
+        .sort();
+    const laneSnapshotRequired = input.outcome.status === "completed"
+        && turn.executionGroupId !== undefined
+        && turn.executionLaneId !== undefined
+        && requiredSnapshotProjects.length > 0;
+    const missingLaneSnapshot = laneSnapshotRequired
+        && (observedSnapshotProjects === undefined
+            || !isDeepStrictEqual(observedSnapshotProjects, requiredSnapshotProjects));
+    const workspaceFailure = laneSnapshotRequired
+        ? input.workspaceFailure ?? (missingLaneSnapshot
+            ? {
+                failureReason: "workspace-unavailable",
+                diagnostic: "Core could not freeze the exact clean writable Lane workspace."
+            }
+            : undefined)
+        : undefined;
+    const effectiveOutcome = input.outcome.status === "completed" && workspaceFailure !== undefined
+        ? {
+            status: "failed",
+            output: input.outcome.output,
+            diagnostic: workspaceFailure.diagnostic,
+            failureReason: workspaceFailure.failureReason,
+            ...(input.outcome.provider === undefined ? {} : { provider: input.outcome.provider })
+        }
+        : input.outcome;
+    const terminalOutcome = effectiveOutcome.status === "failed"
+        ? {
+            ...effectiveOutcome,
+            diagnostic: boundedTurnFailureDiagnostic(effectiveOutcome.diagnostic)
+        }
+        : effectiveOutcome;
     // All Turn, active-pointer, Session, launch, and mailbox fences have passed.
     // Only now may the exact ReviewRound be terminalized alongside the Turn so a
     // stale fence never leaves a Round written while the Turn stays active.
     const reviewRoundTerminalization = terminalizeExactTurnReviewRound(store, {
         taskId: input.taskId,
         turn,
-        outcome: input.outcome,
-        reviewResult: input.reviewResult,
-        ...(input.settleFailedExecutionGroup === undefined
-            ? {}
-            : { settleFailedExecutionGroup: input.settleFailedExecutionGroup })
+        outcome: terminalOutcome
     }, now);
     if (reviewRoundTerminalization.disposition !== "applied") {
         return obsolete(turn, reviewRoundTerminalization.reason ?? "review-round-mismatch");
     }
-    const terminal = input.outcome.status === "completed"
-        ? completeTurn(turn, input.outcome.summary, now, input.outcome.provider)
-        : failTurn(turn, input.outcome.failureReason ?? "runtime-failed", input.outcome.summary, now, input.outcome.provider);
+    const terminal = terminalOutcome.status === "completed"
+        ? completeTurn(turn, terminalOutcome.output, now, terminalOutcome.provider, input.systemEvidence)
+        : failTurn(turn, terminalOutcome.failureReason, terminalOutcome.diagnostic, now, terminalOutcome.provider, terminalOutcome.output);
     if (turn.executionGroupId !== undefined
         && turn.executionLaneId !== undefined
         && turn.purpose === "execution"
@@ -337,30 +320,48 @@ export function terminalizeExactTaskTurn(store, input, now) {
             ? undefined
             : workItemExecutionGroupById(item, turn.executionGroupId);
         if (item !== null && group !== undefined) {
-            let grouped = recordExecutionLaneResult(group, turn.executionLaneId, {
-                summary: input.outcome.summary,
-                ...(input.reviewResult?.report === undefined ? {} : { report: input.reviewResult.report }),
-                ...(input.reviewResult?.checks === undefined ? {} : { checks: input.reviewResult.checks }),
-                ...(input.reviewResult?.findings === undefined ? {} : { findings: input.reviewResult.findings }),
-                ...(input.reviewResult?.evidence === undefined ? {} : { evidence: input.reviewResult.evidence }),
-                ...(input.reviewResult?.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
-                ...(input.reviewResult?.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot })
-            }, input.outcome.status, now);
-            if (input.settleFailedExecutionGroup === true
-                && input.outcome.status === "failed"
-                && grouped.resolution === undefined
-                && grouped.lanes.every((lane) => (lane.status === "completed"
-                    || lane.status === "failed"
-                    || lane.status === "skipped"))) {
-                grouped = resolveExecutionGroup(grouped, {
-                    decision: "blocked",
-                    summary: input.outcome.summary
+            if (terminal.status === "completed") {
+                const grouped = updateWorkItemExecutionLane(group, turn.executionLaneId, {
+                    currentTurnId: turn.id,
+                    successfulTurnId: turn.id,
+                    disposition: "succeeded"
+                }, now);
+                store.saveWorkItem(input.taskId, updateWorkItemExecutionGroup(item, grouped, now));
+            }
+        }
+    }
+    if (turn.executionGroupId !== undefined
+        && turn.executionLaneId !== undefined
+        && turn.purpose === "review"
+        && turn.reviewRoundId !== undefined) {
+        const round = store.getReviewRound(input.taskId, turn.reviewRoundId);
+        const group = round?.executionGroup;
+        if (round !== null
+            && round !== undefined
+            && group !== undefined
+            && group.id === turn.executionGroupId) {
+            if (terminal.status === "completed") {
+                const grouped = updateExecutionLane(group, turn.executionLaneId, {
+                    currentTurnId: turn.id,
+                    successfulTurnId: turn.id,
+                    disposition: "succeeded"
                 }, now);
+                store.saveReviewRound(input.taskId, updateReviewExecutionGroup(round, grouped));
             }
-            store.saveWorkItem(input.taskId, updateWorkItemExecutionGroup(item, grouped, now));
         }
     }
     store.saveTurn(terminal);
+    const dispatchIdentity = {
+        taskId: terminal.taskId,
+        roleName: terminal.roleName,
+        turnId: terminal.id
+    };
+    const dispatchToken = captureRoleTurnDispatch(store.getWorkMailbox({
+        kind: "role",
+        taskId: terminal.taskId,
+        roleName: terminal.roleName
+    }), dispatchIdentity);
+    settleRoleTurnDispatch(store, dispatchIdentity, dispatchToken);
     if (terminal.roleName === "leader") {
         const wake = store.listTaskWakes(input.taskId)
             .find((candidate) => candidate.turnId === terminal.id && candidate.status === "dispatched");
@@ -375,6 +376,8 @@ export function terminalizeExactTaskTurn(store, input, now) {
         store.clearActiveTurn(input.taskId, input.roleName);
     }
     settleLaunchReservation(store, sessions, input);
+    reconcileWorkItemMainTurns(store, input.taskId, now);
+    reconcileReviewMainTurns(store, input.taskId, now);
     return { disposition: "applied", turn: terminal };
 }
 function settleLaunchReservation(store, sessions, input) {
@@ -386,10 +389,10 @@ function settleLaunchReservation(store, sessions, input) {
     const mailbox = store.getWorkMailbox(target);
     const reservation = mailbox?.processing;
     const session = sessions?.sessions[input.agentId];
-    const launchId = input.nativeSessionId === undefined
-        ? input.launchId ?? session?.launchId
-        : session?.launchId;
-    if (launchId === undefined || !isRuntimeLaunchReservation(reservation, launchId))
+    const runtimeGenerationId = input.nativeSessionId === undefined
+        ? input.runtimeGenerationId ?? session?.runtimeGenerationId
+        : session?.runtimeGenerationId;
+    if (runtimeGenerationId === undefined || !isRuntimeLaunchReservation(reservation, runtimeGenerationId))
         return;
     const settled = completeProcessing(mailbox, reservation.batchId);
     if (settled.processing === null && settled.pending === null) {

package/dist/message/message.js

@@ -26,6 +26,22 @@ export function createTaskMessage(id, taskId, body, kind, author, now, context =
 export function taskMessageAuthorLabel(author) {
     return author.type === "role" ? author.roleName : author.type;
 }
+/** Replace only the mutable content of a Draft user/operator Message. */
+export function updateDraftTaskMessage(message, update) {
+    validateTaskMessage(message);
+    if (message.kind !== "user" && message.kind !== "operator") {
+        throw new Error(`Only user/operator Task Messages can be updated: ${message.id}.`);
+    }
+    const updated = {
+        ...message,
+        body: requireBody(update.body),
+        ...(update.wakePolicy === undefined
+            ? {}
+            : { wakePolicy: update.wakePolicy })
+    };
+    validateTaskMessage(updated);
+    return updated;
+}
 export function validateTaskMessage(message) {
     if (message.schemaVersion !== 3)
         throw new Error("Task Message must use schemaVersion 3.");

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, Session generations, Review execution
+ * Turns/failures/durations, wake reasons, Runtime generations, 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
@@ -259,7 +259,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         failedCount += 1;
                         failedDurationMs += duration;
                         cumulativeDurationMs += duration;
-                        addLaunchFailureCounts(launchFailures, turn.result?.output);
+                        addLaunchFailureCounts(launchFailures, turn.result?.diagnostic);
                         failures.push(classifyTurnFailure(turn));
                     }
                 }
@@ -396,11 +396,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let completed = 0;
             let failedCount = 0;
             let infraFailed = 0;
-            let semanticNegative = 0;
             let deltaTotal = 0;
-            let deltaAccepted = 0;
-            let deltaFinding = 0;
-            let deltaEscalated = 0;
             const classes = [];
             for (const taskId of taskIds) {
                 for (const round of store.listReviewRounds(taskId)) {
@@ -413,19 +409,10 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         failedCount += 1;
                     if (round.deltaRecheck !== undefined) {
                         deltaTotal += 1;
-                        if (round.deltaRecheck.disposition === "equivalent-and-accepted")
-                            deltaAccepted += 1;
-                        else if (round.deltaRecheck.disposition === "finding")
-                            deltaFinding += 1;
-                        else if (round.deltaRecheck.disposition === "requires-full-review")
-                            deltaEscalated += 1;
                     }
-                    const classification = classifyReviewRound(round, store);
+                    const classification = classifyReviewRound(round);
                     if (classification.faultClass === "review-infra")
                         infraFailed += 1;
-                    else if (classification.faultClass === "review-semantic-negative") {
-                        semanticNegative += 1;
-                    }
                     if (classification.faultClass !== "other")
                         classes.push(classification);
                 }
@@ -435,14 +422,8 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 completed,
                 failed: failedCount,
                 infraFailed,
-                semanticNegative,
                 faultClasses: countFaultClasses(classes),
-                deltaRechecks: {
-                    total: deltaTotal,
-                    equivalentAndAccepted: deltaAccepted,
-                    finding: deltaFinding,
-                    requiresFullReview: deltaEscalated
-                }
+                deltaRechecks: deltaTotal
             });
         }
         catch (error) {
@@ -651,11 +632,9 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         workItems: withinWindow(store.listWorkItems(taskId), options),
                         changeSets: withinWindow(store.listChangeSets(taskId), options),
                         reviewRounds: withinWindow(store.listReviewRounds(taskId), options),
-                        reviewFindings: withinWindow(store.listReviewFindings(taskId), options),
                         integrations: withinWindow(store.listIntegrationAttempts(taskId), options),
                         durableJobs: withinWindow(store.listDurableJobs(taskId), options),
                         publications: withinWindow(store.listPublicationReferences(taskId), options),
-                        decisions: withinWindow(store.listDecisions(taskId), options),
                         events: withinWindow(store.listEvents(taskId), options),
                         managedWorkspaces: withinWindow(store.listManagedWorkspaces(taskId), options)
                     })];