@sun-asterisk/sungen 3.2.25 → 3.2.27

package/src/harness/flow-contract.ts

@@ -22,6 +22,7 @@
  *                       declared collection (order, application, submission …)
  */
 import * as fs from 'fs';
+import { refNamespaces, screenKey } from '../utils/ref-key';
 import * as path from 'path';
 import { parse as parseYaml } from 'yaml';
 import { ScenarioInfo } from './parse';
@@ -40,6 +41,13 @@ export interface FlowDecl {
   reason?: string;
 }
 
+/** One declared journey phase. `scenarios:` is the author naming its evidence directly. */
+export interface FlowPhaseDecl {
+  id: string;
+  description?: string;
+  scenarios?: string[];
+}
+
 const FLOW_STATUSES = new Set(['covered', 'deferred', 'pending-clarification', 'out-of-scope']);
 
 export interface FlowContract {
@@ -58,6 +66,12 @@ export interface FlowContract {
   /** Journey phases this flow declares. Default [HP, ER, EH]; UI is allowed but
    *  never demanded (presentation is the balance axis's business, not coverage's). */
   phases: string[];
+  /**
+   * The phases as DECLARED, when the contract uses the object form. A phase may name the
+   * scenarios that carry it — direct evidence, rather than the harness inferring coverage from
+   * id segments — and that is what a project which writes `phases:` this way is telling us.
+   */
+  phaseDetails?: FlowPhaseDecl[];
   /**
    * The use case's declared flow inventory — the answer to "how many flows does this use
    * case HAVE?". `phases:` alone cannot answer it: a phase is present as soon as ONE
@@ -94,6 +108,8 @@ export interface FlowQualityResult {
   /** Off-goal categories, for the split suggestion ("VP-FILTER-* looks like its own flow"). */
   offGoalCategories: string[];
   phases: { phase: string; covered: boolean; automated: boolean }[];
+  /** Phase-declared scenario refs that match no scenario — a phase whose evidence does not exist. */
+  danglingPhaseRefs: Array<{ phase: string; ref: string }>;
   /** Covered-and-automated phases / declared phases (UI excluded) — the flow coverage axis. */
   phaseRatio: number;
   /** Cross-namespace transitions followed by an assertion / all transitions. */
@@ -130,20 +146,46 @@ export function loadFlowContract(unitDir: string): { contract: FlowContract | nu
     errors.push('missing `outcome.screen:` — the screen namespace that carries the final proof');
   }
   if (errors.length > 0) return { contract: null, errors };
-  const phases = Array.isArray(raw.phases) && raw.phases.length > 0
-    ? (raw.phases as unknown[]).map((x) => String(x).toUpperCase())
-    : DEFAULT_PHASES;
+  // `phases:` comes in two shapes, and the loader used to assume the first. A real project
+  // declared the RICHER one — each phase an object with `name`, `description` and an explicit
+  // `scenarios:` list — and `String(x).toUpperCase()` turned every one of them into
+  // `[OBJECT OBJECT]`. Nothing matched, phase coverage read 0%, the score fell to 6.9, and the
+  // report said only that the phases were uncovered. Garbage in place of an error is the worst
+  // of both: the author sees a broken number with no cause (#657).
+  //
+  // The object form is the better declaration — it names the scenarios that carry the phase
+  // instead of leaving the harness to infer them from ids — so it is read, not merely tolerated.
+  const phaseDetails: FlowPhaseDecl[] = Array.isArray(raw.phases)
+    ? (raw.phases as unknown[]).map((x, i) => {
+      if (x !== null && typeof x === 'object') {
+        const o = x as Record<string, unknown>;
+        const name = o.name ?? o.id ?? o.phase;
+        if (name === undefined) {
+          errors.push(`phases[${i}] is an object with no \`name:\` (or \`id:\`) — a phase needs a label`);
+          return { id: `PHASE${i + 1}` };
+        }
+        return {
+          id: String(name).toUpperCase(),
+          description: o.description !== undefined ? String(o.description) : undefined,
+          scenarios: Array.isArray(o.scenarios) ? (o.scenarios as unknown[]).map((v) => String(v)) : undefined,
+        };
+      }
+      return { id: String(x).toUpperCase() };
+    })
+    : [];
+  const phases = phaseDetails.length > 0 ? phaseDetails.map((p) => p.id) : DEFAULT_PHASES;
   return {
     contract: {
       goal: String(raw.goal),
       actor: raw.actor !== undefined ? String(raw.actor) : undefined,
       trigger: raw.trigger !== undefined ? String(raw.trigger) : undefined,
       precondition: raw.precondition !== undefined ? String(raw.precondition) : undefined,
-      outcome: { screen: String(outcome!.screen).toLowerCase(), assertion: outcome!.assertion !== undefined ? String(outcome!.assertion) : undefined },
+      outcome: { screen: screenKey(String(outcome!.screen)), assertion: outcome!.assertion !== undefined ? String(outcome!.assertion) : undefined },
       value: raw.value !== undefined ? String(raw.value) : undefined,
       successGuarantee: raw.successGuarantee !== undefined ? String(raw.successGuarantee) : (raw.success_guarantee !== undefined ? String(raw.success_guarantee) : undefined),
       minimalGuarantee: raw.minimalGuarantee !== undefined ? String(raw.minimalGuarantee) : (raw.minimal_guarantee !== undefined ? String(raw.minimal_guarantee) : undefined),
       phases,
+      ...(phaseDetails.some((p) => p.scenarios || p.description) ? { phaseDetails } : {}),
       flows: Array.isArray(raw.flows)
         ? (raw.flows as Array<Record<string, unknown>>)
             .filter((f) => f && typeof f === 'object' && f.id)
@@ -169,7 +211,7 @@ export function loadFlowContract(unitDir: string): { contract: FlowContract | nu
             .map((e) => ({
               name: String(e.name),
               owner: e.owner !== undefined ? String(e.owner) : undefined,
-              screens: Array.isArray(e.screens) ? (e.screens as unknown[]).map((x) => String(x).toLowerCase()) : [],
+              screens: Array.isArray(e.screens) ? (e.screens as unknown[]).map((x) => screenKey(String(x))) : [],
             }))
         : undefined,
       golden: raw.golden === true,
@@ -182,13 +224,12 @@ export function loadFlowContract(unitDir: string): { contract: FlowContract | nu
 
 /** `[screen:element]` namespaces referenced by a scenario's steps, in step order. */
 function namespacesInOrder(s: ScenarioInfo): string[] {
-  const out: string[] = [];
-  for (const m of s.stepsText.matchAll(/\[([a-z0-9_.-]+):/g)) out.push(m[1]);
-  return out;
+  // Through the shared vocabulary — a private regex here once dropped every multi-word screen (#660).
+  return refNamespaces(s.stepsText);
 }
 
 function touchesOutcome(s: ScenarioInfo, outcomeScreen: string): boolean {
-  return namespacesInOrder(s).includes(outcomeScreen);
+  return namespacesInOrder(s).includes(screenKey(outcomeScreen));
 }
 
 /**
@@ -203,14 +244,24 @@ function reachesOutcome(s: ScenarioInfo, outcomeScreen: string): boolean {
   // anywhere in the scenario would suppress every positive assertion in it.
   const steps = (s.steps ?? []).map((st) => st.text.toLowerCase());
   if (steps.length === 0) return touchesOutcome(s, outcomeScreen);
-  return steps.some((t) => t.includes(`[${outcomeScreen}`)
+  const key = screenKey(outcomeScreen);
+  return steps.some((t) => refNamespaces(t, { bare: true }).includes(key)
     && !/\b(is hidden|is not visible|does not exist|is absent|no longer)\b/.test(t));
 }
 
 /** Phase of a scenario: its declared phase token (FL-HP-001 / VP-FLOW-ER-02 / MS-EH-005)
  *  when present, else vocabulary detection. */
-export function phaseOf(s: ScenarioInfo, declared: string[]): string | null {
+export function phaseOf(s: ScenarioInfo, declared: string[], details?: FlowPhaseDecl[]): string | null {
   const id = (s.vpId ?? '').toUpperCase();
+  // When a phase NAMES its scenarios, that list is the mapping — the author has already done
+  // the assignment, and inferring it from id segments instead would ignore them. A phase called
+  // "Cross-screen data" shares no token with `VP-LOGIC-002`; only the declaration connects them.
+  for (const ph of details ?? []) {
+    if (ph.scenarios?.some((ref) => {
+      const r = ref.trim().toUpperCase();
+      return r === id || (r.length > 0 && s.name.toUpperCase().includes(r));
+    })) return ph.id;
+  }
   // A DECLARED phase wins, matched on the id's segments with the branch number removed —
   // so the use-case vocabulary (VP-EF01-01, VP-AF02-01: one id per Exception/Alternate
   // Flow) resolves to its phase exactly like the flat HP/ER/EH form does.
@@ -316,15 +367,39 @@ export function flowInventory(contract: FlowContract, scenarios: ScenarioInfo[])
  * Both inflate the flow count while adding no branch coverage, which is exactly what makes a
  * suite look complete to the harness and thin to a reviewer.
  */
+/** An interaction, whichever keyword the author put in front of it — `Then User click` exists. */
+const INTERACTION_VERB = /\buser\s+(?:click|clicks|tap|taps|fill|fills|type|types|select|selects|press|presses|check|checks|uncheck|unchecks|upload|uploads|submit|submits|enter|enters|choose|chooses|toggle|toggles|drag|drags|swipe|swipes|scroll|scrolls|hover|hovers|clear|clears)\b/i;
+
 export function misfiledPhases(
   contract: FlowContract, scenarios: ScenarioInfo[], basicPhase: string,
 ): Array<{ scenario: string; id: string; why: string }> {
   const out: Array<{ scenario: string; id: string; why: string }> = [];
   const outcome = contract.outcome.screen;
+  // A branch point is a STRUCTURAL fact before it is a vocabulary one. The check used to demand a
+  // branch WORD (back / cancel / retry…), so a precondition guard — `Given` already authenticated,
+  // or no originating session → `Then` redirected — had no way to satisfy it: such a scenario has
+  // no interaction step at all, by construction, and its branch is in the `Given`, not in a verb.
+  // Reported under AF and EF alike on a real project (#660). Two structural signals now count:
+  // no `When` at all (a guard by construction), or a `Given` the basic flow never establishes
+  // (a precondition branch). Vocabulary remains as the fallback for scenarios without step data.
+  const basicGivens = new Set(scenarios
+    .filter((sc) => phaseToken(flowIdOf(sc, contract.phases) ?? '') === phaseToken(basicPhase))
+    .flatMap((sc) => (sc.steps ?? []).filter((st) => st.bucket === 'given').map((st) => st.text.toLowerCase().trim())));
+  const branchesStructurally = (sc: ScenarioInfo): boolean => {
+    const steps = sc.steps ?? [];
+    if (steps.length === 0) return false;
+    // No interaction AND the journey does not complete: a guard by construction (the redirect or
+    // the blocked screen IS the branch). No interaction but the outcome IS reached is a different
+    // animal — a postcondition on the basic path — and stays subject to the checks below.
+    const interacts = steps.some((st) => st.bucket === 'when' || INTERACTION_VERB.test(st.text));
+    if (!interacts && !reachesOutcome(sc, outcome)) return true;
+    return steps.some((st) => st.bucket === 'given' && !basicGivens.has(st.text.toLowerCase().trim()));
+  };
   for (const s of scenarios) {
     const id = flowIdOf(s, contract.phases);
     if (!id || phaseToken(id) === phaseToken(basicPhase)) continue;
     const ph = phaseToken(id);
+    if (branchesStructurally(s)) continue;
     if (ph === 'EF' && reachesOutcome(s, outcome)) {
       // An error-then-recover flow legitimately ends at the outcome — it is the recovery that
       // is being proven, and a guard flow is blocked rather than "failed". Only a scenario with
@@ -350,7 +425,7 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
   const neutral: FlowQualityResult = {
     hasContract: false, errors, outcomeProven: false, outcomeManualOnly: false,
     offGoal: [], offGoalRatio: 0, offGoalCategories: [],
-    phases: [], phaseRatio: 1, handoffs: { total: 0, asserted: 0, ratio: 1 }, sit: [],
+    phases: [], phaseRatio: 1, danglingPhaseRefs: [], handoffs: { total: 0, asserted: 0, ratio: 1 }, sit: [],
   };
   if (!contract) return neutral;
 
@@ -365,9 +440,17 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
   // guard/error phase is evidence of a SECOND business goal in this flow.
   const declaredPhases = contract.phases;
   const basic = declaredPhases.filter((p) => p !== 'UI')[0];
+  // A flow the inventory declares WITH ITS OWN outcome is measured against that outcome, never
+  // against the use case's. A spec that keeps an entry variant deliberately light ("prove the
+  // entry reaches the action bar; do not repeat the full assertion") could only satisfy the old
+  // check by widening the scenario — which the human reviewer then called over-testing. The gate
+  // and the reviewer were optimising different things; the declaration is where they agree (#660).
+  const ownOutcome = new Set((contract.flows ?? []).filter((f) => f.outcome).map((f) => f.id));
   const offGoalScenarios = scenarios.filter((s) => {
     if (touchesOutcome(s, outcomeScreen)) return false;
-    const ph = phaseOf(s, declaredPhases);
+    const fid = flowIdOf(s, declaredPhases);
+    if (fid && ownOutcome.has(fid)) return false;
+    const ph = phaseOf(s, declaredPhases, contract.phaseDetails);
     // Any NON-basic declared phase (guards, error recovery, alternate branches) legitimately
     // stops before the outcome — that is what a branch IS. Only an unclassified scenario that
     // never reaches the outcome is evidence of a second business goal.
@@ -383,7 +466,7 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
   // phase that must reach the declared outcome, whether the project spells it HP or BF.
   const basicPhase = demanded[0];
   const phases = demanded.map((phase) => {
-    const inPhase = scenarios.filter((s) => phaseOf(s, declaredPhases) === phase);
+    const inPhase = scenarios.filter((s) => phaseOf(s, declaredPhases, contract.phaseDetails) === phase);
     // The basic flow must additionally prove the outcome — a data assertion elsewhere is not the goal.
     const relevant = phase === basicPhase ? inPhase.filter((s) => touchesOutcome(s, outcomeScreen)) : inPhase;
     return {
@@ -396,6 +479,17 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
     ? phases.filter((p) => p.covered && p.automated).length / demanded.length
     : 1;
 
+  // A phase that names a scenario which does not exist is a declaration pointing at nothing:
+  // the phase reads covered in the contract and is empty in the suite. Same class as a dangling
+  // traceability ref — the map, not the territory.
+  const known = new Set(scenarios.flatMap((s) => [s.vpId?.toUpperCase(), s.name.toUpperCase()].filter(Boolean) as string[]));
+  const danglingPhaseRefs = (contract.phaseDetails ?? []).flatMap((ph) => (ph.scenarios ?? [])
+    .filter((ref) => {
+      const r = ref.trim().toUpperCase();
+      return !known.has(r) && !scenarios.some((s) => s.name.toUpperCase().includes(r));
+    })
+    .map((ref) => ({ phase: ph.id, ref })));
+
   // --- Handoff integrity: no blind tail after a cross-namespace transition. ---
   // A transition counts as asserted when ANY assertion follows it — in the entered
   // namespace or later. Demanding the assertion in the entered namespace itself
@@ -409,7 +503,7 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
     const steps = s.steps ?? [];
     let current: string | null = null;
     for (let i = 0; i < steps.length; i++) {
-      const ns = (steps[i].text.match(/\[([A-Za-z0-9_.-]+):/) || [])[1]?.toLowerCase() ?? null;
+      const ns = refNamespaces(steps[i].text)[0] ?? null;
       if (!ns) continue;
       if (current !== null && ns !== current) {
         total++;
@@ -439,7 +533,7 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
     outcomeProven, outcomeManualOnly,
     offGoal: offGoalScenarios.map((s) => s.name.slice(0, 80)),
     offGoalRatio, offGoalCategories,
-    phases, phaseRatio, handoffs, sit,
+    phases, phaseRatio, danglingPhaseRefs, handoffs, sit,
   };
 }
 
@@ -460,7 +554,24 @@ export interface ContinuityGap { claim: string; missing: 'loss' | 'persistence'
 
 const CONTINUITY_CLAIM = /\b(buffer(?:s|ed|ing)?|persist(?:s|ed|ence)?|round[- ]?trips?|restor(?:e|es|ed|ation)|carr(?:y|ied|ies)|retain(?:s|ed)?|session[- ]?storage|local[- ]?storage)\b/i;
 const SIDE_PERSIST = /\b(restor(?:e|es|ed)|persist(?:s|ed)?|unchanged|same value|round[- ]?trips?|re-?hydrat\w*|still (?:shows|holds)|carr(?:y|ied|ies)|retain(?:s|ed)?|prefilled|pre-?filled)\b/i;
-const SIDE_LOSS = /\b(lose|loses|lost|cleared?|clears|discard\w*|reload\w*|refresh\w*|expire\w*|empty|blank|not restored|no longer|wiped?|reset)\b/i;
+// A LOSS CONSTRUCTION, not a word list. `reset` and `expire` are domain NOUNS — every claim in a
+// password-*reset* flow contains "reset", and every token flow contains "expire", so a bare-word
+// list marked all of them as promising that state is lost and then demanded the missing half.
+// A field report hit exactly that: the two sides of its mechanism were both written (in two
+// different scenarios, which this already handles) and CONTINUITY-ONE-SIDED fired anyway (#630).
+// The state has to be the thing that goes: `is cleared`, `loses the values`, `no longer holds`.
+const SIDE_LOSS = new RegExp([
+  '\\b(?:lose|loses|losing|lost)\\b',
+  '\\b(?:is|are|gets?|got|becomes?|will be|was|were)\\s+(?:lost|cleared|emptied|discarded|wiped|reset|blanked)\\b',
+  '\\b(?:clears|clearing|discards|discarding|wipes|wiping)\\b',
+  '\\b(?:does|do|did)\\s+not\\s+(?:survive|persist|remain|carry)\\b',
+  '\\bnot\\s+(?:restored|retained|preserved|kept)\\b',
+  '\\bno longer\\b',
+  '\\bcomes? up (?:empty|blank)\\b',
+  // The triggers that CAUSE the loss still count when the claim names them as such.
+  '\\b(?:on|after) (?:a )?(?:reload|refresh)\\b',
+  '\\breload(?:ing|s|ed)? (?:the )?(?:page|screen|form|tab)\\b',
+].join('|'), 'i');
 
 /**
  * Continuity claims in the viewpoint file whose feature proves only ONE side.

package/src/harness/next-step.ts

@@ -25,8 +25,14 @@ export interface NextStep {
   command: string;
   /** Why it is next — stated so an agent can weigh it, not just obey it. */
   because: string;
-  /** `blocked` steps are not runnable yet; they name what to resolve first. */
-  kind: 'do' | 'blocked' | 'optional';
+  /**
+   * `blocked` steps are not runnable yet; they name what to resolve first. `decide` steps are a
+   * HUMAN'S to run: an agent presents them and stops. Accepting the viewpoint baseline is the
+   * case — offered as a plain `do`, an agent that had just rewritten `test-viewpoint.md` from the
+   * spec ran it, and `atomicLedger`/`traceability` read 100% against a checklist it wrote itself
+   * in the same session (#660).
+   */
+  kind: 'do' | 'blocked' | 'optional' | 'decide';
 }
 
 export interface UnitState {
@@ -228,9 +234,9 @@ export function deriveSteps(s: UnitState): NextStep[] {
   }
   if (s.audit.viewpointBaselineStatus === 'changed') {
     out.push({
-      kind: 'do',
+      kind: 'decide',
       command: `sungen audit --screen ${s.unit} --accept-viewpoint`,
-      because: 'test-viewpoint.md changed since the accepted baseline, so the ledger and traceability axes are not evidence until you confirm the new declaration',
+      because: 'test-viewpoint.md changed since the accepted baseline, so the ledger and traceability axes are not evidence until a QA confirms the new declaration. A decision, not a step: an agent presents it and does not run it — accepting the yardstick you just wrote makes both axes read 100% by construction',
     });
   }
   const repair = s.audit.findings

package/src/harness/quality-gates.ts

@@ -14,24 +14,46 @@ import { readTextFile } from './read-text';
 export interface DownstreamResult {
   downstreamRoutes: string[];                 // success/navigation targets ≠ own route
   underCovered: { route: string; slug: string }[]; // referenced only by a bare page-nav
+  /**
+   * Declared navigation targets NO scenario mentions at all. These used to be skipped as "out of
+   * this screen's scope", which is right for a screen and wrong for a FLOW: a field report found a
+   * dashboard whose spec declared four click-through destinations and whose suite tested only the
+   * render conditions of the regions containing them — the navigation itself had no case, and
+   * nothing said so (#630).
+   */
+  absent: { route: string; slug: string }[];
 }
 
 /** Routes the spec hands off to (Navigation Flow / success), other than the screen's own route. */
 function downstreamRoutes(specText: string): string[] {
   const ownRoute = (specText.match(/\*\*Route\*\*\s*:\s*`?(\/[^\s`]+)/) || [])[1] || '';
   const routes = new Set<string>();
+  const negated = new Set<string>();
   for (const line of specText.split('\n')) {
     if (!/success|navigat|to \(|→/i.test(line)) continue;
     // A real route's leading `/` sits at a path boundary (start, whitespace, backtick, quote, paren),
     // NOT after a letter/digit. The lookbehind rejects prose slashes like "text/icon" or
     // "category/brand" that aren't routes at all (H2 — they produced /icon, /button, /brand).
+    let negRun = false;      // inside a "…, not `/a`/`/b`" list
+    let prevEnd = 0;
     for (const m of line.matchAll(/(?<![A-Za-z0-9])(\/[a-z][a-z0-9/_-]+)`?/gi)) {
       const r = m[1];
+      // "the destination is `/a/b` (singular, not `/a/bs` as this spec assumed)" declares ONE
+      // target and CORRECTS another. A spec that says where a route is NOT is doing the reader a
+      // service; extracting the disowned one and demanding a test for it punishes the correction.
+      // The negation carries across a LIST — "not `/x`/`/y`" disowns both, not just the first.
+      const before = line.slice(Math.max(0, m.index - 24), m.index);
+      const gap = line.slice(prevEnd, m.index);
+      prevEnd = m.index + m[0].length;
+      if (/\b(?:not|instead of|rather than|no longer|never|không)\s*[`'"(\[]*\s*$/i.test(before)) negRun = true;
+      else if (negRun && !/^[`'"\s)\]]*[/,]?\s*(?:or|hoặc)?\s*[`'"(\[]*$/i.test(gap)) negRun = false;
+      if (negRun) { negated.add(r); continue; }
       if (r !== ownRoute && r.split('/').length > ownRoute.split('/').length - 0) routes.add(r);
     }
   }
+  for (const n of negated) if (!routes.has(n)) routes.delete(n);
   // keep only routes that extend beyond the own route (a distinct downstream surface)
-  return [...routes].filter((r) => r !== ownRoute && (!ownRoute || r.startsWith(ownRoute + '/') || r.split('/').length >= 3));
+  return [...routes].filter((r) => !negated.has(r) && r !== ownRoute && (!ownRoute || r.startsWith(ownRoute + '/') || r.split('/').length >= 3));
 }
 
 /**
@@ -100,9 +122,27 @@ export function sameScreenName(slug: string, label: string): boolean {
   return i >= 5 && i / Math.min(a.length, b.length) >= 0.6;
 }
 
-export function downstreamScope(specText: string, scenarios: ScenarioInfo[]): DownstreamResult {
-  const routes = downstreamRoutes(specText);
+export function downstreamScope(
+  specText: string, scenarios: ScenarioInfo[], featureText = '',
+): DownstreamResult {
+  const all = downstreamRoutes(specText);
+  // A one-segment route that other declared routes are BUILT ON is a prefix, not a destination:
+  // a spec noting that "every route is served under a `/xx/` locale prefix (e.g. `/xx/register`)"
+  // was read as declaring `/xx/` a navigation target, and no suite will ever "navigate to" it.
+  // Structural, so it catches any mount point — locale, tenant, api version — without a list.
+  const mounts = all.filter((r) => {
+    const segs = r.split('/').filter(Boolean);
+    return segs.length === 1 && all.some((o) => o !== r && o.startsWith(r.endsWith('/') ? r : `${r}/`));
+  });
+  // The same destination written twice — once bare, once under the mount the spec documents —
+  // is one navigation target, and reporting both doubles the work it asks for.
+  const routes = all.filter((r) => !mounts.includes(r)
+    && !mounts.some((m) => {
+      const bare = r.slice(m.replace(/\/$/, '').length);
+      return bare.startsWith('/') && all.includes(bare);
+    }));
   const underCovered: { route: string; slug: string }[] = [];
+  const absent: { route: string; slug: string }[] = [];
   for (const route of routes) {
     const slug = (route.split('/').filter(Boolean).pop() || route).toLowerCase();
     // Referenced when the route/slug appears literally, OR when any `[Ref]` in the suite
@@ -112,16 +152,34 @@ export function downstreamScope(specText: string, scenarios: ScenarioInfo[]): Do
     const refs = scenarios.filter((s) =>
       s.haystack.includes(slug) || s.haystack.includes(route.toLowerCase()) ||
       labelsOf(s).some((l) => sameScreenName(slug, l)));
-    if (!refs.length) continue; // not referenced at all — out of this screen's scope entirely
+    if (!refs.length) {
+      // A scenario's haystack is its name + steps, so a route documented in a @manual scenario's
+      // tester procedure — a COMMENT — looks like nothing at all. That route is accounted for: a
+      // person has been told to check it. Reporting "no scenario mentions it, add one" over a
+      // deliberate manual deferral is the false positive this whole round is about, so absence is
+      // measured against the feature TEXT, comments included (#651 follow-up).
+      if (!featureText.toLowerCase().includes(route.toLowerCase())) absent.push({ route, slug });
+      continue;
+    }
     // Substantively covered only if some scenario OPERATES on the downstream — i.e. it
     // starts there (`is on [<downstream>]`) — not merely navigates to it as a terminal
     // `see [<downstream>] page` assertion. The latter just proves the transition.
+    // Two shapes prove the screen's CONTENT was checked, not just its route:
+    //   - the suite OPENS ON it (`is on [Registration] page`), and
+    //   - it asserts an element NAMESPACED to it (`see [Registration:Submit] button`) — the
+    //     namespace names the screen, so the assertion is about that screen by construction.
+    // Only the first counted, so a scenario that navigated there and then asserted the screen's
+    // own elements was still reported "covered only by a page-nav assertion" (#630). The field
+    // report's hypothesis — that the parser reads one line after the nav and stops — is still not
+    // what happens: there is no line window, and both shapes are matched over the whole scenario.
     const contentCovered = refs.some((s) =>
       [...s.haystack.matchAll(/\bis on \[([^\]]+)\]/g)]
-        .some((m) => sameScreenName(slug, m[1].split(':')[0])));
+        .some((m) => sameScreenName(slug, m[1].split(':')[0]))
+      || [...s.haystack.matchAll(/\bsee \[([^\]:]+):[^\]]+\]/g)]
+        .some((m) => sameScreenName(slug, m[1])));
     if (!contentCovered) underCovered.push({ route, slug });
   }
-  return { downstreamRoutes: routes, underCovered };
+  return { downstreamRoutes: routes, underCovered, absent };
 }
 
 // ---------- #4 Manual-oracle ----------

package/src/harness/sensors.ts

@@ -659,7 +659,15 @@ const CLAIM_RULES: ClaimRule[] = [
     // category behind "browser back does not re-submit", "does not re-charge the card",
     // "double-click does not create two orders" — not a per-feature keyword.
     claim: 'no-side-effect/no-duplicate',
-    title: /(?=.*\b(submit|sen[dt]|resend|resubmit|re-?fire|re-?issue|re-?post|repost|create|charge|order|payment|\bpay\b|email|request|\botp\b|insert|register|book|duplicate|double[- ]?submit|again|twice)\b)(?=.*(\bno\b|\bnot\b|n['’]t\b|\bnever\b|\bwithout\b|\bcannot\b|prevent|block|avoid|reject|disabl|\bdeny\b|denies|\bkhông\b|\bchưa\b))/i,
+    // The negation must attach to an EFFECT — something created, sent, stored, charged, fired
+    // twice — not to the INPUT being refused. "duplicate address is rejected" is an observable
+    // rejection, proven by the error assertion in front of the user; "no duplicate record is
+    // created" is an absence nothing on the page can show. The rule used to fire on any action
+    // word beside any negation word, so ordinary rejection titles were told to go find a DB count,
+    // and renaming around the trigger words became the workflow (#660). Two shapes now qualify:
+    // (a) a negation followed by an effect token, (b) a repeat token (twice / again / double- or
+    // re-submit / second …) beside a negation, "only once" or a disabled control.
+    title: /(?:\b(?:no|not|n['’]t|never|without|cannot|không|chưa)\b[^.;]{0,40}?\b(?:creat(?:e|es|ed|ion)|record(?:s|ed)?|rows?|entr(?:y|ies)|sen[dt]|resen[dt]|charg(?:e|es|ed)|order(?:s|ed)?|payment|paid|insert(?:s|ed)?|submit(?:s|ted)?|submission|stor(?:e|es|ed)|sav(?:e|es|ed)|persist(?:s|ed)?|fir(?:e|es|ed)|issu(?:e|es|ed)|post(?:s|ed)?|email(?:s|ed)?|request(?:s|ed)?|\botp\b|twice|again|second|double|duplicate[sd]?|re-?submit(?:s|ted)?|tạo|gửi|lưu)\b)|(?=.*\b(?:double[- ]?(?:submit|click|tap|activation)|re-?submi(?:t|ts|tted|ssion)|twice|again|second (?:submit|submission|request|click|tap|order|charge|email|record))\b)(?=.*\b(?:no|not|n['’]t|never|without|cannot|prevent(?:s|ed)?|block(?:s|ed)?|avoid(?:s|ed)?|only once|exactly one|single|idempotent|disabled|không|chưa)\b)/i,
     // `is disabled` counts: when the spec's own mechanism against a repeat is "the control
     // is disabled immediately" (FR-014-style), asserting the disabled state IS the contrast —
     // the second activation cannot occur. Without it the canonical double-submit proof shape