@zq-silk/yui 0.8.2 → 0.8.6

package/dist/observability/executionAudit.js

@@ -18,6 +18,7 @@ import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.j
 import { classifyAgentRunFailure, classifyIntegrationAttempt, classifyReviewRound, classifyWakeReasons, 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";
 export function createProductionExecutionAuditPorts() {
     return {
         openStore: (home) => openCompatibleFileTaskStore(home),
@@ -206,6 +207,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             events: section,
             providerRetries: section,
             workItems: section,
+            orchestration: section,
             storage: section,
             runtimeProtocol: section,
             topLongRunning: section
@@ -443,7 +445,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         else if (round.deltaRecheck.disposition === "requires-full-review")
                             deltaEscalated += 1;
                     }
-                    const classification = classifyReviewRound(round);
+                    const classification = classifyReviewRound(round, store);
                     if (classification.faultClass === "review-infra")
                         infraFailed += 1;
                     else if (classification.faultClass === "review-semantic-negative") {
@@ -674,6 +676,37 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
+    const orchestration = (() => {
+        try {
+            const metrics = taskIds.flatMap((taskId) => {
+                const task = store.getTask(taskId);
+                if (task === null)
+                    return [];
+                return [projectTaskOrchestration({
+                        task,
+                        runs: withinWindow(store.listAgentRuns(taskId), options),
+                        roleSessionSets: sessionSetsWithinWindow(store.listRoleSessionSets(taskId), options),
+                        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)
+                    })];
+            });
+            return ok({
+                tasks: metrics,
+                advisoryCount: metrics.reduce((total, task) => total + task.advisories.length, 0)
+            });
+        }
+        catch (error) {
+            return failed(error);
+        }
+    })();
     const storage = (() => {
         try {
             let stateJsonBytes = UNSUPPORTED;
@@ -834,8 +867,21 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         events,
         providerRetries,
         workItems,
+        orchestration,
         storage,
         runtimeProtocol,
         topLongRunning
     };
 }
+function withinWindow(records, options) {
+    return records.filter((record) => inWindow(record.createdAt, options));
+}
+function sessionSetsWithinWindow(sets, options) {
+    if (options.since === undefined && options.until === undefined)
+        return sets;
+    return sets.map((set) => ({
+        ...set,
+        sessions: Object.fromEntries(Object.entries(set.sessions).filter(([, session]) => (inWindow(session.createdAt, options)))),
+        history: (set.history ?? []).filter((session) => inWindow(session.createdAt, options))
+    }));
+}

package/dist/observability/faultClassification.js

@@ -1,3 +1,4 @@
+import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
 export const FAULT_CLASSES = [
     "provider-transient",
     "policy-denied",
@@ -73,15 +74,16 @@ export function classifyAgentRunFailure(run, structured) {
  * Review execution failure (the Round itself failed to execute/deliver) is
  * `review-infra`; a completed Round with failed checks is a semantic negative.
  */
-export function classifyReviewRound(round) {
-    if (round.status === "failed") {
+export function classifyReviewRound(round, evidence) {
+    const outcome = classifyReviewRoundOutcome(round, evidence);
+    if (outcome?.kind === "non-semantic") {
         return {
             faultClass: "review-infra",
             basis: "structured",
-            evidence: "round status=failed"
+            evidence: outcome.reason
         };
     }
-    if (round.status === "completed" && (round.checks ?? []).some((c) => c.outcome === "failed")) {
+    if (outcome?.kind === "semantic" && (round.checks ?? []).some((c) => c.outcome === "failed")) {
         const failed = (round.checks ?? [])
             .filter((c) => c.outcome === "failed")
             .map((c) => c.name)

package/dist/observability/orchestrationMetrics.js

@@ -0,0 +1,196 @@
+import { classifyReviewRoundOutcome } from "../review/reviewOutcomeClassifier.js";
+import { projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
+import { taskDeliveryPath } from "../task/task.js";
+/** One Task's orchestration cost and advisory projection, with no writes. */
+export function projectTaskOrchestration(facts) {
+    const evidence = {
+        listAgentRuns: () => facts.runs,
+        listReviewFindings: () => facts.reviewFindings,
+        listEvents: () => facts.events
+    };
+    const fullRounds = facts.reviewRounds.filter((round) => round.deltaRecheck === undefined);
+    const deltaRounds = facts.reviewRounds.filter((round) => round.deltaRecheck !== undefined);
+    const classifications = new Map(facts.reviewRounds.map((round) => [round.id, classifyReviewRoundOutcome(round, evidence)]));
+    const semanticRounds = facts.reviewRounds.filter((round) => (classifications.get(round.id)?.kind === "semantic"));
+    const p1P2Findings = facts.reviewFindings.filter((finding) => ((finding.severity === "p1" || finding.severity === "p2")
+        && semanticRounds.some((round) => round.id === finding.firstReviewRoundId))).length;
+    const candidateTimes = [
+        ...facts.changeSets.map(({ createdAt }) => createdAt),
+        ...facts.workItems.flatMap((item) => item.candidates
+            .filter((candidate) => candidate.gitSnapshot !== undefined
+            || candidate.taskMainSnapshot?.projects.some((project) => (project.baseCommit !== project.headCommit)))
+            .map(({ createdAt }) => createdAt))
+    ].sort();
+    const firstCommitAt = candidateTimes[0];
+    const integrationIdentities = new Map();
+    for (const job of facts.durableJobs) {
+        if (job.owner.kind !== "integration-attempt")
+            continue;
+        const integrationAttemptId = job.owner.integrationAttemptId;
+        const attempt = facts.integrations.find(({ id }) => id === integrationAttemptId);
+        if (attempt === undefined || attempt.jobId !== job.id)
+            continue;
+        const identity = `${attempt.projectId}\0${job.head}\0${JSON.stringify(attempt.checkCommands)}`;
+        integrationIdentities.set(identity, (integrationIdentities.get(identity) ?? 0) + 1);
+    }
+    const repeatedIdentities = [...integrationIdentities.values()]
+        .reduce((total, count) => total + Math.max(0, count - 1), 0);
+    const leaderSessions = facts.roleSessionSets.find(({ owner }) => owner.roleName === "leader") ?? null;
+    const firstProgress = projectFirstProgressStopLoss({
+        sessions: leaderSessions,
+        events: facts.events,
+        workItems: facts.workItems,
+        reviewRounds: facts.reviewRounds,
+        integrations: facts.integrations
+    });
+    const advisories = projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, firstProgress.exhausted);
+    const publicationAt = facts.task.completedAt === undefined
+        ? undefined
+        : facts.publications
+            .map((reference) => reference.mergedAt ?? reference.createdAt)
+            .filter((timestamp) => timestamp <= facts.task.completedAt)
+            .sort()
+            .at(-1);
+    return Object.freeze({
+        taskId: facts.task.id,
+        deliveryPath: taskDeliveryPath(facts.task),
+        timeToFirstProjectCommitMs: firstCommitAt === undefined
+            ? null
+            : Math.max(0, Date.parse(firstCommitAt) - Date.parse(facts.task.createdAt)),
+        runs: {
+            total: facts.runs.length,
+            byStatus: counts(facts.runs.map(({ status }) => status)),
+            byRole: counts(facts.runs.map(({ roleName }) => roleName))
+        },
+        workItems: facts.workItems.length,
+        reviews: {
+            full: fullRounds.length,
+            delta: deltaRounds.length,
+            nonSemantic: [...classifications.values()].filter((value) => value?.kind === "non-semantic").length,
+            ambiguous: [...classifications.values()].filter((value) => value?.kind === "ambiguous").length,
+            p1P2Findings,
+            p1P2FindingsPerSemanticReview: semanticRounds.length === 0
+                ? 0
+                : p1P2Findings / semanticRounds.length
+        },
+        integrations: {
+            attempts: facts.integrations.length,
+            failed: facts.integrations.filter(({ status }) => status === "failed").length,
+            repeatedIdentities,
+            evidenceReuses: facts.integrations.filter((attempt) => ((attempt.checks ?? []).some(({ details }) => details?.startsWith("Reused successful check evidence from ")))).length
+        },
+        providerGenerationsBeforeFirstProgress: firstProgress.generationsBeforeFirstProgress,
+        publicationToCompletionMs: publicationAt === undefined || facts.task.completedAt === undefined
+            ? null
+            : Math.max(0, Date.parse(facts.task.completedAt) - Date.parse(publicationAt)),
+        terminalWorkspaceCount: terminalWorkspaceCount(facts),
+        advisories
+    });
+}
+function projectAdvisories(facts, classifications, fullRounds, repeatedIdentities, stopLoss) {
+    const result = [];
+    if (taskDeliveryPath(facts.task) === "direct"
+        && (facts.workItems.length > 0 || facts.reviewRounds.length > 0 || facts.integrations.length > 0)) {
+        result.push({
+            code: "direct-protocol-overhead",
+            reason: "Direct delivery accumulated WorkItem, Review, or Integration protocol overhead; keep the fix Leader-direct or explicitly promote it to integrated delivery.",
+            refs: [
+                ...facts.workItems.map(({ id }) => `work-item:${id}`),
+                ...facts.reviewRounds.map(({ id }) => `review-round:${id}`),
+                ...facts.integrations.map(({ id }) => `integration-attempt:${id}`)
+            ]
+        });
+    }
+    const initial = facts.workItems.filter(({ dependsOn }) => dependsOn.length === 0);
+    if (taskDeliveryPath(facts.task) === "integrated" && initial.length > 1) {
+        result.push({
+            code: "guarded-workitem-fanout",
+            reason: `${initial.length} initial WorkItems were created for an integrated Task; start with one bounded fix unless independence is explicit.`,
+            refs: initial.map(({ id }) => `work-item:${id}`)
+        });
+    }
+    const repairItems = facts.workItems.filter((item) => (item.acceptance.some((line) => line.startsWith("review-finding:"))));
+    const byRound = new Map();
+    for (const item of repairItems) {
+        const roundIds = new Set(item.acceptance.flatMap((line) => {
+            const findingId = line.startsWith("review-finding:") ? line.slice("review-finding:".length) : "";
+            const finding = facts.reviewFindings.find(({ id }) => id === findingId);
+            return finding === undefined ? [] : [finding.firstReviewRoundId];
+        }));
+        for (const roundId of roundIds)
+            byRound.set(roundId, [...(byRound.get(roundId) ?? []), item]);
+    }
+    for (const [roundId, items] of byRound) {
+        if (items.length < 2 || hasRepairFanoutDecision(facts.decisions, roundId, items))
+            continue;
+        result.push({
+            code: "review-repair-fanout",
+            reason: `Findings from Review ${roundId} were split across ${items.length} WorkItems without a durable Decision explaining independent ownership.`,
+            refs: [`review-round:${roundId}`, ...items.map(({ id }) => `work-item:${id}`)]
+        });
+    }
+    if (repeatedIdentities > 0) {
+        result.push({
+            code: "repeated-integration-check",
+            reason: `${repeatedIdentities} Integration DurableJob(s) reran the same candidate commit and ordered checks.`,
+            refs: facts.durableJobs
+                .filter(({ owner }) => owner.kind === "integration-attempt")
+                .map(({ id }) => `durable-job:${id}`)
+        });
+    }
+    const semanticFull = fullRounds.filter((round) => classifications.get(round.id)?.kind === "semantic")
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    const recent = semanticFull.slice(-3);
+    const recentIds = new Set(recent.map(({ id }) => id));
+    const newFinding = facts.reviewFindings.some(({ firstReviewRoundId }) => recentIds.has(firstReviewRoundId));
+    if (semanticFull.length > 2 && !newFinding) {
+        result.push({
+            code: "review-budget-exhausted",
+            reason: `${semanticFull.length} full semantic Reviews ran and the latest three produced no new finding; stop repeating full rounds without a changed head or new risk.`,
+            refs: recent.map(({ id }) => `review-round:${id}`)
+        });
+    }
+    if (stopLoss) {
+        result.push({
+            code: "provider-first-progress-stop-loss",
+            reason: "Two fresh Leader generations produced no first durable progress; hand off to the unique Operator before another generation.",
+            refs: [facts.task.id]
+        });
+    }
+    return result;
+}
+function hasRepairFanoutDecision(decisions, roundId, items) {
+    return decisions.some((decision) => {
+        const text = `${decision.title}\n${decision.rationale}`;
+        return text.includes(roundId) && items.every(({ id }) => text.includes(id));
+    });
+}
+function terminalWorkspaceCount(facts) {
+    return facts.managedWorkspaces.filter(({ owner }) => {
+        if (owner.type === "task")
+            return false;
+        if (owner.type === "work-item") {
+            return terminalStatus(facts.workItems.find(({ id }) => id === owner.workItemId)?.status);
+        }
+        if (owner.type === "review-round") {
+            return terminalStatus(facts.reviewRounds.find(({ id }) => id === owner.reviewRoundId)?.status);
+        }
+        if (owner.type === "integration-attempt") {
+            return terminalStatus(facts.integrations.find(({ id }) => id === owner.integrationAttemptId)?.status);
+        }
+        if (owner.workItemId !== undefined) {
+            return terminalStatus(facts.workItems.find(({ id }) => id === owner.workItemId)?.status);
+        }
+        return owner.reviewRoundId !== undefined
+            && terminalStatus(facts.reviewRounds.find(({ id }) => id === owner.reviewRoundId)?.status);
+    }).length;
+}
+function terminalStatus(status) {
+    return status !== undefined && !["pending", "running", "awaiting_acceptance", "blocked", "validating"].includes(status);
+}
+function counts(values) {
+    const result = {};
+    for (const value of values)
+        result[value] = (result[value] ?? 0) + 1;
+    return Object.freeze(result);
+}

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/gitWorkspace.js

@@ -15,15 +15,18 @@ export class RemoteBaselineConflictError extends Error {
 }
 /** The small Git boundary used by project registration and Task workspaces. */
 export class NodeGitWorkspace {
+    async resolveTree(repositoryPath, commit) {
+        return gitLine([
+            "-C", repositoryPath,
+            "rev-parse", "--verify", "--end-of-options", `${commit}^{tree}`
+        ]);
+    }
     async findCommitWithSameTreeInHistory(input) {
         const source = (await this.inspect(input.repositoryPath, input.sourceCommit)).baseCommit;
         const history = (await this.inspect(input.repositoryPath, input.historyHead)).baseCommit;
         if (await this.isAncestor(input.repositoryPath, source, history))
             return source;
-        const sourceTree = await gitLine([
-            "-C", input.repositoryPath,
-            "rev-parse", "--verify", "--end-of-options", `${source}^{tree}`
-        ]);
+        const sourceTree = await this.resolveTree(input.repositoryPath, source);
         const pageSize = 1000;
         for (let skip = 0;; skip += pageSize) {
             const output = await git([

package/dist/repository/taskBaseFreshness.js

@@ -107,10 +107,12 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     }));
     return { taskId, refreshed: options.refresh === true, entries };
 }
-export function assertTaskBaseFreshnessForCompletion(report) {
+export function assertTaskBaseFreshnessForCompletion(report, options = {}) {
     const warnings = [];
     for (const entry of report.entries) {
-        if (entry.status === "behind" || entry.status === "diverged") {
+        const acceptedPublishedTree = options.acceptedPublishedTreeProjectId === entry.projectId;
+        if ((entry.status === "behind" || entry.status === "diverged")
+            && !acceptedPublishedTree) {
             throw usageError(`Task ${report.taskId} Project ${entry.projectId} base is ${entry.status}; `
                 + `run 'yui task base status ${report.taskId} --refresh' and choose an explicit delivery base. `
                 + "Safe resolutions are to rebase or merge the Task workspace onto the refreshed remote base, "

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);