@nanmicoder/dsh-agent-teams 0.1.22 → 0.1.23

package/lib/quality-gates.js

@@ -111,13 +111,19 @@ export function pathMatchesScope(path, pattern) {
     }
     return normalizedPath === normalizedPattern;
 }
-function isDefaultExcluded(path) {
+/**
+ * Paths no quality contract may claim: version control, harness/plugin state,
+ * secrets and private keys. Exported because the completion gate and contract
+ * generation (including the artifact reader that must not walk into
+ * `.agent-teams/`, `secrets/` or `.env*`) have to share exactly one predicate.
+ */
+export function isDefaultExcludedPath(path) {
     const normalized = normalizeWorkspacePath(path);
     if (normalized === undefined)
         return false;
     const segments = normalized.split('/');
     const base = segments[segments.length - 1] ?? '';
-    if (segments[0] === '.git' || segments[0] === '.dsh')
+    if (segments[0] === '.git' || segments[0] === '.dsh' || segments[0] === '.agent-teams')
         return true;
     if (base === '.env' || base.startsWith('.env.'))
         return true;
@@ -127,6 +133,9 @@ function isDefaultExcluded(path) {
         return true;
     return false;
 }
+function isDefaultExcluded(path) {
+    return isDefaultExcludedPath(path);
+}
 export function classifyChangedPath(path, inScope = [], outOfScope = []) {
     if (normalizeWorkspacePath(path) === undefined)
         return 'illegal';
@@ -430,29 +439,77 @@ const REPAIR_SCOPE_LINE_SUFFIX = /:\d+$/;
  * forbids, so no honest completion exists and the repair dead-locks.
  *
  * Absolute and otherwise illegal paths are dropped (they can never match
- * workspace-relative scope patterns anyway); when nothing legal remains,
- * the source task's own inScope is kept as the fallback. Over-inclusion is
- * accepted: inScope is an audit upper bound, and the requiredFix text still
- * tells the implementer what to touch.
+ * workspace-relative scope patterns anyway), and so are paths the completion
+ * gate refuses by default (`secrets/` segments, `.env*`, `.git`, `.dsh`,
+ * `id_rsa*` — issue #183). `classifyChangedPath` checks that default-exclusion
+ * set BEFORE inScope, so collecting such a path here would generate a contract
+ * that demands an edit the gate calls `out_of_scope`: no honest completion
+ * exists and the repair burns its rounds. Contract generation and the
+ * completion gate must agree; the exemption channel stays the user-configured
+ * outOfScope list, never a reviewer's finding.
  *
- * Keep all derived paths until the generator resolves inherited exclusions;
- * filtering first would silently discard a required fix target.
+ * When nothing legal remains, the source task's own inScope is kept as the
+ * fallback. Over-inclusion is accepted otherwise: inScope is an audit upper
+ * bound, and the requiredFix text still tells the implementer what to touch.
+ * Keep every remaining derived path until the generator resolves inherited
+ * exclusions; filtering those first would silently discard a required fix
+ * target.
  */
 export function repairScopeFromFindings(findings, fallback) {
     const derived = [];
+    for (const finding of findings) {
+        for (const path of findingDerivedPaths(finding)) {
+            if (isDefaultExcludedPath(path) || derived.includes(path))
+                continue;
+            derived.push(path);
+        }
+    }
+    return derived.length > 0 ? derived : fallback === undefined ? undefined : [...new Set(fallback)];
+}
+/**
+ * Every workspace-relative path one finding names, before any exclusion rule:
+ * the observed file plus the fix targets referenced by `requiredFix`.
+ */
+export function findingDerivedPaths(finding) {
+    const paths = [];
     const push = (raw) => {
         const normalized = normalizeWorkspacePath(raw.replace(REPAIR_SCOPE_LINE_SUFFIX, ''));
-        if (normalized === undefined || derived.includes(normalized))
+        if (normalized === undefined || paths.includes(normalized))
             return;
-        derived.push(normalized);
+        paths.push(normalized);
     };
-    for (const finding of findings) {
-        if (nonemptyString(finding.file))
-            push(finding.file);
-        for (const match of finding.requiredFix.matchAll(REPAIR_SCOPE_PATH_PATTERN))
-            push(match[0]);
-    }
-    return derived.length > 0 ? derived : fallback === undefined ? undefined : [...new Set(fallback)];
+    if (nonemptyString(finding.file))
+        push(finding.file);
+    for (const match of finding.requiredFix.matchAll(REPAIR_SCOPE_PATH_PATTERN))
+        push(match[0]);
+    return paths;
+}
+/**
+ * Findings whose every cited path is default-excluded. They cannot become an
+ * honest repair contract (see {@link repairScopeFromFindings}), so they are
+ * surfaced to the captain instead of silently disappearing or dead-locking a
+ * member. A finding that names no path at all is NOT excluded: it simply falls
+ * back to the judged task's own scope, exactly as before.
+ */
+export function excludedFindingsOf(findings, pathExists) {
+    return findings.filter((finding) => {
+        const paths = findingDerivedPaths(finding);
+        if (paths.length === 0)
+            return false;
+        const own = normalizeWorkspacePath(finding.file ?? '');
+        return paths.every((path) => {
+            if (isDefaultExcludedPath(path))
+                return true;
+            // A path extracted from prose that does not exist is not something the
+            // workspace can act on (real run: "console/stream write" became a
+            // repair scope while the finding's actual target was excluded). The
+            // finding's own `file` always counts, so "create this new file" stays
+            // actionable.
+            if (pathExists === undefined || path === own)
+                return false;
+            return !pathExists(path);
+        });
+    });
 }
 const AMENDABLE_CONTRACT_FIELDS = ['objective', 'acceptance', 'verify', 'inScope', 'outOfScope'];
 /**
@@ -576,21 +633,77 @@ function withoutScopeConflicts(outOfScope, inScope) {
     const conflicting = new Set(inScopeOverlap(outOfScope, inScope ?? []));
     return outOfScope.filter((pattern) => !conflicting.has(pattern));
 }
-export function planQualityFollowUp(team, closed) {
+/**
+ * Line anchors (`file.ts:42`, `deliver.go:503-505`) cannot survive an edit
+ * anywhere above them, so generated text never asserts one. Callers locate the
+ * cited code by content anchor instead. Fully anchored numbers (`12:30`, a
+ * version, a URL port) are left alone.
+ */
+const LINE_ANCHOR_PATTERN = /(?<!\/\/)(?<=[A-Za-z_./\\-][A-Za-z0-9_./\\-]*):\d+(?:-\d+)?\b/gu;
+/** Remove drifting line anchors from generated contract text. */
+export function stripLineAnchors(text) {
+    return text.replaceAll(LINE_ANCHOR_PATTERN, '');
+}
+/**
+ * Acceptance items derived from a failed verification: the concrete failures
+ * the member must resolve. A verification carries no review findings, so the
+ * generator uses the evidence the task itself recorded.
+ */
+function verificationFailureAcceptance(closed) {
+    const items = [];
+    for (const result of closed.acceptanceResults ?? []) {
+        if (result.status === 'failed')
+            items.push(`Satisfy the failed acceptance item recorded by ${closed.id}: ${stripLineAnchors(result.criterion)}`);
+    }
+    for (const command of closed.commandsRun ?? []) {
+        if (command.status !== 'failed')
+            continue;
+        items.push(`Make \`${command.command}\` pass (it failed${command.exitCode === undefined ? '' : ` with exit code ${command.exitCode}`})`);
+    }
+    if (items.length === 0) {
+        items.push(`Resolve what failed in ${closed.id}${closed.output === undefined ? '' : `: ${closed.output.slice(0, 200)}`}`);
+    }
+    return items;
+}
+/**
+ * What the generator tells the member about a work order it derived from
+ * someone else's findings. The plugin cannot verify a finding's claims (a
+ * target count, a symbol that still exists, an action the product supports),
+ * and says so instead of lending them authority.
+ */
+function generatedRepairDescription(closed, excluded) {
+    const lines = [
+        `Auto-generated repair round derived from the findings of ${closed.id} (${taskKindOf(closed)}).`,
+        'The plugin did not verify the finding text: line numbers were removed because an edit anywhere above them invalidates them, and claims such as a target count, a symbol that still exists, or an action the product supports are the reporter\'s, not confirmed facts. Locate the cited code by content anchor (symbol, string, call site) and check every acceptance item against the current workspace before editing; if an item is already satisfied or impossible as written, report that instead of forcing a change.',
+    ];
+    if (excluded.length > 0) {
+        lines.push(`Excluded from this contract on purpose: ${excluded.map((finding) => finding.file ?? finding.id).join(', ')} — the completion gate refuses those paths by default, so they need a human decision rather than a member edit.`);
+    }
+    return lines.join(' ');
+}
+export function planQualityFollowUp(team, closed, options = {}) {
     const empty = { created: [], tasks: [] };
+    const escalate = (reason) => ({ ...empty, escalated: true, status: 'escalated', reason });
     const kind = taskKindOf(closed);
-    if ((kind !== 'review' && kind !== 'requirements') || closed.status !== 'failed')
+    if (closed.status !== 'failed')
         return empty;
-    if (closed.verdict === 'reject')
-        return { ...empty, escalated: true, status: 'escalated' };
-    if (closed.verdict !== 'needs_revision')
+    if (kind === 'review' || kind === 'requirements') {
+        if (closed.verdict === 'reject')
+            return escalate(`${closed.id} returned verdict=reject; automatic repair is not a substitute for a human decision`);
+        if (closed.verdict !== 'needs_revision')
+            return empty;
+    }
+    else if (kind !== 'verification') {
+        // Both quality gates share the findings → repair → re-check contract, so
+        // a failed verification self-heals exactly like a failed review (#175B).
         return empty;
+    }
     const policy = resolveReviewPolicy(team.reviewPolicy);
     const currentRound = closed.round ?? 1;
     const nextRound = currentRound + 1;
     const maxRounds = kind === 'requirements' ? policy.requirementsMaxRounds : policy.codeMaxRounds;
     if (nextRound > maxRounds)
-        return { ...empty, escalated: true, status: 'escalated' };
+        return escalate(`${closed.id} reached the ${kind} round ceiling (${maxRounds}); the loop cannot open round ${nextRound}`);
     if (kind === 'requirements') {
         const next = {
             kind: 'requirements',
@@ -603,49 +716,87 @@ export function planQualityFollowUp(team, closed) {
         };
         return { created: [next], tasks: [next] };
     }
-    const sourceId = closed.reviewedTaskId ?? closed.sourceTaskId;
+    const target = reviewedTargetOf(team, closed);
+    const sourceId = closed.reviewedTaskId ?? closed.sourceTaskId ?? target?.id;
     if (sourceId === undefined)
         return empty;
     const source = team.tasks.find((item) => item.id === sourceId);
     const findings = unresolvedFindings(closed);
-    const findingIds = findings.map((finding) => finding.id);
+    const excluded = excludedFindingsOf(findings, options.pathExists);
+    const actionable = findings.filter((finding) => !excluded.includes(finding));
+    if (findings.length > 0 && actionable.length === 0) {
+        return {
+            ...empty,
+            escalated: true,
+            status: 'escalated',
+            reason: `every finding of ${closed.id} cites only default-excluded paths (${excluded.map((finding) => finding.file ?? finding.id).join(', ')}); the completion gate classifies those out_of_scope, so no honest repair contract exists — a human must decide`,
+            excludedFindings: excluded.map((finding) => finding.id),
+        };
+    }
+    const findingIds = actionable.map((finding) => finding.id);
     if (hasOpenFollowUp(team, sourceId, findingIds))
         return empty;
     if (countRepairAttempts(team, sourceId, findingIds) >= policy.maxRepairAttempts) {
-        return { ...empty, escalated: true, status: 'escalated' };
+        return escalate(`${sourceId} already used ${policy.maxRepairAttempts} automatic repair attempts for these findings`);
     }
-    // inScope is derived from the findings below: the observed file plus any
-    // workspace-relative paths referenced by the requiredFix instructions.
-    const repairScope = repairScopeFromFindings(findings, source?.inScope);
+    // inScope is derived from the actionable findings below: the observed file
+    // plus any workspace-relative paths referenced by the requiredFix
+    // instructions, minus everything the completion gate refuses by default.
+    const repairScope = repairScopeFromFindings(actionable, source?.inScope);
+    const verifyCommands = source?.verify ?? closed.verify;
     const implementer = schedulableAssignee(source?.assignee, team);
+    // The causal edge to the failed gate is recorded explicitly: it cannot be a
+    // `dependencies` entry, because a failed task never reaches `completed` and
+    // `unsatisfiedDependencies` would then make this repair unclaimable forever.
+    const repairDependencies = [sourceId];
     const repair = {
         id: `repair-round-${nextRound}`,
         kind: 'repair',
         subject: `repair-round-${nextRound}`,
+        description: generatedRepairDescription(closed, excluded),
         assignee: implementer,
-        dependencies: [sourceId],
+        dependencies: repairDependencies,
         round: nextRound,
         objective: source?.objective ?? closed.objective ?? `Fix findings from ${sourceId}`,
         inScope: repairScope,
         outOfScope: withoutScopeConflicts(source?.outOfScope, repairScope),
-        verify: source?.verify,
-        acceptance: findings.map((finding) => finding.requiredFix),
+        verify: verifyCommands,
+        acceptance: actionable.length > 0
+            ? actionable.map((finding) => stripLineAnchors(finding.requiredFix))
+            : verificationFailureAcceptance(closed),
         sourceTaskId: sourceId,
         sourceFindingIds: findingIds,
+        findingSourceTaskIds: [closed.id],
+        contractPaths: repairScope,
     };
-    const reviewer = schedulableAssignee(closed.assignee !== implementer ? closed.assignee : undefined, team, implementer);
-    const review = {
-        id: `review-round-${nextRound}`,
-        kind: 'review',
-        subject: `review-round-${nextRound}`,
-        assignee: reviewer,
-        dependencies: [repair.id ?? `repair-round-${nextRound}`],
-        round: nextRound,
-        objective: sanitizeReviewObjective(closed.objective, DEFAULT_REVIEW_OBJECTIVE),
-        acceptance: sanitizeReviewAcceptance(closed.acceptance),
-        reviewedTaskId: repair.id,
-    };
-    return { created: [repair, review], tasks: [repair, review] };
+    const checker = schedulableAssignee(closed.assignee !== implementer ? closed.assignee : undefined, team, implementer);
+    const recheck = kind === 'verification'
+        ? {
+            id: `verification-round-${nextRound}`,
+            kind: 'verification',
+            subject: `verification-round-${nextRound}`,
+            assignee: checker,
+            dependencies: [repair.id ?? `repair-round-${nextRound}`],
+            round: nextRound,
+            objective: closed.objective ?? `Re-verify ${sourceId} after ${repair.id ?? `repair-round-${nextRound}`}`,
+            acceptance: sanitizeReviewAcceptance(closed.acceptance),
+            verify: verifyCommands,
+        }
+        : {
+            id: `review-round-${nextRound}`,
+            kind: 'review',
+            subject: `review-round-${nextRound}`,
+            assignee: checker,
+            dependencies: [repair.id ?? `repair-round-${nextRound}`],
+            round: nextRound,
+            objective: sanitizeReviewObjective(closed.objective, DEFAULT_REVIEW_OBJECTIVE),
+            acceptance: sanitizeReviewAcceptance(closed.acceptance),
+            reviewedTaskId: repair.id,
+        };
+    const result = { created: [repair, recheck], tasks: [repair, recheck] };
+    if (excluded.length > 0)
+        result.excludedFindings = excluded.map((finding) => finding.id);
+    return result;
 }
 export function buildCoverageMatrix(goalItems, tasks) {
     return goalItems.map((goalItem) => {
@@ -662,8 +813,520 @@ export function buildCoverageMatrix(goalItems, tasks) {
         return { goal_item: goalItem, task_ids: taskIds, status: 'in_progress' };
     });
 }
-export function canDeclareDelivery(team) {
+/* ------------------------------------------------------------------------ *
+ * Content-bound verdicts (issue #161) and generated work orders (issue #174) *
+ * ------------------------------------------------------------------------ */
+const VERDICT_KINDS = ['review', 'requirements', 'verification'];
+/** Kinds whose completion is a verdict about a revision. */
+export function isVerdictKind(kind) {
+    return kind !== undefined && VERDICT_KINDS.includes(kind);
+}
+function shortDigest(value) {
+    return value === undefined || value === '' ? 'absent' : value.slice(0, 8);
+}
+/**
+ * Compare recorded bytes against the bytes on disk now, keeping the path each
+ * reason belongs to. "Cannot be read" is reported as its own reason: a
+ * permission error is not a match, and a partial read is not proof of an
+ * unchanged file.
+ */
+export function artifactDriftDetails(recorded, current) {
+    if (recorded === undefined || recorded.length === 0 || current === undefined)
+        return [];
+    const now = new Map(current.map((item) => [item.path, item]));
+    const drift = [];
+    for (const before of recorded) {
+        const after = now.get(before.path);
+        if (after === undefined) {
+            drift.push({ path: before.path, message: `${before.path} was not in the current workspace snapshot` });
+            continue;
+        }
+        if (after.unreadable === true) {
+            drift.push({ path: after.path, message: `${after.path} cannot be read now (${after.reason ?? 'unknown error'}), so its recorded bytes cannot be confirmed` });
+            continue;
+        }
+        if (before.unreadable === true) {
+            drift.push({ path: before.path, message: `${before.path} was not readable when this evidence was recorded (${before.reason ?? 'unknown error'}), so it never covered those bytes` });
+            continue;
+        }
+        if (before.present !== after.present) {
+            drift.push({
+                path: before.path,
+                message: after.present
+                    ? `${before.path} was absent when recorded and now exists`
+                    : `${before.path} was deleted after it was recorded`,
+            });
+            continue;
+        }
+        if (before.present && after.present && before.sha256 !== after.sha256) {
+            drift.push({ path: before.path, message: `${before.path} changed (sha256 ${shortDigest(before.sha256)} -> ${shortDigest(after.sha256)})` });
+        }
+    }
+    return drift;
+}
+/** Message-only view of {@link artifactDriftDetails}. */
+export function artifactDrift(recorded, current) {
+    return artifactDriftDetails(recorded, current).map((detail) => detail.message);
+}
+/** A partially enumerated scope is incomplete evidence, never a silent pass. */
+export function gapDrift(gaps) {
+    return (gaps ?? []).map((gap) => `${gap.pattern}: ${gap.reason}`);
+}
+/**
+ * The task a verdict is about: an explicit `reviewedTaskId`/`sourceTaskId`
+ * first, otherwise the implementation/repair this gate depends on.
+ */
+export function reviewedTargetOf(team, task) {
+    const explicit = task.reviewedTaskId ?? task.sourceTaskId;
+    if (explicit !== undefined) {
+        const found = team.tasks.find((item) => item.id === explicit);
+        if (found !== undefined)
+            return found;
+    }
+    for (const dependency of task.dependencies) {
+        const candidate = team.tasks.find((item) => item.id === dependency);
+        if (candidate !== undefined && (taskKindOf(candidate) === 'implementation' || taskKindOf(candidate) === 'repair')) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+export function bindReviewToRevision(team, task, binding) {
+    const target = reviewedTargetOf(team, task);
+    if (target === undefined || binding.artifacts.length === 0)
+        return task;
+    const kind = taskKindOf(task);
+    return {
+        ...task,
+        ...kind === 'review' || kind === 'requirements' ? { reviewedTaskId: task.reviewedTaskId ?? target.id } : {},
+        reviewedAttempt: target.attempt ?? 0,
+        reviewedArtifacts: binding.artifacts.map((item) => ({ ...item })),
+        ...binding.gaps === undefined || binding.gaps.length === 0 ? {} : { reviewedGaps: binding.gaps.map((gap) => ({ ...gap })) },
+        ...binding.scope === undefined || binding.scope.length === 0 ? {} : { reviewedScope: [...binding.scope] },
+        ...binding.duringDrift === undefined || binding.duringDrift.length === 0 ? {} : { reviewedDuringDrift: [...binding.duringDrift] },
+    };
+}
+/**
+ * Scope a verdict must bind: the paths the judged task changed, otherwise the
+ * scope patterns of its contract (expanded by the caller).
+ */
+export function verdictScopePatterns(team, task) {
+    const lineage = verdictLineageTasks(team, task);
+    // Every implementation/repair this gate transitively judges: the original
+    // source AND the repairs that followed it. A pre-planned review whose edge
+    // was rewired to a re-verification must still bind the bytes the original
+    // source changed, otherwise a later edit to the repair's target would have
+    // no valid review evidence at all (#161 x #175).
+    const changed = new Set();
+    for (const item of lineage) {
+        const kind = taskKindOf(item);
+        if (kind !== 'implementation' && kind !== 'repair')
+            continue;
+        for (const path of item.changedPaths ?? []) {
+            const normalized = normalizeWorkspacePath(path);
+            if (normalized !== undefined)
+                changed.add(normalized);
+        }
+    }
+    if (changed.size > 0)
+        return [...changed];
+    const scope = new Set([
+        ...(task.inScope ?? []),
+        ...lineage.flatMap((item) => item.inScope ?? []),
+    ]);
+    if (scope.size > 0)
+        return [...scope];
+    return (reviewedTargetOf(team, task)?.deliverables ?? [])
+        .map((path) => normalizeWorkspacePath(path))
+        .filter((path) => path !== undefined);
+}
+/**
+ * The artifacts a gate transitively judges: follow explicit review/source
+ * links and dependency edges (a repair records the source it fixes, a
+ * verification depends on the repair, a review depends on the verification).
+ */
+function verdictLineageTasks(team, task) {
+    const byId = new Map(team.tasks.map((item) => [item.id, item]));
+    const visited = new Set();
+    const queue = [...task.dependencies];
+    const explicit = task.reviewedTaskId ?? task.sourceTaskId;
+    if (explicit !== undefined)
+        queue.push(explicit);
+    const target = reviewedTargetOf(team, task);
+    if (target !== undefined && target.id !== task.id)
+        queue.push(target.id);
+    const found = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const item = byId.get(id);
+        if (item === undefined)
+            continue;
+        found.push(item);
+        queue.push(...item.dependencies);
+        const link = item.reviewedTaskId ?? item.sourceTaskId;
+        if (link !== undefined)
+            queue.push(link);
+    }
+    return found;
+}
+/** Scope patterns recorded verdicts bound, for new-file detection. */
+export function deliveryScopePatterns(team) {
+    const patterns = new Set();
+    for (const task of team.tasks) {
+        const kind = taskKindOf(task);
+        if (!VERDICT_KINDS.includes(kind) || task.status !== 'completed')
+            continue;
+        for (const pattern of task.reviewedScope ?? [])
+            patterns.add(pattern);
+    }
+    return [...patterns];
+}
+function isDirectoryPattern(pattern) {
+    const trimmed = pattern.trim();
+    return trimmed.endsWith('/') || trimmed === '.' || trimmed === './';
+}
+/** Root of the artifact lineage a gate judges (the implementation/repair chain). */
+function lineageRoot(team, task) {
+    let current = task;
+    const visited = new Set();
+    while (!visited.has(current.id)) {
+        visited.add(current.id);
+        const nextId = current.reviewedTaskId ?? current.sourceTaskId ?? current.dependencies[0];
+        const next = nextId === undefined ? undefined : team.tasks.find((item) => item.id === nextId);
+        if (next === undefined)
+            break;
+        current = next;
+    }
+    if (current.id === task.id) {
+        const kind = taskKindOf(task);
+        return kind === 'implementation' || kind === 'repair' ? task.id : undefined;
+    }
+    return current.id;
+}
+const VERDICT_WEIGHT = { verification: 1, review: 2, requirements: 2 };
+/**
+ * Does `candidate` cover `prior`'s evidence? A later sound verdict that either
+ * depends on the prior gate or judges the same artifact lineage supersedes it,
+ * so a legitimately changed revision does not block delivery forever behind an
+ * old snapshot.
+ */
+function supersedes(team, candidate, prior) {
+    if (candidate.id === prior.id || candidate.status !== 'completed')
+        return false;
+    if ((VERDICT_WEIGHT[taskKindOf(candidate)] ?? 0) < (VERDICT_WEIGHT[taskKindOf(prior)] ?? 0))
+        return false;
+    if (candidate.createdAt < prior.createdAt)
+        return false;
+    if (candidate.createdAt === prior.createdAt && (candidate.round ?? 0) <= (prior.round ?? 0))
+        return false;
+    if (dependencyClosureContains(team.tasks, candidate.dependencies, prior.id))
+        return true;
+    const candidateRoot = lineageRoot(team, candidate);
+    return candidateRoot !== undefined && candidateRoot === lineageRoot(team, prior);
+}
+/** Paths whose current bytes decide whether recorded verdicts and orders hold. */
+export function deliveryArtifactPaths(team) {
+    const paths = new Set();
+    for (const task of team.tasks) {
+        for (const artifact of task.reviewedArtifacts ?? [])
+            paths.add(artifact.path);
+        for (const artifact of task.contractSnapshot?.artifacts ?? [])
+            paths.add(artifact.path);
+    }
+    // Legacy verdicts carry no digests; the changed paths of the task they
+    // judged still let the delivery check detect a later edit by mtime.
+    for (const task of team.tasks) {
+        const kind = taskKindOf(task);
+        if (!VERDICT_KINDS.includes(kind))
+            continue;
+        if (task.status !== 'completed')
+            continue;
+        if ((task.reviewedArtifacts?.length ?? 0) > 0)
+            continue;
+        for (const changed of reviewedTargetOf(team, task)?.changedPaths ?? []) {
+            const normalized = normalizeWorkspacePath(changed);
+            if (normalized !== undefined)
+                paths.add(normalized);
+        }
+    }
+    return [...paths];
+}
+/**
+ * File mtimes carry sub-millisecond precision while task stamps are whole
+ * milliseconds, so a file written in the same millisecond as the verdict would
+ * otherwise read as "modified after". Only a clearly later write counts;
+ * content digests are exact and need no tolerance.
+ */
+const MTIME_TOLERANCE_MS = 1;
+function verdictDrift(team, item, audit) {
+    const issues = [];
+    const target = reviewedTargetOf(team, item);
+    if (target !== undefined && item.reviewedAttempt !== undefined && (target.attempt ?? 0) !== item.reviewedAttempt) {
+        issues.push({ message: `${target.id} was re-attempted after this verdict (attempt ${item.reviewedAttempt} -> ${target.attempt ?? 0})` });
+    }
+    for (const gap of gapDrift(item.reviewedGaps))
+        issues.push({ message: gap });
+    for (const drift of item.reviewedDuringDrift ?? []) {
+        issues.push({ message: `the workspace changed while this verdict was being formed (${drift}), so it does not bind a stable revision` });
+    }
+    const recorded = item.reviewedArtifacts;
+    // A file that appeared under a bound directory scope after the verdict was
+    // never reviewed: a broad scope must not quietly absorb new work.
+    const recordedPaths = new Set((recorded ?? []).map((artifact) => artifact.path));
+    for (const pattern of item.reviewedScope ?? []) {
+        if (!isDirectoryPattern(pattern))
+            continue;
+        for (const entry of audit.expandedScope ?? []) {
+            if (entry.present !== true || recordedPaths.has(entry.path))
+                continue;
+            if (!pathMatchesScope(entry.path, pattern))
+                continue;
+            issues.push({ path: entry.path, message: `${entry.path} appeared under the reviewed scope ${pattern} after the verdict and was never reviewed` });
+        }
+    }
+    if (recorded !== undefined && recorded.length > 0) {
+        issues.push(...artifactDriftDetails(recorded, audit.artifacts));
+        return issues;
+    }
+    // A record written before content-bound verdicts existed carries no digests,
+    // but the revision it judged is still identifiable: the bytes the target
+    // claimed to change cannot have been written after the verdict closed.
+    for (const changed of target?.changedPaths ?? []) {
+        const normalized = normalizeWorkspacePath(changed);
+        if (normalized === undefined)
+            continue;
+        const current = audit.artifacts?.find((artifact) => artifact.path === normalized);
+        if (current === undefined)
+            continue;
+        if (current.unreadable === true) {
+            issues.push({ path: normalized, message: `${normalized} cannot be read now (${current.reason ?? 'unknown error'}), so the verdict cannot be confirmed` });
+            continue;
+        }
+        if (current.present === true && current.mtimeMs !== undefined && current.mtimeMs > item.updatedAt + MTIME_TOLERANCE_MS) {
+            issues.push({ path: normalized, message: `${normalized} was modified after this verdict closed (file mtime is later than the verdict)` });
+            continue;
+        }
+        if (current.present !== true) {
+            // No digest was recorded, so the plugin cannot date the disappearance:
+            // the file the implementation changed is gone and the verdict cannot be
+            // confirmed against it. A later sound verdict supersedes this one.
+            issues.push({ path: normalized, message: `${normalized} is recorded as changed by ${target?.id ?? 'the judged task'} but no longer exists, and no digest was recorded to confirm the verdict` });
+        }
+    }
+    return issues;
+}
+/** A verdict whose evidence is absent altogether cannot be audited at all. */
+function unboundVerdict(item) {
+    return (item.reviewedArtifacts?.length ?? 0) === 0
+        && (item.reviewedGaps?.length ?? 0) === 0
+        && item.reviewedAttempt === undefined;
+}
+/**
+ * Audit every completed verdict against the current revision (issue #161).
+ *
+ * A drifted review/requirements pass is the delivery evidence itself, so it
+ * blocks — unless a later sound verdict covers the same lineage, which is the
+ * normal shape of `pass → repair → new pass` and must converge instead of
+ * blocking forever behind an old snapshot. A drifted `verification` or a
+ * superseded pass is reported as a warning: a later repair legitimately
+ * supersedes it, but never silently. A verdict that predates content binding
+ * is reported as an unauditable gap rather than being read as a pass over the
+ * current bytes.
+ */
+export function verdictAuditNotes(team, audit = {}) {
+    const notes = [];
+    const verdicts = team.tasks.filter((item) => {
+        const kind = taskKindOf(item);
+        if (!VERDICT_KINDS.includes(kind))
+            return false;
+        if (item.status !== 'completed')
+            return false;
+        return !((kind === 'review' || kind === 'requirements') && item.verdict !== 'pass');
+    });
+    const issues = new Map();
+    for (const item of verdicts) {
+        const found = verdictDrift(team, item, audit);
+        if (found.length > 0)
+            issues.set(item.id, found);
+    }
+    // Only a verdict that actually recorded the bytes it judged, over a complete
+    // scope, and that still matches the workspace may supersede an older one. An
+    // unbound (pre-fix) pass records no identity at all: it cannot "bind the
+    // current bytes" and must never clear another verdict's drift.
+    const sound = verdicts.filter((item) => !issues.has(item.id) && bindsRecordedRevision(team, item, audit));
+    for (const item of verdicts) {
+        const kind = taskKindOf(item);
+        const found = issues.get(item.id);
+        if (found === undefined) {
+            if (unboundVerdict(item) && audit.artifacts !== undefined) {
+                notes.push({
+                    taskId: item.id,
+                    level: 'warning',
+                    message: `${item.id} (${kind}) predates content-bound verdicts and recorded no artifact identity; delivery cannot confirm the current bytes are the revision it judged — re-review to bind them`,
+                });
+            }
+            continue;
+        }
+        const detail = `${item.id} (${kind}) verdict covers a revision that no longer exists: ${found.map((entry) => entry.message).join('; ')}`;
+        // Superseding needs the same lineage AND coverage of every drifted path or
+        // gap: a narrower new review over path A must not clear an unreviewed
+        // change to path B.
+        const covering = sound.find((candidate) => (supersedes(team, candidate, item) && coversDrift(team, candidate, item, found)));
+        if (covering !== undefined) {
+            notes.push({ taskId: item.id, level: 'warning', message: `${detail} — superseded by ${covering.id}, which binds the current bytes` });
+            continue;
+        }
+        // A drifted gate without a sound covering verdict leaves the current bytes
+        // with no valid evidence, whether it is a review or a verification: the
+        // only difference is what the captain has to do next.
+        if (kind === 'verification') {
+            notes.push({ taskId: item.id, level: 'blocker', message: `${detail} — re-verify the current bytes; no later sound verdict bound them` });
+            continue;
+        }
+        notes.push({ taskId: item.id, level: 'blocker', message: `${detail} — re-review the current bytes; do not report this revision as verified` });
+    }
+    return notes;
+}
+/**
+ * Does this verdict hold a real, complete, still-matching record of the bytes
+ * it judged? Attempt drift, an incomplete scope, or a workspace that moved
+ * while the gate was open all disqualify it.
+ */
+function bindsRecordedRevision(team, item, audit) {
+    if ((item.reviewedArtifacts?.length ?? 0) === 0)
+        return false;
+    if ((item.reviewedGaps?.length ?? 0) > 0)
+        return false;
+    if ((item.reviewedDuringDrift?.length ?? 0) > 0)
+        return false;
+    const target = reviewedTargetOf(team, item);
+    if (target !== undefined && item.reviewedAttempt !== undefined && (target.attempt ?? 0) !== item.reviewedAttempt)
+        return false;
+    if (audit.artifacts === undefined)
+        return false;
+    return artifactDriftDetails(item.reviewedArtifacts, audit.artifacts).length === 0;
+}
+/**
+ * A later verdict clears an older one only when it covers what actually
+ * drifted: every implicated path must be among the bytes it bound. Reasons
+ * that name no path (an incomplete scope, a re-attempted target, a workspace
+ * that moved mid-review) are cleared only by a sound verdict about the same
+ * target's current attempt.
+ */
+function coversDrift(team, candidate, prior, drifted) {
+    if (drifted.length === 0)
+        return false;
+    const bound = new Set((candidate.reviewedArtifacts ?? []).map((artifact) => artifact.path));
+    for (const issue of drifted) {
+        if (issue.path !== undefined) {
+            if (!bound.has(issue.path))
+                return false;
+            continue;
+        }
+        const candidateTarget = reviewedTargetOf(team, candidate);
+        const priorTarget = reviewedTargetOf(team, prior);
+        if (candidateTarget === undefined || priorTarget === undefined || candidateTarget.id !== priorTarget.id)
+            return false;
+        if (candidate.reviewedAttempt !== (candidateTarget.attempt ?? 0))
+            return false;
+        if (lineageRoot(team, candidate) === undefined || lineageRoot(team, candidate) !== lineageRoot(team, prior))
+            return false;
+    }
+    return true;
+}
+function verdictBindingIssues(team, audit) {
     const blockers = [];
+    const warnings = [];
+    for (const note of verdictAuditNotes(team, audit)) {
+        if (note.level === 'blocker')
+            blockers.push(note.message);
+        else
+            warnings.push(note.message);
+    }
+    return { blockers, warnings };
+}
+/** Staleness of one auto-generated work order against the current workspace. */
+export function contractStaleness(task, current) {
+    const snapshot = task.contractSnapshot;
+    if (snapshot === undefined)
+        return [];
+    const stale = [];
+    for (const gap of gapDrift(snapshot.gaps)) {
+        stale.push(`${task.id} work order recorded only partial coverage (${gap}), so a change outside it would not be visible`);
+    }
+    if (snapshot.artifacts.length === 0 || current === undefined)
+        return stale;
+    stale.push(...artifactDrift(snapshot.artifacts, current).map((item) => `${task.id} work order was generated before: ${item}`));
+    return stale;
+}
+/**
+ * Open auto-generated work orders whose cited bytes moved on (issue #174).
+ * A repair round's acceptance/inScope is a snapshot of the workspace at
+ * finding-generation time; every later round invalidates it, and nothing used
+ * to say so — a member following it literally edits the wrong line or redoes
+ * work that is already done.
+ */
+export function workOrderWarnings(team, current) {
+    if (current === undefined)
+        return [];
+    const warnings = [];
+    for (const task of team.tasks) {
+        if (task.contractSnapshot === undefined)
+            continue;
+        if (!OPEN_FOLLOW_UP_STATUSES.includes(task.status))
+            continue;
+        const stale = contractStaleness(task, current);
+        if (stale.length === 0)
+            continue;
+        warnings.push({
+            taskId: task.id,
+            message: `${stale.join('; ')}. Its auto-generated acceptance/inScope describe the workspace as it was then: locate the cited code by content anchor, and amend the contract if the target is gone.`,
+        });
+    }
+    return warnings;
+}
+/** Statuses in which a repair still counts as the follow-up of a failed gate. */
+const FOLLOW_UP_VISIBLE_STATUSES = ['pending', 'claimed', 'in_progress', 'completed'];
+/**
+ * Does a repair exist that addresses this failed gate's findings? The causal
+ * link can be recorded three ways, and all of them count: the repair's
+ * declared source, an explicit dependency edge on the failed gate, or the
+ * finding ids the repair was opened for (issue #175A — the transcript edge
+ * used to be invisible to the graph, so delivery reported
+ * `failed without a follow-up repair` for loops that were already closed).
+ */
+function hasFollowUpRepair(team, item) {
+    const kind = taskKindOf(item);
+    if (kind === 'requirements') {
+        return team.tasks.some((candidate) => (taskKindOf(candidate) === 'requirements' && (candidate.round ?? 1) > (item.round ?? 1)));
+    }
+    const findingIds = new Set((item.findings ?? []).map((finding) => finding.id));
+    const upstreams = new Set([item.id, item.reviewedTaskId ?? item.sourceTaskId].filter((id) => id !== undefined));
+    return team.tasks.some((candidate) => {
+        if (taskKindOf(candidate) !== 'repair' || !FOLLOW_UP_VISIBLE_STATUSES.includes(candidate.status))
+            return false;
+        if (candidate.sourceTaskId !== undefined && upstreams.has(candidate.sourceTaskId))
+            return true;
+        if (candidate.dependencies.includes(item.id))
+            return true;
+        if (candidate.findingSourceTaskIds?.includes(item.id) === true)
+            return true;
+        return candidate.sourceFindingIds !== undefined
+            && candidate.sourceFindingIds.some((findingId) => findingIds.has(findingId));
+    });
+}
+/** Failed gates with no follow-up at all: work that genuinely remains. */
+function unresolvedGates(team) {
+    return team.tasks.filter((item) => isQualityKind(taskKindOf(item))
+        && item.status === 'failed'
+        && !hasFollowUpRepair(team, item));
+}
+export function canDeclareDelivery(team, audit = {}) {
+    const blockers = [];
+    const warnings = [];
     if (team.phase === 'staged')
         blockers.push('team plan is awaiting approval');
     if (team.halted === true)
@@ -690,15 +1353,7 @@ export function canDeclareDelivery(team) {
             continue;
         }
         if (item.status === 'failed') {
-            const repaired = kind === 'review'
-                ? quality.some((candidate) => (taskKindOf(candidate) === 'repair'
-                    && candidate.sourceTaskId === (item.reviewedTaskId ?? item.sourceTaskId)
-                    && (candidate.status === 'pending' || candidate.status === 'claimed' || candidate.status === 'in_progress' || candidate.status === 'completed')))
-                : kind === 'requirements'
-                    ? quality.some((candidate) => (taskKindOf(candidate) === 'requirements'
-                        && (candidate.round ?? 1) > (item.round ?? 1)))
-                    : quality.some((candidate) => (taskKindOf(candidate) === 'repair' && candidate.sourceTaskId === item.id));
-            if (!repaired)
+            if (!hasFollowUpRepair(team, item))
                 blockers.push(`${item.id} failed without a follow-up repair`);
             continue;
         }
@@ -718,7 +1373,21 @@ export function canDeclareDelivery(team) {
             }
         }
     }
-    return { ok: blockers.length === 0, blockers };
+    const binding = verdictBindingIssues(team, audit);
+    blockers.push(...binding.blockers);
+    warnings.push(...binding.warnings);
+    if (audit.artifacts !== undefined) {
+        warnings.push(...workOrderWarnings(team, audit.artifacts).map((warning) => warning.message));
+    }
+    // An incomplete audit is not evidence: a scope that outgrew its cap, or a
+    // path that cannot be read, must block instead of passing as a clean read.
+    const auditGaps = audit.gaps ?? [];
+    if (auditGaps.length > 0 && (quality.length > 0 || blockers.length > 0 || audit.artifacts !== undefined)) {
+        const shown = auditGaps.slice(0, 3).map((gap) => `${gap.pattern}: ${gap.reason}`);
+        const more = auditGaps.length > shown.length ? ` (+${auditGaps.length - shown.length} more)` : '';
+        blockers.push(`the current workspace audit is incomplete (${shown.join('; ')}${more}); no recorded verdict can be confirmed over partially enumerated or unreadable artifacts`);
+    }
+    return { ok: blockers.length === 0, blockers, warnings };
 }
 export function resumeTeamState(team, reason) {
     if (!nonemptyString(reason)) {
@@ -737,6 +1406,14 @@ export function resumeTeamState(team, reason) {
         },
     };
 }
+/**
+ * The durable `findings[].line` contract, shared by the write-side parser
+ * (`parseFindings`) and the durable validator (`isReviewFinding`) so the two
+ * cannot drift apart again (issue #188, #105 class).
+ */
+export function isValidFindingLine(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
 export function isReviewFinding(value) {
     if (!isRecord(value))
         return false;
@@ -745,7 +1422,7 @@ export function isReviewFinding(value) {
         && nonemptyString(value['problem'])
         && nonemptyString(value['requiredFix'])
         && (value['file'] === undefined || nonemptyString(value['file']))
-        && (value['line'] === undefined || (Number.isSafeInteger(value['line']) && value['line'] >= 0))
+        && (value['line'] === undefined || isValidFindingLine(value['line']))
         && (value['resolved'] === undefined || typeof value['resolved'] === 'boolean');
 }
 export function isAcceptanceResult(value) {
@@ -772,7 +1449,40 @@ export function isTaskRevision(value) {
         && nonemptyStringList(value['fields'])
         && isRecord(value['previous']);
 }
-// Optional fields whose persisted values must be non-empty when present
+export function isArtifactDigest(value) {
+    if (!isRecord(value))
+        return false;
+    if (!nonemptyString(value['path']) || normalizeWorkspacePath(value['path']) === undefined)
+        return false;
+    if (typeof value['present'] !== 'boolean')
+        return false;
+    if (value['sha256'] !== undefined && !(typeof value['sha256'] === 'string' && /^[0-9a-f]{64}$/u.test(value['sha256'])))
+        return false;
+    if (value['size'] !== undefined && !(Number.isSafeInteger(value['size']) && value['size'] >= 0))
+        return false;
+    if (value['mtimeMs'] !== undefined && !(typeof value['mtimeMs'] === 'number' && Number.isFinite(value['mtimeMs'])))
+        return false;
+    if (value['unreadable'] !== undefined && typeof value['unreadable'] !== 'boolean')
+        return false;
+    if (value['reason'] !== undefined && !nonemptyString(value['reason']))
+        return false;
+    if (value['present'] === true && value['sha256'] === undefined)
+        return false;
+    return true;
+}
+export function isArtifactScopeGap(value) {
+    return isRecord(value) && nonemptyString(value['pattern']) && nonemptyString(value['reason']);
+}
+export function isArtifactSnapshot(value) {
+    if (!isRecord(value))
+        return false;
+    if (!Number.isSafeInteger(value['at']) || value['at'] < 0)
+        return false;
+    if (!Array.isArray(value['artifacts']) || !value['artifacts'].every(isArtifactDigest))
+        return false;
+    return value['gaps'] === undefined
+        || (Array.isArray(value['gaps']) && value['gaps'].length > 0 && value['gaps'].every(isArtifactScopeGap));
+} // Optional fields whose persisted values must be non-empty when present
 // (mirrors the checks in hasValidQualityTaskFields). Some models materialize
 // optional tool parameters as "" instead of omitting them (e.g. GPT-5.6
 // sending reviewedTaskId:"" or profile:""), which would otherwise be written
@@ -815,7 +1525,62 @@ export function normalizeBlankOptionalTaskFields(task) {
         else
             next[key] = kept;
     }
-    return next;
+    return normalizeSentinelNumericTaskFields(next);
+}
+/**
+ * Numeric task fields whose durable contract is a bounded range, paired with
+ * their minimum (`Number.isSafeInteger` plus the lower bound). Some models
+ * materialize "no value" as a numeric sentinel (`line: -1`, `round: 0`,
+ * `reviewedAttempt: -1`) that the write side used to persist verbatim and the
+ * durable validator then rejected — bricking the whole team on the next read
+ * (issue #188, #105 class).
+ */
+const SENTINEL_NUMERIC_TASK_FIELDS = [
+    ['round', 1],
+    ['reviewedAttempt', 0],
+    ['attempt', 0],
+];
+/**
+ * Treat an out-of-contract **numeric** sentinel as absent, including
+ * `findings[].line` (contract: `isValidFindingLine`).
+ *
+ * Only numbers are healed. A value of any other type (`round: "oops"`,
+ * `attempt: {}`, `line: "12"`) is left exactly as written and stays a hard,
+ * named validation failure, so genuine corruption is never silently swallowed
+ * while `-1`-style sentinels — the #188 brick — self-heal. Field order, unknown
+ * fields and every in-range value are preserved.
+ */
+export function normalizeSentinelNumericTaskFields(task) {
+    const next = { ...task };
+    let changed = false;
+    for (const [key, minimum] of SENTINEL_NUMERIC_TASK_FIELDS) {
+        const value = next[key];
+        if (typeof value !== 'number')
+            continue;
+        if (Number.isSafeInteger(value) && value >= minimum)
+            continue;
+        delete next[key];
+        changed = true;
+    }
+    if (Array.isArray(next['findings'])) {
+        let findingsChanged = false;
+        const findings = next['findings'].map((finding) => {
+            if (!isRecord(finding))
+                return finding;
+            const line = finding['line'];
+            if (typeof line !== 'number' || isValidFindingLine(line))
+                return finding;
+            const cleaned = { ...finding };
+            delete cleaned['line'];
+            findingsChanged = true;
+            return cleaned;
+        });
+        if (findingsChanged) {
+            next['findings'] = findings;
+            changed = true;
+        }
+    }
+    return (changed ? next : task);
 }
 export function hasValidQualityTaskFields(value) {
     if (value['kind'] !== undefined && !TASK_KINDS.includes(value['kind']))
@@ -833,7 +1598,7 @@ export function hasValidQualityTaskFields(value) {
     if (value['reviewedAttempt'] !== undefined && !(Number.isSafeInteger(value['reviewedAttempt']) && value['reviewedAttempt'] >= 0)) {
         return false;
     }
-    const stringLists = ['inScope', 'outOfScope', 'acceptance', 'verify', 'deliverables', 'nonGoals', 'changedPaths', 'sourceFindingIds', 'coverageOf'];
+    const stringLists = ['inScope', 'outOfScope', 'acceptance', 'verify', 'deliverables', 'nonGoals', 'changedPaths', 'sourceFindingIds', 'findingSourceTaskIds', 'coverageOf'];
     for (const key of stringLists) {
         if (value[key] === undefined)
             continue;
@@ -861,6 +1626,20 @@ export function hasValidQualityTaskFields(value) {
         if (!Array.isArray(value['revisions']) || !value['revisions'].every(isTaskRevision))
             return false;
     }
+    if (value['reviewedArtifacts'] !== undefined
+        && (!Array.isArray(value['reviewedArtifacts']) || !value['reviewedArtifacts'].every(isArtifactDigest)))
+        return false;
+    if (value['reviewedGaps'] !== undefined
+        && (!Array.isArray(value['reviewedGaps']) || value['reviewedGaps'].length === 0 || !value['reviewedGaps'].every(isArtifactScopeGap)))
+        return false;
+    if (value['reviewedScope'] !== undefined && !nonemptyStringList(value['reviewedScope']))
+        return false;
+    if (value['reviewedDuringDrift'] !== undefined && !nonemptyStringList(value['reviewedDuringDrift']))
+        return false;
+    if (value['contractSnapshot'] !== undefined && !isArtifactSnapshot(value['contractSnapshot']))
+        return false;
+    if (value['verdictStartSnapshot'] !== undefined && !isArtifactSnapshot(value['verdictStartSnapshot']))
+        return false;
     return true;
 }
 function isRecord(value) {
@@ -957,8 +1736,9 @@ export function qualityPlanningPrompt() {
         'halted means the human stopped the team; call agent_teams_resume before creating more work. escalated means the automatic review loop hit its ceiling; that is not halt.',
     ].join(' ');
 }
-export function describeQualityLoop(team) {
-    const delivery = canDeclareDelivery(team);
+export function describeQualityLoop(team, audit = {}) {
+    const delivery = canDeclareDelivery(team, audit);
+    const warnings = [...delivery.warnings];
     if (team.halted === true) {
         return {
             state: 'halted',
@@ -966,6 +1746,7 @@ export function describeQualityLoop(team) {
             escalated: team.escalated === true,
             deliverable: false,
             summary: 'Team is halted. Call agent_teams_resume with a reason before creating more work.',
+            warnings,
         };
     }
     if (delivery.ok) {
@@ -974,16 +1755,19 @@ export function describeQualityLoop(team) {
             halted: false,
             escalated: team.escalated === true,
             deliverable: true,
-            summary: 'All required work and quality gates passed. The captain may report delivery.',
+            summary: `All required work and quality gates passed. The captain may report delivery.${warnings.length === 0 ? '' : ` Warnings: ${warnings.join('; ')}`}`,
+            warnings,
         };
     }
     if (team.escalated === true) {
+        const unresolved = unresolvedGates(team);
         return {
             state: 'escalated',
             halted: false,
             escalated: true,
             deliverable: false,
-            summary: 'Automatic review/repair loop hit its ceiling. The team is still running; do not treat this as halt. Escalate to the user instead of inventing another needs_revision cycle.',
+            summary: `Automatic review/repair loop hit its ceiling. The team is still running; do not treat this as halt. Escalate to the user instead of inventing another needs_revision cycle.${unresolved.length === 0 ? '' : ` Genuinely unresolved gates: ${unresolved.map((item) => `${item.id} (${taskKindOf(item)})`).join(', ')}; any failed gate not listed here already has a follow-up repair.`}`,
+            warnings,
         };
     }
     const open = team.tasks.some((item) => OPEN_STATUSES.includes(item.status));
@@ -994,7 +1778,8 @@ export function describeQualityLoop(team) {
         deliverable: false,
         summary: open
             ? 'Work remains on the shared task list; wait for the scheduler or complete owned tasks.'
-            : `Delivery is blocked: ${delivery.blockers.join('; ') || 'unresolved quality gates'}.`,
+            : `Delivery is blocked: ${delivery.blockers.join('; ') || 'unresolved quality gates'}.${warnings.length === 0 ? '' : ` Warnings: ${warnings.join('; ')}`}`,
+        warnings,
     };
 }
 export { QUALITY_KINDS, WRITE_KINDS };