@zq-silk/yui 0.8.3 → 0.8.7

package/dist/operator/operatorSessionHistory.js

@@ -1,4 +1,40 @@
 import { normalizeRoleAgentSessionText, roleAgentSessionRef, validateRoleSessionSet } from "../executor/agentExecutor.js";
+/** Separates the one selected writer authority from retained conversations. */
+export function projectOperatorStatus(sessions, activeAgentId, activeAdapterId) {
+    if (sessions === null) {
+        return Object.freeze({
+            writer: { state: "unrecorded", agentId: activeAgentId, adapterId: activeAdapterId },
+            historicalConversations: []
+        });
+    }
+    validateRoleSessionSet(sessions);
+    // The GlobalRole binding is the writer authority. The SessionSet pointer is
+    // retained operational state and may lag a Role update, so it cannot select
+    // a second Operator writer.
+    const active = sessions.sessions[activeAgentId];
+    const matchingActive = active?.adapterId === activeAdapterId ? active : undefined;
+    const activeRef = matchingActive === undefined ? undefined : operatorSessionRef(matchingActive);
+    const historicalConversations = listOperatorSessions(sessions)
+        .filter((entry) => entry.ref !== activeRef)
+        .map((entry) => ({ ...entry, state: "history" }));
+    if (matchingActive === undefined) {
+        return Object.freeze({
+            writer: { state: "unrecorded", agentId: activeAgentId, adapterId: activeAdapterId },
+            historicalConversations
+        });
+    }
+    return Object.freeze({
+        writer: {
+            state: matchingActive.status === "stopped" || matchingActive.status === "broken" ? "inactive" : "active",
+            agentId: matchingActive.agentId,
+            adapterId: matchingActive.adapterId,
+            sessionRef: activeRef,
+            nativeSessionId: matchingActive.nativeSessionId,
+            sessionStatus: matchingActive.status
+        },
+        historicalConversations
+    });
+}
 export function operatorSessionRef(session) {
     return roleAgentSessionRef(session);
 }

package/dist/release/releaseHandover.js

@@ -13,17 +13,19 @@
  * the candidate read-only and reports dual-owner; a crashed activator resumes
  * from the recorded phase.
  */
