@sun-asterisk/sungen 3.3.0-alpha.1 → 3.3.0-alpha.10

package/src/harness/gates/audit-report-verification.ts

@@ -6,50 +6,79 @@
  *   status       `gateStatus` is PASS|FAIL and agrees with the integer `exitCode` (0 | 2)
  *   inputs       `inputsHash` equals the hash of today's inputs + decisions (audit-input-hash.ts)
  *   decisions    `decisionsHash` equals today's — otherwise the audit is stale: re-audit
+ *   rules        `provenance.catalogHash` and `provenance.rulesHash` are the running sungen's — other
+ *                catalogs or another AUDIT_RULES_VERSION scored it (a 3.2 PASS can be a 3.3 FAIL on the
+ *                same files): stale, re-audit. Missing → stale (fail closed). The package VERSION
+ *                alone is not a reason: a newer sungen with the same rules gives the same verdict (W4)
  *   verdict      gateStatus re-evaluated from the report's own terms (audit-gate-terms.ts) under the
  *                overrides in force — a flipped gateStatus + exitCode is `verdict-mismatch` (tester m1)
  * Anything else counts as NEVER AUDITED, not as clean; only an explicit `gateStatus: PASS` passes.
  * These checks are anti-STALENESS and anti-casual-tamper, NOT anti-forgery: a writer of audit.json can
  * recompute the hashes, and one who rewrites every finding, gap and verdict is out of scope here.
  *
- * Legacy (DOS-11.4): a report written before these fields existed carries none of exitCode /
- * inputsHash / decisionsHash / gateOverrides. It is still read — with the note "legacy audit, inputs
- * unverified" — while no gate-override can apply to the unit and no input file is newer than it
- * (mtime, review M1); otherwise it is stale. A report carrying SOME of the fields is malformed.
+ * Legacy (DOS-11.4, #933): a report written before these fields existed carries none of exitCode /
+ * inputsHash / decisionsHash / gateOverrides, so nothing in it can vouch for today's inputs. It reads
+ * STALE — one `sungen audit` records a current one. (It used to count while no input file was newer:
+ * a fresh checkout gives every file the checkout's mtime, so that proved nothing and an old PASS was
+ * trusted.) A legacy report claiming a PASS its own fields contradict is invalid. A report carrying
+ * SOME of the fields is malformed.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolveUnitCandidates } from '../../cli/resolve-unit';
 import { reportSlug } from '../unit-paths';
-import { auditInputFiles, auditInputsHash } from './audit-input-hash';
+import { getProvenance } from '../provenance';
+import { auditInputsChangedReason, auditInputsHash } from './audit-input-hash';
 import { AUDIT_EXIT_CODE } from './audit-gate-verdict';
 import { recomputeAuditGateStatus, termSourcesOf } from './audit-gate-terms';
 import { EMPTY_DECISIONS_HASH } from './decisions-hash';
 import { loadUnitGateOverrides, unitScopeOfDir, UnitGateOverrides } from './unit-gate-overrides';
 
-export type AuditState = 'absent' | 'verified' | 'legacy' | 'stale' | 'invalid';
+export type AuditState = 'absent' | 'verified' | 'stale' | 'invalid';
 export type AuditProblemCode = 'unreadable' | 'unknown-key' | 'bad-type' | 'partial-fields' | 'status-exit-mismatch'
-  | 'unit-unresolved' | 'decisions-changed' | 'inputs-changed' | 'legacy-with-overrides' | 'legacy-inputs-newer' | 'verdict-mismatch';
+  | 'unit-unresolved' | 'decisions-changed' | 'inputs-changed' | 'rules-changed' | 'legacy-with-overrides' | 'legacy-unverified' | 'verdict-mismatch';
 
 export interface AuditVerification {
   state: AuditState;
   problems: Array<{ code: AuditProblemCode; message: string }>;
-  /** Caveats on a report that counts (a legacy report's inputs are unverified). */
+  /** Caveats on a report that counts. */
   notes: string[];
-  /** The parsed report — only when it counts (verified or legacy). */
+  /** The parsed report — only when it counts (verified). */
   report: Record<string, unknown> | null;
   path: string;
   /** Today's decisionsHash for the unit (what a fresh audit would record). */
   currentDecisionsHash: string;
 }
 