+import { RELEASE_HANDOVER_PROMOTION_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
 import { acquireHandoverLock, isOwnerLive, newHandoverId, readActiveReleasePointer, readCandidateDiscovery, readHandoverFence, readHandoverReceipt, readRuntimeIdentity, removeCandidateDiscovery, removeHandoverFence, writeActiveReleasePointer, writeHandoverFence, writeHandoverReceipt } from "./runtimeRelease.js";
 export const DEFAULT_CANDIDATE_READY_TIMEOUT_MS = 30_000;
-export const DEFAULT_PROMOTION_TIMEOUT_MS = 45_000;
+export const DEFAULT_PROMOTION_TIMEOUT_MS = RELEASE_HANDOVER_PROMOTION_TIMEOUT_MS;
 export const DEFAULT_POLL_INTERVAL_MS = 100;
 /**
  * Optional confirmation debounce after the candidate latches `dualOwner:
  * true`. Defaults to 0: the candidate's own exit grace
- * (`DEFAULT_DUAL_OWNER_GRACE_MS` in `handoverCandidate.ts`, 30s) is the single
- * authoritative old-owner exit window, and the activator trusts the candidate's
- * latched signal. A non-zero value only adds a short extra confirmation before
- * reporting dual-owner; it must never be used to re-litigate the exit grace.
+ * (`DEFAULT_DUAL_OWNER_GRACE_MS` in `handoverCandidate.ts`) is the single
+ * authoritative old-owner exit window. It outlives the complete Controller
+ * shutdown/drain boundary, and the activator trusts the candidate's latched
+ * signal. A non-zero value only adds a short extra confirmation before reporting
+ * dual-owner; it must never be used to re-litigate the exit grace.
  */
 export const DEFAULT_DUAL_OWNER_GRACE_MS = 0;
 export async function activateRelease(ports, options) {

package/dist/release/runtimeRelease.js

@@ -251,6 +251,21 @@ export function writeCandidateDiscovery(home, candidate) {
 export function removeCandidateDiscovery(home) {
     rmSync(join(resolve(home), CANDIDATE_DISCOVERY_PATH), { force: true });
 }
+/**
+ * Read-only scheduler fence for the short release/rebind critical section.
+ * A stale owner does not block work; an unreadable lock fails closed for
+ * bounded Operator diagnosis instead of dispatching across an unknown fence.
+ */
+export function isHandoverLockHeld(home) {
+    const lockPath = join(resolve(home), "runtime", "handover.lock");
+    try {
+        const owner = JSON.parse(readFileSync(lockPath, "utf8"));
+        return isHandoverLockLive(owner);
+    }
+    catch (error) {
+        return !isEnoent(error);
+    }
+}
 export function acquireHandoverLock(home) {
     const lockPath = join(resolve(home), "runtime", "handover.lock");
     mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });

package/dist/repository/taskWorkspaceCoordinator.js

@@ -108,6 +108,14 @@ export class TaskWorkspaceCoordinator {
         await this.#stopLiveRoles(item.taskId, this.#workItemRoleNames(item));
         return "released";
     }
+    /**
+     * Stops one Task Role's physical runtime without changing its workspace.
+     * The caller owns the subsequent atomic record retirement and wake.
+     */
+    async cleanupTaskRoleRuntime(taskId, roleName) {
+        await this.#stopLiveRoles(taskId, [roleName]);
+        return "released";
+    }
     async cleanupReviewRound(taskId, reviewRoundId) {
         const round = this.store.getReviewRound(taskId, reviewRoundId);
         if (round === null)
@@ -384,17 +392,12 @@ export class TaskWorkspaceCoordinator {
         const observedPanes = inspect?.(taskId);
         const live = targets.filter((roleName) => {
             const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
-            const activeSession = sessions === null
-                ? undefined
-                : sessions.activeAgentId === undefined
-                    // Narrow test doubles and restored callers predating activeAgentId
-                    // still conservatively represent any nonterminal record as live.
-                    ? Object.values(sessions.sessions).find(({ status }) => status !== "stopped" && status !== "broken")
-                    : sessions.sessions[sessions.activeAgentId];
             return observedPanes?.some((pane) => pane.roleName === roleName && !pane.dead) === true
-                || (sessions !== null && activeSession !== undefined
-                    && activeSession.status !== "stopped"
-                    && activeSession.status !== "broken");
+                // A terminal current Session can still carry a resumable native id or
+                // Provider binding. Exact cleanup retires both before a workspace or
+                // release-control transition is allowed to wake this Role again.
+                || (sessions !== null && (Object.keys(sessions.sessions).length > 0
+                    || sessions.providerBinding !== null));
         });
         if (live.length > 0)
             await this.runtime.stopTaskRoleSessions(taskId, live);

package/dist/review/deltaRecheck.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { deltaRecheckMaxChangedFiles, deltaRecheckMaxChangedLines } from "./reviewConfig.js";
 import { validateDeltaRecheckRecord } from "./reviewRound.js";
+import { isSemanticReviewRound } from "./reviewOutcomeClassifier.js";
 /**
  * Assesses whether a delta-recheck may be attempted.  Every deterministic
  * gate fails closed here; semantic equivalence is always left to the
@@ -8,11 +9,11 @@ import { validateDeltaRecheckRecord } from "./reviewRound.js";
  */
 export async function assessDeltaRecheck(input) {
     const { repositoryPaths, previousRound, candidate, git, config } = input;
-    if (previousRound.status !== "completed"
+    if (!isSemanticReviewRound(previousRound)
         || (previousRound.scope ?? "work-item") !== "task") {
         return {
             kind: "ineligible",
-            reason: "Delta recheck requires a completed Task-final ReviewRound."
+            reason: "Delta recheck requires a semantic completed Task-final ReviewRound."
         };
     }
     if (previousRound.taskCandidate === undefined) {

package/dist/review/reviewFindingLedger.js

@@ -117,11 +117,11 @@ export function reconcileReviewFindings(store, taskId, roundId, now) {
     if (round === null) {
         return { roundId, skipped: true, reason: "ReviewRound not found.", created: [], updated: [], conflicts: [] };
     }
-    if (!isSemanticReviewRound(round)) {
+    if (!isSemanticReviewRound(round, store)) {
         return {
             roundId,
             skipped: true,
-            reason: "ReviewRound is an execution-attempt failure, not a semantic report.",
+            reason: "ReviewRound is non-semantic or ambiguous, not a proven semantic report.",
             created: [],
             updated: [],
             conflicts: []
@@ -464,7 +464,7 @@ export function renderFindingLedgerContext(summary) {
 export function reusableTaskReviewEvidence(store, taskId, candidate) {
     const rounds = store.listReviewRounds(taskId)
         .filter((round) => (round.scope ?? "work-item") === "task"
-        && round.status === "completed"
+        && isSemanticReviewRound(round, store)
         && round.evidenceCommit !== undefined
         && isSameTaskReviewCandidate(round.taskCandidate, candidate))
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
@@ -492,7 +492,8 @@ export function reusableTaskReviewEvidence(store, taskId, candidate) {
  */
 export function buildTaskFinalReviewFindingContext(store, taskId, candidate) {
     const previousSemanticRound = store.listReviewRounds(taskId)
-        .filter((round) => (round.scope ?? "work-item") === "task" && round.status === "completed")
+        .filter((round) => (round.scope ?? "work-item") === "task"
+        && isSemanticReviewRound(round, store))
         .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
         .at(-1) ?? null;
     const reusableEvidence = reusableTaskReviewEvidence(store, taskId, candidate);

package/dist/review/reviewOutcomeClassifier.js

@@ -1,61 +1,270 @@
+import { matchYieldReceipt } from "../run/yieldReceipt.js";
+import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 const INFRA_SIGNATURES = [
-    {
-        kind: "session-not-stopped",
-        pattern: /session must be stopped before workspace migration/iu
-    },
-    {
-        kind: "run-start",
-        pattern: /role run could not start|could not start (?:the )?(?:reviewer|role) run/iu
-    },
-    {
-        kind: "storage-lock",
-        pattern: /\.state\.lock|state lock|lock timeout|storage lock/iu
-    },
-    {
-        kind: "tmux-exit",
-        pattern: /tmux[^\n]{0,80}(?:exited|exit|died|vanished)|pane (?:exited|died)/iu
-    },
-    {
-        kind: "yield-timeout",
-        pattern: /yield timeout|controller yield timeout|yield timed out/iu
-    },
-    {
-        kind: "run-identity",
-        pattern: /wrong run id|unknown run id|run id (?:is )?(?:invalid|unknown|mismatch)/iu
-    },
-    {
-        kind: "policy",
-        pattern: /cyber_?policy|policy denial|permission denied by policy/iu
-    },
-    {
-        kind: "baseline-contamination",
-        pattern: /cross[-\s]?baseline|baseline pollution|contaminated baseline|wrong base sha/iu
-    }
+    { kind: "session-not-stopped", pattern: /session must be stopped before workspace migration/iu },
+    { kind: "run-start", pattern: /role run could not start|could not start (?:the )?(?:reviewer|role) run/iu },
+    { kind: "storage-lock", pattern: /\.state\.lock|state lock|lock timeout|storage lock/iu },
+    { kind: "tmux-exit", pattern: /tmux[^\n]{0,80}(?:exited|exit|died|vanished)|pane (?:exited|died)/iu },
+    { kind: "yield-timeout", pattern: /yield timeout|controller yield timeout|yield timed out/iu },
+    { kind: "run-identity", pattern: /wrong run id|unknown run id|run id (?:is )?(?:invalid|unknown|mismatch)/iu },
+    { kind: "policy", pattern: /cyber_?policy|policy denial|permission denied by policy/iu },
+    { kind: "baseline-contamination", pattern: /cross[-\s]?baseline|baseline pollution|contaminated baseline|wrong base sha/iu },
+    { kind: "context-load", pattern: /(?:run )?(?:context|context pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)/iu },
+    { kind: "workspace-binding", pattern: /workspace is not the durable owner|workspace-binding failure/iu }
 ];
-/**
- * Classifies a terminal Round.  `completed` is always semantic (the reviewer
- * delivered a report); `failed` is always infra.  Non-terminal Rounds have no
- * outcome yet.
- */
-export function classifyReviewRoundOutcome(round) {
-    if (round.status === "completed") {
-        return { kind: "semantic", reason: "Reviewer delivered a report." };
-    }
-    if (round.status !== "failed")
+/** Classify one terminal Round without rewriting it. */
+export function classifyReviewRoundOutcome(round, evidence) {
+    if (round.status !== "completed" && round.status !== "failed")
         return null;
-    const text = `${round.summary ?? ""}\n${round.report ?? ""}`;
-    for (const { kind, pattern } of INFRA_SIGNATURES) {
-        if (pattern.test(text)) {
-            return { kind: "infra", infraKind: kind, reason: `Review execution attempt failed (${kind}).` };
+    if (evidence !== undefined && round.reviewerRunId !== undefined
+        && isTaskRecordRetired(evidence.listEvents(round.taskId), "agent-run", round.reviewerRunId)) {
+        return {
+            kind: "non-semantic",
+            infraKind: "run-identity",
+            reason: `Reviewer Run ${round.reviewerRunId} was retired from operational evidence.`
+        };
+    }
+    const infraKind = classifyInfraKind(`${round.summary ?? ""}\n${round.report ?? ""}`);
+    if (round.status === "failed") {
+        const semanticEvidence = failedRoundSemanticEvidence(round, evidence);
+        return semanticEvidence === null
+            ? {
+                kind: "non-semantic",
+                infraKind,
+                reason: "Failed Review execution carries no semantic report evidence."
+            }
+            : {
+                kind: "ambiguous",
+                infraKind,
+                reason: semanticEvidence
+            };
+    }
+    if (!explicitCompletedReviewInfrastructureFailure(round.summary ?? "", round)) {
+        return { kind: "semantic", reason: "Reviewer delivered a terminal report." };
+    }
+    if (evidence === undefined) {
+        return {
+            kind: "ambiguous",
+            infraKind,
+            reason: "Completed Round claims an infrastructure failure but corroborating Run/Event evidence was not supplied."
+        };
+    }
+    const corroborationFailure = completedInfrastructureCorroborationFailure(round, evidence);
+    return corroborationFailure === null
+        ? {
+            kind: "non-semantic",
+            infraKind,
+            reason: "Completed Round and yielded Run agree on an explicit pre-review infrastructure failure."
         }
+        : {
+            kind: "ambiguous",
+            infraKind,
+            reason: corroborationFailure
+        };
+}
+/** True only when a Round may consume semantic Review budget or feed findings. */
+export function isSemanticReviewRound(round, evidence) {
+    return classifyReviewRoundOutcome(round, evidence)?.kind === "semantic";
+}
+function classifyInfraKind(text) {
+    return INFRA_SIGNATURES.find(({ pattern }) => pattern.test(text))?.kind ?? "other-infra";
+}
+function failedRoundSemanticEvidence(round, evidence) {
+    if ((round.checks ?? []).length > 0)
+        return "Failed Round records review checks.";
+    if (round.evidenceCommit !== undefined)
+        return "Failed Round records a review evidence commit.";
+    if (round.deltaRecheck?.disposition !== undefined || round.deltaRecheck?.reasoning !== undefined) {
+        return "Failed Round records a semantic delta-recheck disposition.";
+    }
+    if (round.report !== round.summary)
+        return "Failed Round stores a report distinct from its terminal summary.";
+    if (runtimeFailureSummaryHasReviewerOutput(round.report ?? "")) {
+        return "Failed Round stores non-empty Reviewer output in its runtime failure summary.";
     }
-    return {
-        kind: "infra",
-        infraKind: "other-infra",
-        reason: "Review execution attempt failed before a semantic report."
-    };
+    if (looksLikeStructuredReviewReport(round.report ?? "")) {
+        return "Failed Round stores a structured Reviewer report.";
+    }
+    const semanticLane = (round.executionGroup?.lanes ?? []).find((lane) => ((lane.result?.checks ?? []).length > 0
+        || (lane.result?.findings ?? []).length > 0
+        || (lane.result?.evidence ?? []).length > 0
+        || lane.result?.evidenceCommit !== undefined
+        || lane.result?.gitSnapshot !== undefined
+        || lane.status === "yielded"
+        || lane.status === "completed"));
+    if (semanticLane !== undefined)
+        return `Reviewer Lane ${semanticLane.id} delivered semantic evidence.`;
+    if (evidence !== undefined) {
+        const events = evidence.listEvents(round.taskId);
+        const reviewRun = operationalTaskRecords(evidence.listAgentRuns(round.taskId), events, "agent-run").find((run) => (run.purpose === "review"
+            && run.reviewRoundId === round.id
+            && (run.status === "yielded" || runtimeFailureSummaryHasReviewerOutput(run.summary ?? ""))));
+        if (reviewRun !== undefined)
+            return `Reviewer Run ${reviewRun.id} records Reviewer output.`;
+        const finding = evidence.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
+        if (finding !== undefined)
+            return `Review finding ${finding.id} references the Round.`;
+        const completion = events.find((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
+        if (completion !== undefined)
+            return `Review completion Event ${completion.id} exists.`;
+    }
+    return null;
 }
-/** True when this Round may feed the finding ledger. */
-export function isSemanticReviewRound(round) {
-    return classifyReviewRoundOutcome(round)?.kind === "semantic";
+function completedInfrastructureCorroborationFailure(round, store) {
+    if ((round.checks ?? []).length > 0)
+        return "Completed Round records review checks.";
+    if (round.evidenceCommit !== round.reviewBaseCommit) {
+        return "Completed Round lacks an exact frozen-head evidence commit.";
+    }
+    if (round.report !== round.summary) {
+        return "Completed Round stores a report distinct from its terminal summary.";
+    }
+    if (runtimeFailureSummaryHasReviewerOutput(round.report ?? "")) {
+        return "Completed Round stores non-empty Reviewer output in its runtime failure summary.";
+    }
+    if (round.deltaRecheck?.disposition !== undefined || round.deltaRecheck?.reasoning !== undefined) {
+        return "Completed Round records a semantic delta-recheck disposition.";
+    }
+    if (looksLikeStructuredReviewReport(round.report ?? "")) {
+        return "Completed Round stores a structured Reviewer report.";
+    }
+    for (const lane of round.executionGroup?.lanes ?? []) {
+        if (lane.status === "pending" || lane.status === "running") {
+            return `Reviewer Lane ${lane.id} is still active.`;
+        }
+        if ((lane.result?.checks ?? []).length > 0
+            || (lane.result?.findings ?? []).length > 0
+            || (lane.result?.evidence ?? []).length > 0
+            || (lane.result?.evidenceCommit !== undefined
+                && lane.result.evidenceCommit !== round.reviewBaseCommit)
+            || lane.result?.gitSnapshot !== undefined) {
+            return `Reviewer Lane ${lane.id} delivered semantic evidence.`;
+        }
+        if (lane.status === "yielded" || lane.status === "completed") {
+            if (lane.result === undefined
+                || lane.result.summary !== round.summary
+                || lane.result.report !== round.report
+                || lane.result.evidenceCommit !== round.reviewBaseCommit) {
+                return `Reviewer Lane ${lane.id} output is absent or differs from the Round.`;
+            }
+        }
+        else {
+            return `Completed Round has non-completed Reviewer Lane ${lane.id}/${lane.status}.`;
+        }
+    }
+    const allEvents = store.listEvents(round.taskId);
+    const runs = operationalTaskRecords(store.listAgentRuns(round.taskId), allEvents, "agent-run").filter((run) => (run.purpose === "review" && run.reviewRoundId === round.id));
+    const active = runs.find(({ status }) => status === "active");
+    if (active !== undefined)
+        return `Reviewer Run ${active.id} is still active.`;
+    const output = runs.find((run) => (run.status === "failed" && runtimeFailureSummaryHasReviewerOutput(run.summary ?? "")));
+    if (output !== undefined)
+        return `Reviewer Run ${output.id} records Reviewer output.`;
+    const yielded = runs.filter(({ status }) => status === "yielded");
+    if (round.reviewerRunId === undefined
+        || yielded.length !== 1
+        || yielded[0].id !== round.reviewerRunId) {
+        return "Completed Round lacks one exact yielded Reviewer Run.";
+    }
+    const run = yielded[0];
+    if (run.roleName !== round.reviewerRoleName
+        || run.summary !== round.summary
+        || run.yieldReceipt === undefined) {
+        return `Reviewer Run ${run.id} does not match the non-semantic Round receipt.`;
+    }
+    const receiptMatch = matchYieldReceipt(run.yieldReceipt, {
+        status: "yielded",
+        summary: round.summary ?? "",
+        reviewResult: {
+            report: round.report ?? "",
+            checks: round.checks ?? [],
+            evidenceCommit: round.reviewBaseCommit
+        }
+    });
+    if (receiptMatch?.kind !== "replayed") {
+        return `Reviewer Run ${run.id} yield receipt does not cover the Round outcome.`;
+    }
+    const finding = store.listReviewFindings(round.taskId).find((entry) => (entry.firstReviewRoundId === round.id || entry.lastReviewRoundId === round.id));
+    if (finding !== undefined)
+        return `Review finding ${finding.id} references the Round.`;
+    const events = allEvents.filter((event) => (event.type === "review.completed" && event.payload.reviewRoundId === round.id));
+    if (events.length !== 1)
+        return "Completed Round lacks one exact completion Event.";
+    const event = events[0];
+    if (event.payload.workItemId !== round.workItemId
+        || event.payload.candidateId !== round.candidateId
+        || event.payload.reviewBaseCommit !== round.reviewBaseCommit
+        || event.payload.evidenceCommit !== round.reviewBaseCommit
+        || event.payload.checks !== "none") {
+        return `Review completion Event ${event.id} carries mismatched or semantic evidence.`;
+    }
+    return null;
+}
+function explicitCompletedReviewInfrastructureFailure(summary, round) {
+    if (exactCompletedReviewInfrastructureFailureReport(summary))
+        return true;
+    const report = summary.trim();
+    if (report === `Role Run workspace is not the durable owner: ${round.taskId}/${round.reviewerRoleName}.`
+        || (round.reviewerRunId !== undefined
+            && report === `Review Run workspace is not the durable owner: ${round.reviewerRunId}.`)) {
+        return true;
+    }
+    return /^(?:Run )?(?:Context|Context Pack) load (?:failed|unavailable|unauthorized|stale|mismatched|malformed)(?:: (?:failure|mismatch|unavailable|unauthorized|stale|mismatched|malformed))?\.?$/iu
+        .test(report);
+}
+function exactCompletedReviewInfrastructureFailureReport(summary) {
+    const lines = summary.trim().split(/\r?\n/u);
+    const envelope = [
+        /^# Review result: (?:context-load|workspace-binding) failure$/u,
+        /^$/u,
+        /^The assigned Run context could not be safely matched to this native session, so no candidate review was performed\.$/u,
+        /^$/u,
+        /^- Run: `[^`\r\n]+`$/u,
+        /^- ReviewRound: `[^`\r\n]+`$/u,
+        /^- Review base commit: `[0-9a-f]{40}`$/u,
+        /^- Frozen target: `[^`\r\n]+`$/u,
+        /^- Authorized workspace from the exact Context Pack: `[^`\r\n]+`$/u,
+        /^- Session-attached workspace: `[^`\r\n]+`$/u,
+        /^- Verification: both paths resolve distinctly and have different filesystem inodes \(`[^`\r\n]+` vs `[^`\r\n]+`\)\.$/u,
+        /^$/u,
+        /^## Findings$/u,
+        /^$/u,
+        /^- Verified-fixed findings: none; review did not start\.$/u,
+        /^- New findings: none; candidate sources were intentionally not inspected\.$/u,
+        /^- Accepted risks: none accepted\.$/u,
+        /^- Residual verification gaps: the complete frozen diff, changed control-flow paths, callers, data-integrity behavior, and required deterministic checks remain unreviewed because the Review workspace binding is mismatched\.$/u,
+        /^$/u,
+        /^## Checks actually run$/u,
+        /^$/u,
+        /^- Exact Context API load: passed for Task\/Run\/Role\/purpose\/subject\/snapshot\/adapter\.$/u,
+        /^- Workspace binding verification: failed\.$/u,
+        /^- Candidate build\/tests\/package checks: not run\.$/u,
+        /^- Real-provider E2E: not run and not authorized\.$/u,
+        /^$/u,
+        /^## Required next action$/u,
+        /^$/u,
+        /^Attach the native Reviewer session to the exact workspace recorded by the Context Pack, or issue a fresh internally consistent Review Run\/Context Pack\. Then perform the complete bounded Task-final review at the frozen head\.$/u
+    ];
+    return lines.length === envelope.length
+        && envelope.every((pattern, index) => pattern.test(lines[index]));
+}
+function runtimeFailureSummaryHasReviewerOutput(summary) {
+    const output = /(?:^|\n)last_assistant_message:[ \t]*([\s\S]*)$/u.exec(summary)?.[1];
+    return output !== undefined && output.trim().length > 0;
+}
+function looksLikeStructuredReviewReport(report) {
+    let parsed;
+    try {
+        parsed = JSON.parse(report);
+    }
+    catch {
+        return false;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return false;
+    const record = parsed;
+    return [
+        "summary", "report", "checks", "findings", "evidence", "evidenceCommit",
+        "deltaDisposition", "deltaReasoning"
+    ].some((key) => Object.hasOwn(record, key));
 }

package/dist/review/taskFinalReviewContractEvent.js

@@ -0,0 +1 @@
+export const TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT = "review.task-final-contract-rebound";