-export const LEGACY_AUDIT_NOTE = 'legacy audit, inputs unverified — written before inputsHash existed; re-run `sungen audit` to record it';
+/** A string field of the report's provenance, or null when it does not say. */
+function provenanceField(r: Record<string, unknown>, key: 'sungenVersion' | 'catalogHash' | 'rulesHash'): string | null {
+  const v = r.provenance && typeof r.provenance === 'object' ? (r.provenance as Record<string, unknown>)[key] : undefined;
+  return typeof v === 'string' && v ? v : null;
+}
+const writtenBy = (r: Record<string, unknown>): string | null => provenanceField(r, 'sungenVersion');
+
+export interface RulesStamp { catalogHash: string | null; rulesHash: string | null }
+/** rulesProblem's answer for a report that records no rules (`provenance.catalogHash` / `rulesHash`): an older sungen wrote it. */
+export const NO_RULES_STAMP = 'audited by an older sungen, which did not record the rules it scored with';
+/** What getProvenance writes when it could not read a catalog — never a match, on either side. */
+const UNKNOWN = 'unknown';
+
+/**
+ * Why the rules a report was scored by (`was`) cannot be taken as this sungen's (`now`), or null when
+ * they are the same KNOWN rules. Missing or `unknown` on either side is a problem (fail closed):
+ * unknown == unknown proves nothing.
+ */
+export function rulesProblem(was: RulesStamp, now: RulesStamp): string | null {
+  if (!was.catalogHash || !was.rulesHash) return NO_RULES_STAMP;
+  if ([was.catalogHash, was.rulesHash].includes(UNKNOWN)) return 'the rules that scored it are unknown (provenance says "unknown")';
+  if (!now.catalogHash || !now.rulesHash || [now.catalogHash, now.rulesHash].includes(UNKNOWN)) return 'this sungen cannot read its own rules (catalog or rules hash unknown), so it trusts no report';
+  if (was.catalogHash === now.catalogHash && was.rulesHash === now.rulesHash) return null;
+  return `scored by other rules (catalog ${was.catalogHash} · rules ${was.rulesHash}) than this sungen's (catalog ${now.catalogHash} · rules ${now.rulesHash})`;
+}
 
-/** A legacy report is stale once an input it judged is newer than the report itself (mtime). */
-function newerLegacyInput(reportFile: string, unitDir: string | null, unit: string): string | null {
-  if (!unitDir) return null;
-  const at = fs.statSync(reportFile).mtimeMs;
-  return auditInputFiles(unitDir, unit).find((f) => fs.statSync(f).mtimeMs > at) ?? null;
+/** Why a current-format report was judged by other rules than this sungen's, or null when the same. */
+function otherRules(r: Record<string, unknown>): string | null {
+  return rulesProblem({ catalogHash: provenanceField(r, 'catalogHash'), rulesHash: provenanceField(r, 'rulesHash') }, getProvenance());
 }
 
 type JsonKind = 'string' | 'number' | 'boolean' | 'object' | 'array';
@@ -124,21 +153,25 @@ export function verifyAuditReport(projectRoot: string, unit: string): AuditVerif
   if (schema.length) return result('invalid', schema);
 
   if (!P0_KEYS.some((k) => k in r)) {
-    if (current !== EMPTY_DECISIONS_HASH) {
-      return result('stale', [{ code: 'legacy-with-overrides', message: 'written by an earlier sungen (no decisionsHash) and a gate-override now applies to this unit' }]);
-    }
-    const newer = newerLegacyInput(file, unitDir, unit);
-    if (newer) return result('stale', [{ code: 'legacy-inputs-newer', message: `written by an earlier sungen and ${path.basename(newer)} changed after it` }]);
     // A legacy report predates gateSensorError, so only a stored PASS its own fields contradict is caught.
     const sources = termSourcesOf(r, false);
     if (r.gateStatus === 'PASS' && sources && recomputeAuditGateStatus(sources, overrides) === 'FAIL') return result('invalid', [verdictMismatch(r)]);
-    return result('legacy', [], r, [LEGACY_AUDIT_NOTE]);
+    const by = `written by ${writtenBy(r) ? `sungen ${writtenBy(r)}` : 'an earlier sungen'}`;
+    if (current !== EMPTY_DECISIONS_HASH) {
+      return result('stale', [{ code: 'legacy-with-overrides', message: `${by} (no decisionsHash) and a gate-override now applies to this unit` }]);
+    }
+    return result('stale', [{ code: 'legacy-unverified', message: `${by}, before inputsHash existed — its inputs cannot be verified` }]);
   }
   const stale: AuditVerification['problems'] = [];
+  const rules = otherRules(r);
+  // A report from before the rules stamp reads in plain words, with the one command that clears it (#966).
+  if (rules) stale.push({ code: 'rules-changed', message: rules === NO_RULES_STAMP
+    ? `audited by an older sungen${writtenBy(r) ? ` (${writtenBy(r)})` : ''} — run \`sungen audit --screen ${unit}\` once`
+    : `${writtenBy(r) ? `written by sungen ${writtenBy(r)}, ` : ''}${rules}` });
   if (r.decisionsHash !== current) stale.push({ code: 'decisions-changed', message: 'the gate-override decisions changed since this audit' });
   if (!unitDir) return result('invalid', [{ code: 'unit-unresolved', message: `"${unit}" does not name exactly one unit, so the audit's inputs cannot be checked` }]);
   if (r.inputsHash !== auditInputsHash(unitDir, unit, r.decisionsHash as string)) {
-    stale.push({ code: 'inputs-changed', message: 'an input the audit judged (.feature, spec, viewpoint, context, design) changed since this audit' });
+    stale.push({ code: 'inputs-changed', message: auditInputsChangedReason(unitDir) });
   }
   if (stale.length) return result('stale', stale);
   const tampered = verdictProblem(r, overrides);
@@ -157,8 +190,8 @@ function verdictProblem(r: Record<string, unknown>, overrides: UnitGateOverrides
   return recomputeAuditGateStatus(sources, overrides) === r.gateStatus ? null : verdictMismatch(r);
 }
 
-/** Whether the report may be used at all (verified, or a legacy report no override touches). */
-export const auditCounts = (v: AuditVerification): boolean => v.state === 'verified' || v.state === 'legacy';
+/** Whether the report may be used at all: only a verified one. */
+export const auditCounts = (v: AuditVerification): boolean => v.state === 'verified';
 
 /** Only an explicit `gateStatus: PASS` on a report that counts passes; a score never does. */
 export const auditPassed = (v: AuditVerification): boolean => auditCounts(v) && v.report?.gateStatus === 'PASS';

package/src/harness/gates/delivery-checklist.ts

@@ -6,7 +6,10 @@
  *   script-check    runScriptCheck: OK | FAIL                                    (`sungen script-check` 0 | 2)
  *   contract check  buildContractVerdict: pass | review | fail                   (`sungen contract check` 0 | 0 | 2)
  *   decisions       evaluateDeliveryDecisions: problems, in-run decisions        (what this delivery checks)
- *   triage          testCaseStates: every red case classified, candidates decided
+ *   results         resultsFreshness: the run the counts come from, not older than the .feature,
+ *                   compiled spec or spec.md, and present for SUNGEN_ENV (#942)
+ *   triage          testCaseStates: every red case classified, candidates decided — naming the classified
+ *                   reds still awaiting a test fix or an environment re-run
  * A box that cannot apply is SKIPPED with its reason — never absent, never ticked. The checklist only
  * reports: the gates before it decide whether the delivery runs, so no exit code moves because of it.
  */
@@ -15,6 +18,7 @@ import { readTextOrNull } from '../../contract/contract-git';
 import { lockPathFor } from '../../contract/contracts-lock-file';
 import { testCaseNeed } from '../../graph/test-case-satisfied';
 import { testCaseStates } from '../../graph/test-case-states';
+import { describeResultsRun, resultsFreshness } from '../../graph/unit-results-freshness';
 import { runScriptCheck, UnitKind } from '../script-check';
 import { auditCounts, auditNotCountedReason, verifyAuditReport } from './audit-report-verification';
 import { evaluateDeliveryDecisions } from './delivery-decision-gate';
@@ -33,10 +37,10 @@ function auditBox(projectRoot: string, u: ChecklistUnit): ChecklistBox {
   const v = verifyAuditReport(projectRoot, u.unitName);
   if (!auditCounts(v)) return box('audit', 'fail', auditNotCountedReason(v, u.unitName));
   const overall = (v.report?.score as { overall?: number } | undefined)?.overall;
-  const how = v.state === 'legacy' ? 'legacy report, inputs unverified' : "verified against today's inputs";
+  const how = "verified against today's inputs";
   return v.report?.gateStatus === 'PASS'
     ? box('audit', 'pass', `PASS ${overall ?? '?'}/10 — ${how}`)
-    : box('audit', 'fail', `FAIL ${overall ?? '?'}/10 — \`sungen audit\` exits 2 (${how})`);
+    : box('audit', 'fail', `FAIL ${overall ?? '?'}/10 — \`sungen audit\` exits 2 (${how}); an official delivery is blocked until it passes — --preview renders a draft`);
 }
 
 /** The compiler prints progress on stdout; the checklist keeps the delivery output to itself. */
@@ -46,13 +50,23 @@ async function quietly<T>(fn: () => Promise<T>): Promise<T> {
   try { return await fn(); } finally { Object.assign(console, saved); }
 }
 
+/** Findings a fresh `sungen generate` cures: the spec is out of step with the .feature, not hollow. */
+const REGENERATE_CURES = /^(?:DRIFT|MISSING in spec|EXTRA in spec|Count mismatch)\b/;
+
+/** The first finding's first sentence — its cause after "→" kept (#943) — and, when regenerating cures it, the command. */
+function scriptCheckFailure(u: ChecklistUnit, finding = 'not faithful'): string {
+  const first = finding.split(/\. /)[0].slice(0, 240);
+  const generate = `sungen generate --${u.kind === 'flow' ? 'flow' : u.kind === 'api' ? 'api' : 'screen'} ${u.unitName}`;
+  return `FAIL — ${first}${REGENERATE_CURES.test(finding) ? ` — run \`${generate}\` after fixing the scenario` : ''} (\`sungen script-check\` exits 2)`;
+}
+
 async function scriptCheckBox(u: ChecklistUnit): Promise<ChecklistBox> {
   try {
     const r = await quietly(() => runScriptCheck(u.unitDir, u.unitName, u.kind));
     if (!r.specPath) return box('script-check', 'skipped', 'no compiled spec to compare: nothing was compiled for this unit');
     return r.status === 'OK'
       ? box('script-check', 'pass', `OK — the spec is a 1:1 of the .feature, no drift (${r.automatedScenarios} automated)`)
-      : box('script-check', 'fail', `FAIL — ${(r.findings[0] ?? 'not faithful').split(/ → |\. /)[0].slice(0, 160)} (\`sungen script-check\` exits 2)`);
+      : box('script-check', 'fail', scriptCheckFailure(u, r.findings[0]));
   } catch (e) {
     return box('script-check', 'fail', `could not run: ${why(e)}`);
   }
@@ -87,7 +101,21 @@ function decisionsBox(projectRoot: string, u: ChecklistUnit, accepted?: InRunAcc
   }
 }
 
-function triageBox(projectRoot: string, u: ChecklistUnit): ChecklistBox {
+/** Which run the delivered counts come from — and whether the suite moved on since (#942). */
+export function resultsBox(projectRoot: string, u: ChecklistUnit): ChecklistBox {
+  try {
+    const f = resultsFreshness(projectRoot, u.unitDir, u.unitName);
+    if (!f) return box('results', 'skipped', 'no run results: the unit has not run, every case reads Pending');
+    const run = `${describeResultsRun(f)}${f.files.length > 1 ? `, ${f.files.length} files` : ''}`;
+    return f.warning
+      ? box('results', 'fail', `${run} — ${f.warning}`)
+      : box('results', 'pass', `${run} — not older than the .feature, compiled spec or spec.md`);
+  } catch (e) {
+    return box('results', 'fail', `could not be dated: ${why(e)}`);
+  }
+}
+
+export function triageBox(projectRoot: string, u: ChecklistUnit): ChecklistBox {
   try {
     const cases = testCaseStates(projectRoot, u.unitName, { unitDir: u.unitDir });
     if (!cases.some((c) => c.result !== 'never-run')) return box('triage', 'skipped', 'no run results to classify');
@@ -97,14 +125,18 @@ function triageBox(projectRoot: string, u: ChecklistUnit): ChecklistBox {
     if (owed.length) return box('triage', 'fail', `${owed.length} red test case(s) not classified — run \`sungen triage ${flag} ${u.unitName}\``);
     if (decide.length) return box('triage', 'fail', `${decide.length} product-defect candidate(s) await a QA decision (\`sungen defect draft ${flag} ${u.unitName}\`)`);
     const reds = cases.filter((c) => c.result === 'failed').length;
-    return box('triage', 'pass', reds ? `${reds} red test case(s), each classified or exempt` : 'no red test case');
+    // Classified is not done: a test defect still needs its fix, an environment red its re-run (#928).
+    const waiting = cases.filter((c) => testCaseNeed(c) === 'fix-test' || testCaseNeed(c) === 'rerun-environment');
+    const named = waiting.length
+      ? ` — ${waiting.length} awaiting a fix or a re-run (${waiting.slice(0, 4).map((c) => `${c.id}: ${c.triage?.class}`).join(', ')}${waiting.length > 4 ? ', …' : ''})` : '';
+    return box('triage', 'pass', reds ? `${reds} red test case(s), each classified or exempt${named}` : 'no red test case');
   } catch (e) {
     return box('triage', 'fail', `could not be read: ${why(e)}`);
   }
 }
 
 export async function unitChecklist(projectRoot: string, u: ChecklistUnit, accepted?: InRunAcceptance): Promise<ChecklistBox[]> {
-  return [auditBox(projectRoot, u), await scriptCheckBox(u), contractBox(projectRoot, u), decisionsBox(projectRoot, u, accepted), triageBox(projectRoot, u)];
+  return [auditBox(projectRoot, u), await scriptCheckBox(u), contractBox(projectRoot, u), decisionsBox(projectRoot, u, accepted), resultsBox(projectRoot, u), triageBox(projectRoot, u)];
 }
 
 const MARK: Record<BoxState, string> = { pass: '[x]', fail: '[ ]', skipped: '[-]' };

package/src/harness/gates/delivery-decision-gate.ts

@@ -8,12 +8,16 @@
  *   no trusted    no audit report, or one that does not count (stale, invalid, verdict-mismatch):
  *   audit         a real delivery stops and asks for `sungen audit` (owner decision 2026-10-22);
  *                 `--preview` / `--check` go on with a warning — the caller decides (`untrustedAudits`)
+ *   failing       a trusted audit whose verdict is FAIL (`sungen audit` exits 2): the same — a real
+ *   audit         delivery stops, naming the failing gate rules (#935, owner decision); `--preview`
+ *                 renders a DRAFT, `--check` reports it (`failingAudits`)
  * It also hands each target its gate rules (catalog + overrides) for the matrix gates, and the
  * override rows the XLSX may show. With no decision in reach nothing here changes the delivery.
  */
 import { checkDecisionIntegrity, DecisionFinding } from '../../decisions/decision-integrity-check';
 import { PROJECT_SCOPE } from '../../decisions/decision-file';
 import { auditCounts, verifyAuditReport } from './audit-report-verification';
+import { auditGateTerms, termSourcesOf } from './audit-gate-terms';
 import { GateOverrideReport, gateOverrideReports, gateOverrideSummaryLine, InRunAcceptance } from './gate-override-report';
 import { unitsCoveredByScope } from './gate-override-scope';
 import { committedDecisionPaths, hasInRunKindDecisions, inRunDecisions, InRunDecision, IN_RUN_RULE, runStartOf } from './in-run-decision-check';
@@ -35,6 +39,10 @@ export interface DeliveryDecisionGate {
   blocking: string[];
   /** Units with no trusted audit — a real delivery stops on them, --preview / --check warn. */
   untrustedAudits: string[];
+  /** Units whose trusted audit FAILs (#935) — a real delivery stops on them, --preview / --check warn. */
+  failingAudits: string[];
+  /** The unit's audit does not let it be delivered officially (untrusted or FAIL): its render is a DRAFT. */
+  auditDraft(unitDir: string): boolean;
   notes: string[];
   inRun: Array<InRunDecision & { unit: string }>;
   /** The unit's tracked gate rules, for the matrix gates of its targets. */
@@ -48,9 +56,22 @@ export interface DeliveryDecisionGate {
 
 const reachOf = (scope: string | null): string[] => [`qa/decisions/`, ...(scope ? [`qa/${scope}/decisions/`] : [])];
 
+/** The audit gate rules a FAIL report's own terms violate under the unit's overrides, gaps named. */
+function failingGateRules(report: Record<string, unknown>, overrides: UnitGateOverrides): string {
+  const sources = termSourcesOf(report, true);
+  if (!sources) return 'its gate terms';
+  const gaps = (sources.gate.gaps as Array<{ theme?: unknown; status?: unknown }>)
+    .map((g) => `${g.status === 'shallow' ? 'SHALLOW' : 'MISSING'}: ${String(g.theme)}`);
+  const rules = auditGateTerms(sources).filter((t) => !t.holds && resolveRule(t.rule, overrides.context).blocking)
+    .map((t) => (t.rule === 'audit.viewpoint-coverage' && gaps.length ? `${t.rule} (${gaps.join(', ')})` : t.rule));
+  return rules.join(', ') || 'its gate terms';
+}
+
 export function evaluateDeliveryDecisions(projectRoot: string, refs: DeliveryUnitRef[]): DeliveryDecisionGate {
   const blocking: string[] = [];
   const untrustedAudits: string[] = [];
+  const failingAudits: string[] = [];
+  const draftDirs = new Set<string>();
   const notes: string[] = [];
   const inRun: DeliveryDecisionGate['inRun'] = [];
   const units = new Map<string, UnitState>();
@@ -63,10 +84,15 @@ export function evaluateDeliveryDecisions(projectRoot: string, refs: DeliveryUni
       ? (audit.report!.gateOverrides as GateOverrideReport[]).filter((g) => g?.triggered).map((g) => g.rule) : []);
     units.set(ref.unitDir, { ref, resultsPaths: [ref.resultsPath], overrides, rules: trackGateRules(overrides.context), auditTriggered });
     for (const r of overrides.rejected) blocking.push(`${ref.label}: gate.override-rejected — ${r.decisionId} (${r.path}): ${r.reason}`);
+    const flag = /[\\/]qa[\\/]api[\\/]/.test(ref.unitDir) ? '--api' : '--screen';
     if (!auditCounts(audit)) {
       const why = audit.state === 'absent' ? 'no audit report' : `the audit is ${audit.state === 'stale' ? 'stale' : 'not trusted'}: ${audit.problems.map((p) => p.message).join('; ')}`;
-      const flag = /[\\/]qa[\\/]api[\\/]/.test(ref.unitDir) ? '--api' : '--screen';
       untrustedAudits.push(`${ref.label}: ${why} — re-run \`sungen audit ${flag} ${ref.unitName}\``);
+      draftDirs.add(ref.unitDir);
+    } else if (audit.report?.gateStatus !== 'PASS') {
+      const overall = (audit.report?.score as { overall?: number } | undefined)?.overall;
+      failingAudits.push(`${ref.label}: FAIL ${overall ?? '?'}/10 on ${failingGateRules(audit.report!, overrides)} — fix the suite, then re-run \`sungen audit ${flag} ${ref.unitName}\``);
+      draftDirs.add(ref.unitDir);
     }
     for (const n of audit.notes) notes.push(`${ref.label}: ${n}`);
   }
@@ -95,6 +121,8 @@ export function evaluateDeliveryDecisions(projectRoot: string, refs: DeliveryUni
   return {
     blocking,
     untrustedAudits,
+    failingAudits,
+    auditDraft: (dir) => draftDirs.has(dir),
     notes,
     inRun,
     rulesFor: (dir) => units.get(dir)?.rules,

package/src/harness/gates/delivery-decision-step.ts

@@ -16,7 +16,10 @@ export interface DeliveryDecisionStepInput {
   argv: string[];
   io: ConfirmationIO;
   log: (line: string) => void;
-  /** A real export needs a trusted audit per unit (owner decision 2026-10-22); false for --preview / --check. */
+  /**
+   * A real export needs, per unit, a trusted audit (owner decision 2026-10-22) that PASSes (#935);
+   * false for --preview / --check, which go on with a warning (a DRAFT render / a report).
+   */
   requireTrustedAudit: boolean;
 }
 
@@ -29,6 +32,8 @@ export async function runDeliveryDecisionStep(i: DeliveryDecisionStepInput): Pro
     for (const b of gate.blocking) i.log(`  - ${b}`);
     return null;
   }
+  // Every reason to stop is listed before stopping, so one run names all of them (audit and in-run).
+  let blocked = false;
   if (gate.untrustedAudits.length) {
     i.log(i.requireTrustedAudit
       ? `✗ Delivery blocked — ${gate.untrustedAudits.length} unit(s) without a trusted audit (a delivery stands on an audit that matches today's suite):`
@@ -36,10 +41,20 @@ export async function runDeliveryDecisionStep(i: DeliveryDecisionStepInput): Pro
     for (const u of gate.untrustedAudits) i.log(`  - ${u}`);
     if (i.requireTrustedAudit) {
       i.log('  Or render a watermarked draft with --preview.');
-      return null;
+      blocked = true;
     }
   }
-  if (gate.inRun.length === 0) return gate;
+  if (gate.failingAudits.length) {
+    i.log(i.requireTrustedAudit
+      ? `✗ Delivery blocked — ${gate.failingAudits.length} unit(s) whose audit FAILs (\`sungen audit\` exits 2; an official delivery stands on a passing audit):`
+      : `⚠ Rendering ${gate.failingAudits.length} unit(s) whose audit FAILs — a draft, not an official delivery:`);
+    for (const u of gate.failingAudits) i.log(`  - ${u}`);
+    if (i.requireTrustedAudit) {
+      i.log('  Fix the suite and re-run the audit, or render a watermarked draft with --preview.');
+      blocked = true;
+    }
+  }
+  if (gate.inRun.length === 0) return blocked ? null : gate;
   const acceptCommand = formatCommand([...i.argv, '--accept-in-run']);
   if (!i.acceptInRun) {
     i.log(`✗ Delivery blocked — ${gate.inRun.length} decision(s) recorded during the run (${IN_RUN_RULE}, hard):`);
@@ -48,6 +63,7 @@ export async function runDeliveryDecisionStep(i: DeliveryDecisionStepInput): Pro
     i.log(`    ${acceptCommand}`);
     return null;
   }
+  if (blocked) return null;   // nothing to accept on top of a delivery the audit already stops
   try {
     await requireTypedConfirmation({
       what: `deliver with ${gate.inRun.length} decision(s) recorded during the run (${IN_RUN_RULE})`,

package/src/harness/gates/in-run-decision-check.ts

@@ -11,10 +11,20 @@
  *
  * A MIGRATED waiver (DOS-13.5) was reviewed when its legacy record was committed — the only record the
  * import trusts — so it is judged by THAT commit (migrated-waiver-review.ts), never by its own decision
- * file: in-run when the record was committed after the run started, or, with no run to compare,
- * after the decision file appeared. Holding it to its decision file's commit would make every legacy
- * project's waivers in-run the day they are imported (phase 09). An entry HEAD's legacy file does not
- * vouch for — absent, uncommitted, different — is judged as any other.
+ * file: in-run when the record was committed after the run started, or — run start or not (#925) —
+ * when it could not have been the import's source: not strictly before the decision file, the unit's
+ * import marker or the project's adoption of 3.3 appeared. Holding it to its decision file's commit would make
+ * every legacy project's waivers in-run the day they are imported (phase 09). An entry HEAD's legacy
+ * file does not vouch for — absent, uncommitted, different, introduced beyond the commits the walk
+ * reads (#924) or at a shallow clone's boundary — is judged as any other; in the last two cases an
+ * in-run finding says why.
+ *
+ * A manual triage classification that claims a human typed it (`triage-classification` with
+ * `humanConfirmed`, #928) is a claim the entry makes about itself — a script can write one. What backs
+ * it is review, so it is in-run while git HEAD does not hold it (and, with no git, always: nothing
+ * shows it was reviewed). Judged by HEAD membership only: it is always recorded after the run it
+ * judges, so its commit time says nothing. Only a test-defect / environment entry that is not
+ * superseded counts — the only kind the reader puts in force on that claim.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -22,7 +32,8 @@ import { DECISION_FILE_PATH } from '../../decisions/decision-file';
 import { DecisionVisibility } from '../../decisions/decision-schema';
 import { gitOutput } from '../../decisions/git-head-trust';
 import { readDecisions } from '../../decisions/read-decisions';
-import { decisionFirstSeenMs, migratedWaiverReviewedAt } from './migrated-waiver-review';
+import { HUMAN_ONLY_TRIAGE, ManualTriageClass, TRIAGE_DECISION_KIND } from '../../graph/manual-triage-decisions';
+import { migratedWaiverReview } from './migrated-waiver-review';
 
 export const IN_RUN_KINDS = ['gate-override', 'waiver', 'contract-approval'] as const;
 export const IN_RUN_RULE = 'decision.in-run';
@@ -55,23 +66,36 @@ export function runStartOf(resultsPath: string | null): string | null {
 }
 
 const isInRunKind = (kind: string): boolean => (IN_RUN_KINDS as readonly string[]).includes(kind);
+/**
+ * A triage classification claiming a human typed it (#928): reviewed only once git HEAD holds it.
+ * Only what the reader (manual-triage-decisions.ts) can put in force: a superseded entry is never read,
+ * and a product classification needs no human — its claim backs nothing, so it blocks nothing.
+ */
+const claimsHumanTriage = (e: { kind: string; payload?: Record<string, unknown>; superseded_by?: string }): boolean =>
+  e.kind === TRIAGE_DECISION_KIND && !e.superseded_by && e.payload?.humanConfirmed === true
+  && HUMAN_ONLY_TRIAGE.has(e.payload?.class as ManualTriageClass);
 
 /** In-run decisions among `scopes`, judged against one run start (null: HEAD membership only) and the committed set. */
 export function inRunDecisions(projectRoot: string, scopes: string[], runStart: string | null, committed: Set<string> | null): InRunDecision[] {
   const out: InRunDecision[] = [];
   const after = (t: string): boolean => !!runStart && Date.parse(t) > Date.parse(runStart);
+  const migratedReview = committed ? migratedWaiverReview(projectRoot) : null;
   for (const scope of scopes) {
     for (const e of readDecisions(projectRoot, scope).entries) {
-      if (!isInRunKind(e.kind)) continue;
       const rel = path.relative(projectRoot, e.path).split(path.sep).join('/');
+      if (claimsHumanTriage(e) && !committed?.has(rel)) {
+        out.push({ id: e.id, kind: e.kind, path: rel, visibility: e.visibility, why: [committed
+          ? 'a classification by hand that claims a human typed it, not in git HEAD (never committed through review)'
+          : 'a classification by hand that claims a human typed it, and no git to show it was committed through review'] });
+      }
+      if (!isInRunKind(e.kind)) continue;
+      // A migrated waiver re-confirmed on a terminal is replaced: the new decision is judged on its own.
+      if (e.superseded_by && e.source?.where === 'migrated') continue;
       const why: string[] = [];
-      const legacyAt = committed ? migratedWaiverReviewedAt(projectRoot, scope, e) : null;
-      if (legacyAt) {
-        if (runStart ? after(legacyAt) : Date.parse(legacyAt) > decisionFirstSeenMs(projectRoot, rel, e.path)) {
-          why.push(runStart
-            ? `migrated: its legacy record was committed at ${legacyAt}, after the run started ${runStart}`
-            : `migrated: its legacy record was committed at ${legacyAt}, after this decision first appeared`);
-        }
+      const migrated = migratedReview?.reviewOf(scope, e) ?? null;
+      if (migrated?.at) {
+        if (after(migrated.at)) why.push(`migrated: its legacy record was committed at ${migrated.at}, after the run started ${runStart}`);
+        if (migrated.notImported) why.push(migrated.notImported);
       } else if (committed && !committed.has(rel)) {
         why.push('not in git HEAD (never committed through review)');
       } else if (committed && runStart) {
@@ -82,6 +106,7 @@ export function inRunDecisions(projectRoot: string, scopes: string[], runStart:
       } else if (!committed && after(e.valid_from)) {
         why.push(`recorded ${e.valid_from}, after the run started ${runStart}`);
       }
+      if (why.length && migrated?.unvouched) why.push(migrated.unvouched);
       if (why.length) out.push({ id: e.id, kind: e.kind, path: rel, visibility: e.visibility, why });
     }
   }

package/src/harness/gates/migrated-waiver-import-bounds.ts

@@ -0,0 +1,103 @@
+/**
+ * Could a migrated waiver's legacy record have been the source of the import that wrote it? (#925)
+ *
+ * The one-time import (legacy-waiver-migration.ts) reads a record git HEAD ALREADY holds, and only
+ * before 3.3 takes over. So a genuine record was committed strictly before each of:
+ *   1. the decision file's first appearance — its first commit, else its creation on disk;
+ *   2. the unit's import marker `.sungen/migrations/<slug>.waivers-imported.json` — the commit that
+ *      added the one HEAD holds (an agent can delete or recreate the file, not that commit), else its
+ *      creation on disk; once it exists the import never reads that unit's legacy file again;
+ *   3. the project's adoption of 3.3 — the first commit that added any 3.3-only file: an import marker
+ *      or other `.sungen/migrations/` file, a decision file (`qa/**\/decisions/*.yaml`) or a contract lock
+ *      (`qa/**\/contracts.lock.yaml`). Only the 3.3 CLI writes them, and only committed ones count: a
+ *      legacy waiver is one written before the project's first reviewed 3.3 change. Mixed versions pay
+ *      for it: a waiver a pre-3.3 CLI writes after that commit must be re-confirmed on a terminal.
+ * A record failing any bound claims a migration that never happened: the decision is in-run.
+ *
+ * What stays open (the limit of any time-based check, as for ordinary decisions): a record forged and
+ * committed before the project's first 3.3 commit — indistinguishable from a real legacy waiver, as on
+ * a project adopting 3.3 for the very first time — and commit times forged with GIT_COMMITTER_DATE.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { committedText, gitOutput } from '../../decisions/git-head-trust';
+import { formatCommand } from '../../decisions/human-confirmation';
+import { importMarkerPath } from '../../decisions/legacy-waiver-migration';
+import type { ReadDecision } from '../../decisions/read-decisions';
+
+/** Files only the 3.3 CLI writes, as pathspecs relative to the project. */
+const ADOPTION_PATHSPECS = ['.sungen/migrations', ':(glob)qa/**/decisions/*.yaml', ':(glob)qa/**/contracts.lock.yaml'];
+
+/**
+ * What a human does about a migrated waiver its legacy record cannot vouch for: record it anew on a
+ * terminal (a `cli` decision that supersedes it — the superseded one is no longer judged), or accept it
+ * for one delivery.
+ */
+export const migratedWaiverRemedy = (scope: string, ob: string): string =>
+  `re-confirm it on a terminal: ${formatCommand(['sungen', 'journey', '--screen', scope.split('/').pop() ?? scope, '--waive', ob, '--reason', '…'])}, `
+  + 'then commit the new decision; or accept it once with `sungen delivery --accept-in-run`';
+
+const validMs = (iso: string | undefined): number | null => (iso && !Number.isNaN(Date.parse(iso)) ? Date.parse(iso) : null);
+const createdMs = (abs: string): number | null => {
+  try { const s = fs.statSync(abs); return s.birthtimeMs || s.mtimeMs; } catch { return null; }
+};
+
+/** One run's bounds: each decision's first appearance, each unit's marker and the project's adoption, read once. */
+export function migratedWaiverImportBounds(projectRoot: string) {
+  const relOf = (abs: string): string => path.relative(projectRoot, abs).split(path.sep).join('/');
+  const firstSeen = new Map<string, number>();
+  const markers = new Map<string, number | null>();
+  let adoption: number | null | undefined;
+
+  /** When a decision file first appeared: its first commit, else its creation (or last change) on disk. */
+  const decisionMs = (e: ReadDecision): number => {
+    if (!firstSeen.has(e.path)) {
+      const added = gitOutput(projectRoot, ['log', '--diff-filter=A', '--format=%cI', '--', relOf(e.path)])?.trim().split('\n').filter(Boolean).pop();
+      firstSeen.set(e.path, validMs(added) ?? createdMs(e.path) ?? Number.NEGATIVE_INFINITY);
+    }
+    return firstSeen.get(e.path)!;
+  };
+  const markerMs = (slug: string): number | null => {
+    if (!markers.has(slug)) {
+      const abs = importMarkerPath(projectRoot, slug);
+      const added = committedText(projectRoot, abs) !== null
+        ? validMs(gitOutput(projectRoot, ['log', '-1', '--diff-filter=A', '--format=%cI', '--', relOf(abs)])?.trim()) : null;
+      markers.set(slug, added ?? createdMs(abs));
+    }
+    return markers.get(slug)!;
+  };
+  const adoptionMs = (): number | null => {
+    if (adoption === undefined) {
+      const added = (gitOutput(projectRoot, ['log', '--diff-filter=A', '--format=%cI', '--', ...ADOPTION_PATHSPECS]) ?? '')
+        .split('\n').map((l) => validMs(l.trim())).filter((t): t is number => t !== null);
+      adoption = added.length ? Math.min(...added) : null;
+    }
+    return adoption;
+  };
+
+  /** The first bound a record committed at `legacy` (ms) crosses, or undefined. */
+  const boundCrossed = (slug: string, e: ReadDecision, legacy: number): string | undefined => {
+    const decision = decisionMs(e);
+    if (legacy > decision) return 'after this decision first appeared';
+    if (legacy === decision) return 'when this decision first appeared, not before it — an import only reads a record already committed';
+    const marker = markerMs(slug);
+    if (marker !== null && legacy >= marker) {
+      return `after this unit's waivers were imported (${relOf(importMarkerPath(projectRoot, slug))}, ${new Date(marker).toISOString()}) `
+        + '— from then on the import never reads the legacy file';
+    }
+    const adopted = adoptionMs();
+    if (adopted !== null && legacy >= adopted) {
+      return `after this project adopted sungen 3.3 (${new Date(adopted).toISOString()}: the first commit adding a .sungen/migrations/ file, `
+        + 'a decision or a contract lock) — a legacy waiver is one written before that';
+    }
+    return undefined;
+  };
+
+  return {
+    /** Why a record committed at `at` (state file of `slug`) cannot have been the source of `e`'s import; undefined when it can. */
+    notImported(slug: string, e: ReadDecision, at: string): string | undefined {
+      const why = boundCrossed(slug, e, Date.parse(at));
+      return why && `migrated: its legacy record was committed at ${at}, ${why}; ${migratedWaiverRemedy(e.scope, String(e.payload?.obligation))}`;
+    },
+  };
+}