@sun-asterisk/sungen 3.2.34-beta.1 → 3.3.0-alpha.1

package/src/harness/sensors.ts

@@ -12,8 +12,9 @@ import { parse as parseYaml } from 'yaml';
 import { ScenarioInfo, ViewpointEntry, idPrefix } from './parse';
 import { readTextFile } from './read-text';
 import { keywordHit, hasKeyword } from './keyword-match';
-import { parsePriority } from './viewpoint-priority';
 import { countedAssertions } from './counted-assertions';
+import { CATALOG_GATE_RULES, GateRules } from './gates/resolve-rule';
+import { ruleVerdict, sensorSeverityOf } from './gates/gate-terms';
 
 // Business-critical category keywords (matched by CONTAINMENT against the VP category, so a
 // compound category like LIST-DISPLAY / ADD-TO-CART / PRODUCT-DISCOVERY classifies correctly).
@@ -277,6 +278,8 @@ export function assertionDepth(
   scenarios: ScenarioInfo[],
   dataThemes: CatalogTheme[] = [],
   focus = 'functional',
+  /** The unit's gate rules; the catalog alone (today's levels) by default. */
+  rules: GateRules = CATALOG_GATE_RULES,
 ): DepthResult {
   const nonManual = scenarios.filter((s) => !s.manual);
   const shallow = nonManual.filter((s) => s.shallow);
@@ -300,8 +303,7 @@ export function assertionDepth(
   const ratio = required.length ? 1 - reqShallow.length / required.length : 1;
 
   const threshold = DEPTH_THRESHOLDS[focus] ?? DEPTH_THRESHOLDS.functional;
-  let verdict: DepthVerdict = 'pass';
-  if (ratio < threshold) verdict = WARN_ONLY_FOCUS.has(focus) ? 'warn' : 'fail';
+  const verdict = ruleVerdict(rules, 'audit.assertion-depth', ratio < threshold, WARN_ONLY_FOCUS.has(focus));
 
   return {
     total: nonManual.length,
@@ -712,7 +714,10 @@ export interface ClaimUnproven {
   claim: string;       // the claim keyword matched in the title
   need: string;        // the assertion shape the steps must contain
   hint: string;        // how to fix
-  severity: 'fail' | 'warn';
+  /** Resolved from the row's catalog rule (fail = blocks when under the ratio; info only via an override). */
+  severity: 'fail' | 'warn' | 'info';
+  /** The gate rule that decided `severity` (`claim.*`, or `claim.partial-proof`). */
+  rule: string;
 }
 
 export interface ClaimProofResult {
@@ -727,16 +732,17 @@ export interface ClaimProofResult {
 }
 
 interface ClaimRule {
+  /** The catalog rule (`claim.*`) whose resolved severity a missing proof gets (OES-11.2). */
+  rule: string;
   claim: string;
   title: RegExp;        // claim keyword(s) in the title
   proof: RegExp;        // required assertion shape in the steps
   need: string;
   hint: string;
-  severity: 'fail' | 'warn';
   // Optional: even when `proof` matches, if `underproof` also matches the proof is
-  // PARTIAL (the right shape exists but on the wrong/another element) → a warn-level
-  // finding. e.g. an "each card exposes <action>" claim that has a see-all on price
-  // but asserts the actions with singular presence.
+  // PARTIAL (the right shape exists but on the wrong/another element) → a finding at the
+  // `claim.partial-proof` rule's level. e.g. an "each card exposes <action>" claim that has
+  // a see-all on price but asserts the actions with singular presence.
   underproof?: RegExp;
   underNeed?: string;
   underHint?: string;
@@ -750,29 +756,30 @@ const CLAIM_RULES: ClaimRule[] = [
     // catch, so proving it with a substring proves the opposite of what the title says. Found on
     // a real basic flow whose seven confirmation rows all used `contains` while claiming the six
     // values "survive unchanged" (#599).
+    rule: 'claim.unchanged-preserved',
     claim: 'unchanged/preserved',
     title: /\b(unchanged|unmodified|un-?edited|identical|preserved|intact|verbatim|as entered|without (?:any )?(?:change|modification))\b/,
     proof: /^(?![\s\S]*\bcontains \{\{)/,
     need: 'exact-value assertions (`see [X] text with {{v}}` / `field with {{v}}`) for the values the title says are unchanged',
     hint: 'swap `contains {{v}}` for `with {{v}}` on the continuity rows. A substring match cannot distinguish "unchanged" from "changed by adding a prefix" — and if the screen genuinely renders extra text around the value, say so in the title instead of claiming exactness.',
-    severity: 'warn',
   },
   {
     // An ORDER claim ("sorted by date descending", "ties broken by last-updated") is invisible to
     // a presence check: `see [List] table` passes whatever order the rows are in. It sits ahead of
     // the generic rules so "all results sorted …" is judged as an ordering claim, not an all-claim.
     // A tiebreaker is a Tier-1 guard in the tc-generation skill, yet no rule recognised it (#810).
+    rule: 'claim.ordering-sort',
     claim: 'ordering/sort',
     title: /\b(ascending|descending|sorted|sorts|sort order|ordered by|order by|in (?:chronological|alphabetical|reverse|numeric) order|(?:newest|oldest|latest|earliest|highest|lowest) first|tie-?break(?:s|er|ers)?|ties?)\b|降順|昇順|並び順|giảm dần|tăng dần|sắp xếp/,
     proof: /match data|is sorted|sorted (?:ascending|descending)|\brow \d+\b|\.first\.|\.last\.|\[\d+\]\.|order by/,
     need: 'an order-sensitive assertion (`table match data:` rows in the expected order, `is sorted ascending|descending`, or positional `row N` checks)',
     hint: 'a presence check passes in any order — assert the rows in their expected sequence (`User see [T] table match data:`), or the column sort state; a tiebreak needs two rows sharing the primary key.',
-    severity: 'fail',
   },
   {
     // A LIMIT claim ("never exceeds 10", "at most 5 files") is a count claim in disguise.
     // Ahead of 'no-side-effect', whose negation+effect pattern would otherwise swallow
     // "never exceeds 10 records" and ask for a duplicate-count proof.
+    rule: 'claim.limit-cap',
     claim: 'limit/cap',
     // The quantity must be ≥2 ("at most ONE order" is a no-duplicate claim — left to the rules
     // below) and not a duration ("up to 30 seconds" is a timing claim, not a cap).
@@ -780,51 +787,50 @@ const CLAIM_RULES: ClaimRule[] = [
     proof: /\bcount\b|tohavecount|table with|row with \{\{|match data|is at most|\bexactly\b|field with \{\{|\berror\b|invalid|is disabled/,
     need: 'a count/boundary assertion (count is N, `is at most`, the N+1th input rejected or truncated)',
     hint: 'assert the boundary itself — the count at the cap, or the value/error when one more is attempted — not just that the list or field is present.',
-    severity: 'fail',
   },
   {
+    rule: 'claim.all-every-each',
     claim: 'all/every/each',
     title: /\b(all|every|each)\b/,
     proof: /\bsee all\b/,
     need: 'a `User see all …` assertion (every element, not one)',
     hint: 'assert across all matched elements — for per-card structure use the all-card DSL (roadmap Q2).',
-    severity: 'fail',
     // singular action presence under an "each/every" claim = partial proof
     underproof: /\bsee \[[^\]]+\] (link|button)\b/,
     underNeed: 'an all-card assertion for the claimed action (not single presence)',
     underHint: 'the actions are asserted once, not per-card — wrap them with the all-card DSL `User see all [Card] contain [Action]` (roadmap Q2).',
   },
   {
+    rule: 'claim.only-belong-to',
     claim: 'only/belong-to',
     title: /\b(only|belongs? to|exclusively)\b/,
     proof: /\bsee all\b[^.]*\bcontain/,
     need: 'all-match (`User see all … contains …`)',
     hint: 'all displayed items must match the facet; "no items OUTSIDE" is UI-limited → verify via hybrid API/DB or mark @manual with reason.',
-    severity: 'warn',
   },
   {
+    rule: 'claim.single-exactly-one',
     claim: 'single/exactly-one',
     title: /\b(a single|single|exactly one|just one|only one)\b/,
     proof: /\bcount\b|\btable with\b|\bexactly\b|tohavecount/,
     need: 'a count assertion (e.g. count is 1)',
     hint: 'assert the quantity, not just presence.',
-    severity: 'fail',
   },
   {
+    rule: 'claim.correct-matching-identity',
     claim: 'correct/matching/identity',
     title: /\b(correct|matching|the same|same (product|name|price|value|item)|consistency|identity|lands? in|is the (product|item))\b/,
     proof: /\bremember\b/,
     need: 'capture + compare (`User remember … as {{v}}` then assert {{v}})',
     hint: 'remember the value on the source, then assert it on the target (cross-screen → defer to a flow as @manual).',
-    severity: 'fail',
   },
   {
+    rule: 'claim.changes-toggles',
     claim: 'changes/toggles',
     title: /\b(changes?|toggles?|updates?|reflects?|reopens?)\b/,
     proof: /\bremember\b|\bis hidden\b/,
     need: 'a state delta (before ≠ after, or a visible→hidden contrast)',
     hint: 'capture the before-state and assert the after-state differs, or assert the visible/hidden transition.',
-    severity: 'warn',
   },
   {
     // GENERAL — mutation-absence. A title asserts that a STATE-CHANGING action does NOT
@@ -835,6 +841,7 @@ const CLAIM_RULES: ClaimRule[] = [
     // count/contrast (record count unchanged) or defer to @manual. This is the general
     // 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.
+    rule: 'claim.no-side-effect',
     claim: 'no-side-effect/no-duplicate',
     // 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
@@ -852,33 +859,33 @@ const CLAIM_RULES: ClaimRule[] = [
     proof: /\bcount\b|ok_count|status_counts|row with \{\{|table with|tohavecount|is hidden|are hidden|is disabled|are disabled|not complete|no longer/,
     need: 'a record/request-count proof (count stays at one, e.g. `User see [Table] row with {{count}}`, an API `{{name.ok_count}}` invariant, or a `@query` DB count) or @manual with a request-count oracle',
     hint: 'a "does-not-happen / does-not-repeat" claim about a state-changing action is NOT proven by a terminal `see [...] page` — that page is identical whether or not the action (re-)fired. Prove the side-effect count is unchanged, or mark @manual with a setup→action→assert-no-duplicate oracle.',
-    severity: 'fail',
   },
   {
+    rule: 'claim.hidden-rejected',
     claim: 'hidden/rejected/not-complete',
     title: /\b(hidden|closed|dismiss(es|ed)?|not complete|rejected|inert)\b/,
     proof: /\bis hidden\b|\bare hidden\b|message is hidden|not complete|\bhidden\b/,
     need: 'a negative / hidden assertion (`… is hidden`)',
     hint: 'assert the absence/hidden state that the title claims, not just an unrelated visible element.',
-    severity: 'fail',
   },
   {
+    rule: 'claim.cleared-emptied',
     claim: 'cleared/emptied',
     title: /\b(cleared|clears|emptied|empties|reset to empty|wiped)\b/,
     proof: /\bis empty\b|with \{\{empty|with ['"]?['"]?\s*$|\bempty\b/,
     need: 'an empty/cleared assertion after the action (e.g. `field with {{empty_value}}` / `is empty`)',
     hint: 'prove the value is actually gone — return to the screen and assert the field is empty, not just that the action ran.',
-    severity: 'fail',
   },
   {
+    rule: 'claim.restored-preserved',
     claim: 'restored/preserved',
     title: /\b(restored|preserved|persists?|retained|remembered|kept)\b/,
     proof: /\bremember\b|with \{\{|field with/,
     need: 'the value re-asserted after the transition (capture or `field with {{v}}` after returning)',
     hint: 'prove the value survives — assert the field still holds the typed value after the reload/return, not just that it was typed.',
-    severity: 'warn',
   },
   {
+    rule: 'claim.independent-separate',
     claim: 'independent/separate',
     title: /\b(independent|separate|isolat(ed|es)|per[- ]tab|two tabs|each tab)\b/,
     // A storage `does not exist` check on the OTHER tenant's key proves isolation
@@ -887,23 +894,22 @@ const CLAIM_RULES: ClaimRule[] = [
     proof: /\bcontext\b|tab a|tab b|second (tab|context)|does not exist/,
     need: 'a multi-context proof (tab A vs tab B)',
     hint: 'independence across tabs/contexts is rarely DSL-expressible — mark @manual with a clear setup/action/oracle.',
-    severity: 'warn',
   },
   {
+    rule: 'claim.sanitized-inert',
     claim: 'sanitized/inert',
     title: /\b(sanitized|sanitised|escaped|inert|not executed|not rendered|stripped)\b/,
     proof: /field with \{\{|payload|inert|toContainText|is hidden/,
     need: 'the payload echoed as inert text (`field with {{payload}}`) + no execution',
     hint: 'prove the payload round-trips as literal text and triggers nothing — assert the field value and the absence of any effect.',
-    severity: 'warn',
   },
   {
+    rule: 'claim.announces-aria',
     claim: 'announces/aria',
     title: /\b(announce[sd]?|aria|screen[- ]reader|programmatically associated)\b/,
     proof: /aria|role|@manual|describedby|is focused|tab order/,
     need: 'an aria/role assertion (or @manual with a screen-reader oracle)',
     hint: 'ARIA announcement is usually not DSL-expressible — assert aria attributes if possible, else @manual with an NVDA/VoiceOver oracle.',
-    severity: 'warn',
   },
   {
     // GENERAL CATCH-ALL (last) — any negative/absence title not handled by a specific
@@ -913,6 +919,7 @@ const CLAIM_RULES: ClaimRule[] = [
     // only a positive presence. WARN, because a positive proxy is sometimes a valid
     // negative proof (e.g. "stayed on the login page"); the semantic reviewer is the
     // authoritative recall layer for the residue this can't judge structurally.
+    rule: 'claim.negative-absence',
     claim: 'negative-claim/absence',
     title: /(\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,
     // `does not exist` covers the storage-absence shape — the broad "any storage
@@ -922,7 +929,6 @@ const CLAIM_RULES: ClaimRule[] = [
     proof: /is hidden|are hidden|is empty|no longer|not complete|disabl|invalid|rejected|\berror\b|\bcount\b|row with \{\{|table with|\bremember\b|\bexactly\b|tohavecount|does not exist|tab order/i,
     need: 'a proof of the ABSENCE — a contrast/empty/hidden/error/count assertion, or @manual with an oracle',
     hint: 'a negative claim ("no / not / không …") is not proven by a positive `see [X]` that looks the same whether or not the claim holds. Assert the contrast (state hidden/empty, error shown, count unchanged), or mark @manual.',
-    severity: 'warn',
   },
 ];
 
@@ -1015,7 +1021,12 @@ export function taxonomyLint(scenarios: ScenarioInfo[]): TaxonomyResult {
   return { total: scenarios.length, checked, mislabeled };
 }
 
-export function claimProof(scenarios: ScenarioInfo[], focus = 'functional'): ClaimProofResult {
+/**
+ * `rules` resolves each row's catalog rule for the unit being audited (the catalog alone by default —
+ * today's levels). A rule switched `off` by a gate-override is not measured: its unproven claim is
+ * neither counted nor reported (a partial-proof switched off leaves the claim proven).
+ */
+export function claimProof(scenarios: ScenarioInfo[], focus = 'functional', rules: GateRules = CATALOG_GATE_RULES): ClaimProofResult {
   const measured = scenarios.filter((s) => !s.manual);
   const unproven: ClaimUnproven[] = [];
   let withClaims = 0;
@@ -1024,19 +1035,17 @@ export function claimProof(scenarios: ScenarioInfo[], focus = 'functional'): Cla
     const title = s.name.toLowerCase();
     const rule = CLAIM_RULES.find((r) => r.title.test(title));
     if (!rule) continue;          // no claim → not measured
+    const miss = !rule.proof.test(s.stepsText)
+      // proof shape entirely absent → the claim's own rule decides the level
+      ? { rule: rule.rule, need: rule.need, hint: rule.hint }
+      : rule.underproof && rule.underproof.test(s.stepsText)
+        // right shape exists but only as a partial proof
+        ? { rule: 'claim.partial-proof', need: rule.underNeed ?? rule.need, hint: rule.underHint ?? rule.hint }
+        : null;
+    const severity = miss ? sensorSeverityOf(rules.resolve(miss.rule)) : undefined;
+    if (miss && severity === null && miss.rule === rule.rule) continue;   // the claim's rule is off for this unit
     withClaims++;
-    if (!rule.proof.test(s.stepsText)) {
-      // proof shape entirely absent → fail at the rule's severity
-      unproven.push({ name: s.name, claim: rule.claim, need: rule.need, hint: rule.hint, severity: rule.severity });
-    } else if (rule.underproof && rule.underproof.test(s.stepsText)) {
-      // right shape exists but only as a partial proof → warn
-      unproven.push({
-        name: s.name, claim: rule.claim,
-        need: rule.underNeed ?? rule.need,
-        hint: rule.underHint ?? rule.hint,
-        severity: 'warn',
-      });
-    }
+    if (miss && severity) unproven.push({ name: s.name, claim: rule.claim, need: miss.need, hint: miss.hint, severity, rule: miss.rule });
   }
 
   const proven = withClaims - unproven.length;
@@ -1044,10 +1053,7 @@ export function claimProof(scenarios: ScenarioInfo[], focus = 'functional'): Cla
   const threshold = DEPTH_THRESHOLDS[focus] ?? DEPTH_THRESHOLDS.functional;
 
   const hasFail = unproven.some((u) => u.severity === 'fail');
-  let verdict: DepthVerdict = 'pass';
-  if (ratio < threshold) {
-    verdict = WARN_ONLY_FOCUS.has(focus) || !hasFail ? 'warn' : 'fail';
-  }
+  const verdict = ruleVerdict(rules, 'audit.claim-proof', ratio < threshold, WARN_ONLY_FOCUS.has(focus) || !hasFail);
 
   return { total: measured.length, withClaims, proven, unproven, ratio, focus, threshold, verdict };
 }
@@ -1103,6 +1109,8 @@ export function priorityMismatches(
   const declared = new Map<string, string>();
   for (const v of viewpoints) if (v.priorityWord) declared.set(v.id.toUpperCase(), v.priorityWord);
   if (declared.size === 0) return [];
+  // `medium` and `normal` are the same rank under different names in real documents.
+  const rank = (p: string): string => (p === 'medium' ? 'normal' : p);
   const out: Array<{ id: string; declared: string; tagged: string; scenario: string }> = [];
   for (const s of scenarios) {
     const id = (s.vpId ?? '').toUpperCase();
@@ -1110,14 +1118,12 @@ export function priorityMismatches(
     // The most specific declared row that prefixes this id.
     const key = [...declared.keys()].filter((k) => id.startsWith(k)).sort((a, b) => b.length - a.length)[0];
     if (!key) continue;
-    // Both sides fold through the one priority reading (`critical` ≡ high, `medium`/`med` ≡ normal).
-    const want = parsePriority(declared.get(key)!);
-    // `deferred` and `skip` (declared not applicable, #853) have no tag equivalent — nothing to contradict.
-    if (want === 'deferred' || want === 'skip') continue;
-    // An untagged scenario states no priority, so it cannot contradict one (#861).
-    const tagged = s.priorityTag ?? (s.priority === 'unknown' ? undefined : String(s.priority));
-    if (!tagged) continue;
-    if (want !== parsePriority(tagged)) out.push({ id: key, declared: declared.get(key)!, tagged, scenario: s.name });
+    const want = rank(declared.get(key)!);
+    const got = rank(String(s.priority).toLowerCase());
+    // `critical`, `deferred` and `skip` (declared not applicable, #853) have no tag equivalent —
+    // nothing to contradict.
+    if (want === 'critical' || want === 'deferred' || want === 'skip') continue;
+    if (want !== got) out.push({ id: key, declared: declared.get(key)!, tagged: got, scenario: s.name });
   }
   return out;
 }

package/src/harness/viewpoint-baseline.ts

@@ -2,7 +2,6 @@ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { parseViewpointOverview } from './parse';
-import { isAiDraft, removeDraftLine } from './viewpoint-draft-header';
 
 /**
  * Keep the yardstick from moving with the thing it measures.
@@ -90,12 +89,7 @@ function fingerprint(ids: string[]): string {
  */
 function fileFingerprint(viewpointPath: string): string {
   try {
-    const bytes = fs.readFileSync(viewpointPath);
-    // `drafted-by: ai` is provenance that accept REMOVES, so it is not part of what was reviewed:
-    // counted, accepting a draft would read as the declaration changing. Every other byte stays raw.
-    const text = bytes.toString('utf-8');
-    const hashed = isAiDraft(text) ? Buffer.from(removeDraftLine(text), 'utf-8') : bytes;
-    return crypto.createHash('sha1').update(hashed).digest('hex').slice(0, 12);
+    return crypto.createHash('sha1').update(fs.readFileSync(viewpointPath)).digest('hex').slice(0, 12);
   } catch { return ''; }
 }
 

package/src/harness/viewpoint-ledger.ts

@@ -58,13 +58,6 @@ function claimedCount(text: string): number | null {
 }
 
 const ID_RE = /\b([A-Z]{1,5}\d{0,2}(?:[.\-][A-Za-z0-9]+)*-?\d{0,3})\b/; // VP0.Title, VP7-002, MS-HP-001, TV-01
-/**
- * A bullet declares only the id it STARTS with (after a `[ ]` checkbox); one further along is a
- * citation (`… (SG-01, …)`). `- **High** VP-…` or `- Email shown — VP-…` therefore carry no id.
- */
-const BULLET_ID = new RegExp(`^[\\s(#]*(?:\\[[ xX]\\]\\s*)?\\[?${ID_RE.source}`);
-/** A table cell that is an id and nothing else. */
-const WHOLE_ID = new RegExp(`^${ID_RE.source}$`);
 
 /**
  * Lines that DECLARE something about the checklist rather than being a checklist item —
@@ -109,31 +102,17 @@ const PROCEDURE_LEAD = /^(?:how to (?:run|test|reproduce|verify)|(?:manual )?pro
 const LIST_ITEM = /^(?:[-*+]|\d+[.)])\s+/;
 const GENERIC = new Set(['display', 'shown', 'value', 'field', 'input', 'page', 'screen', 'button', 'link', 'text', 'check', 'verify', 'should', 'with', 'when', 'then', 'user', 'this', 'that', 'each', 'item', 'items']);
 
-/**
- * `decision`: a `- D4: …` line under Design Decisions. It names the spec's intent so rows can cite
- * it; its testable part is carried by a VP row (review check 8). No scenario ever carries `D4`, so
- * as a ledger item it stayed MISSING for good — "not tested" decisions included (phase-7 D5). The
- * ledger skips it; the continuity, source and integrity checks still read it. Only that section
- * declares: a QA claim labelled `D8` elsewhere stays a claim, and an id-less decision bullet stays
- * the prose claim it always was.
- */
-export interface ViewpointItem { id?: string; text: string; decision?: true }
-const DECISION_ID = /^D\d+$/;
-const DECISIONS_SECTION = /^(?:design decisions?|quyết định(?: thiết kế)?)\b/i;
-
 /** Extract atomic checklist items from a viewpoint file (format-tolerant). */
-export function parseViewpointItems(viewpointPath: string): ViewpointItem[] {
+export function parseViewpointItems(viewpointPath: string): { id?: string; text: string }[] {
   if (!fs.existsSync(viewpointPath)) return [];
   const lines = readViewpointText(viewpointPath).split('\n');
-  const items: ViewpointItem[] = [];
+  const items: { id?: string; text: string }[] = [];
   let inFence = false;
   let inDeclarationSection = false;
   // The level an excluded section was opened at. A SUBSECTION inherits it: `### Optional`
   // nested under `## 8. Traceability Index` used to re-open the section and hand its rows
   // back as claims, because exclusion was recomputed from scratch at every heading.
   let excludedAt: number | null = null;
-  // The level the Design Decisions section was opened at, while inside it (see `decision`).
-  let decisionsAt: number | null = null;
   // Inside the list a PROCEDURE_LEAD introduced: the indent of the lead (-1 for a paragraph lead),
   // whose list items — and their wrapped continuation lines — are steps. A heading, a table, a
   // new lead, or (after a paragraph lead) a blank line once a step was read ends it: when in
@@ -168,28 +147,21 @@ export function parseViewpointItems(viewpointPath: string): ViewpointItem[] {
     if (heading) {
       const level = heading[1].length;
       if (excludedAt !== null && level > excludedAt) continue;   // still inside the excluded section
-      if (decisionsAt !== null && level > decisionsAt) continue; // a subsection of Design Decisions
       // A heading both ends the previous section and decides whether this one declares or claims.
       // Strip an ordinal prefix ("## 5. Known Issues", "## 8. Viewpoint Grouping") before
       // testing. The regex anchors at the start, so a NUMBERED heading matched nothing and
       // every excluded section leaked its rows back in as claims — a real viewpoint numbers
       // its sections, so in practice the exclusion list was doing nothing at all (#657).
-      // `Phần 4:` / `Part 4.` / `Mục 4.` number a section the same way.
-      const headText = heading[2].replace(/[*`]/g, '').replace(/^\s*(?:(?:[Pp]hần|[Pp]art|[Mm]ục|[Ss]ection)\s+)?(?:\d+|[A-Z])\s*[.):]\s*/, '').trim();
+      const headText = heading[2].replace(/[*`]/g, '').replace(/^\s*(?:\d+|[A-Z])\s*[.):]\s*/, '').trim();
       inDeclarationSection = DECLARATION_SECTION.test(headText);
       excludedAt = inDeclarationSection ? level : null;
-      decisionsAt = DECISIONS_SECTION.test(headText) ? level : null;
       continue;
     }
     if (inDeclarationSection) continue;
     let text = '';
     let lead = '';
-    let declared: RegExpMatchArray | null = null;
     const bullet = line.match(/^(?:[-*+]|\d+[.)])\s+(.*)$/);
-    if (bullet) {
-      text = bullet[1]; lead = bullet[1];
-      declared = lead.replace(/[*`]/g, '').match(BULLET_ID);
-    }
+    if (bullet) { text = bullet[1]; lead = bullet[1]; }
     else if (line.startsWith('|')) {                       // table data row
       if (/^\|[\s|:-]+\|?$/.test(line)) continue;           // separator
       // The row right above a `|---|` separator IS the header, whatever its words (`Skill #`,
@@ -200,14 +172,7 @@ export function parseViewpointItems(viewpointPath: string): ViewpointItem[] {
       const cells = line.split('|').map((c) => c.trim()).filter(Boolean);
       if (/^(vp|id|viewpoint|priority|reason|no\.?|category|item|trigger|#|pattern|applicable|notes|field|constraint|code|description|status|step|flow|ref|level|question|screen|actor|branches from|own steps|component|thành phần|trường|bước)$/i.test(cells[0] || '')) continue; // header
       text = cells.join(' — ');
-      // The lead is the row's FIRST cell, empty or not: a continuation row (`| | | case | … see SG-02 |`)
-      // declares nothing. A later cell holding an id and nothing else still declares (`| x | VP-UI-001 |`),
-      // and so does a row number followed by a cell that starts with one (`| 1 | VP-UI-001 — … |`).
-      const raw = line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.replace(/[*`]/g, '').trim());
-      lead = raw[0] ?? '';
-      declared = lead.match(ID_RE)
-        ?? (/^\d+\.?$/.test(lead) ? (raw[1] ?? '').match(BULLET_ID) : null)
-        ?? raw.slice(1).map((c) => c.match(WHOLE_ID)).find(Boolean) ?? null;
+      lead = cells[0] ?? '';
     } else continue;
     text = text.replace(/[*`]/g, '').trim();
     if (!text) continue;
@@ -222,16 +187,15 @@ export function parseViewpointItems(viewpointPath: string): ViewpointItem[] {
     // under a grouping section. It declares nothing; it points at things declared elsewhere.
     const leadIds = new Set((leadClean.match(new RegExp(ID_RE.source, 'g')) || []).filter((x) => /\d/.test(x)));
     if (leadIds.size > 1) continue;
-    const id = declared && /\d/.test(declared[1]) ? declared[1] : undefined; // require a digit so prose words aren't IDs
+    const idM = leadClean.match(ID_RE) ?? text.match(ID_RE);
+    const id = idM && /\d/.test(idM[1]) ? idM[1] : undefined; // require a digit so prose words aren't IDs
     // A row keyed by a bare GROUP prefix ("VP-LOGIC — transitions — High — why the flow exists")
     // declares a family and its priority, not a checklist item: nothing can "cover" it, and
     // demanding coverage sends the author looking for a test that was never meant to exist.
     if (/^VP-[A-Z]+\s*(?:—|-|\||$)/.test(leadClean) && !/\d/.test(leadClean)) continue;
     const words = (text.toLowerCase().match(/[a-z][a-z-]{3,}/g) || []).filter((w) => !GENERIC.has(w));
     if (!id && words.length < 2) continue;                 // not substantive enough to track
-    items.push(decisionsAt !== null && id && DECISION_ID.test(id)
-      ? { id, text: text.slice(0, 100), decision: true }
-      : { id, text: text.slice(0, 100) });
+    items.push({ id, text: text.slice(0, 100) });
   }
   return items;
 }
@@ -242,7 +206,6 @@ export function viewpointLedger(viewpointPath: string, scenarios: ScenarioInfo[]
   // (#622) — silently collapsing those would remove its input.
   const seen = new Set<string>();
   const items = parseViewpointItems(viewpointPath)
-    .filter((i) => !i.decision)
     .filter((i) => { const k = `${i.id ?? ''}|${i.text}`; if (seen.has(k)) return false; seen.add(k); return true; });
   if (!fs.existsSync(viewpointPath) || items.length === 0) {
     return { hasViewpoint: fs.existsSync(viewpointPath), total: 0, covered: 0, ratio: 1, missing: [], manualOnly: [], partial: [] };
@@ -434,15 +397,11 @@ export function viewpointIntegrity(
 
   // The Priority-Viewpoints table: `| <id> | <priority> | <reason> |`.
   const vpText = readViewpointText(viewpointPath);
-  const words = [...vpText
+  const rows = [...vpText
     .matchAll(new RegExp(`^\\|\\s*((?:VP|FL)[A-Z0-9._-]*)\\s*\\|\\s*(${PRIORITY_WORDS})\\s*\\|`, 'gim'))]
     .map((m) => m[2].toLowerCase());
-  // Fold only synonyms (Medium / Med / Normal are one level). `critical` stays its own word: a
-  // Critical / High / High table is a ranking, and folding it into `high` made it read as uniform.
-  const level = (w: string): string => (/^(?:medium|med|normal)$/.test(w) ? 'normal' : w);
-  const uniformPriority = words.length >= 3 && new Set(words.map(level)).size === 1
-    ? { levels: [words[0]], rows: words.length } // the word QA wrote, not the folded key
-    : null;
+  const levels = [...new Set(rows)];
+  const uniformPriority = rows.length >= 3 && levels.length === 1 ? { levels, rows: rows.length } : null;
 
   return { duplicateIds, danglingRefs, uniformPriority };
 }

package/src/hooks/bash-write-targets.ts

@@ -0,0 +1,109 @@
+/**
+ * The files a Bash command line WRITES through the three forms the pre-tool guard covers (P0.1):
+ * output redirection (`>`, `>>`, `>|`, `&>`, `2>`…), `tee`, and in-place `sed -i`.
+ *
+ * A floor, not a shell interpreter: quotes, escapes, `;`/`&&`/`||`/`|` and a leading `cd` are
+ * understood; anything else that can write a file (`cp`, a script, `python -c`) is out of scope by
+ * design. The command string is untrusted — it is only tokenized here, never executed.
+ */
+import * as path from 'path';
+
+type Tok = { kind: 'word'; value: string } | { kind: 'sep' } | { kind: 'redir'; writes: boolean };
+
+/** Commands that run another command: the real one is the next word. */
+const WRAPPERS = new Set(['sudo', 'env', 'command', 'nohup', 'time', 'exec', 'nice']);
+const ASSIGNMENT = /^[A-Za-z_]\w*=/;
+
+function tokenize(cmd: string): Tok[] {
+  const toks: Tok[] = [];
+  let word = '';
+  let inWord = false;
+  const flush = (): void => { if (inWord) toks.push({ kind: 'word', value: word }); word = ''; inWord = false; };
+  for (let i = 0; i < cmd.length;) {
+    const ch = cmd[i];
+    if (ch === "'") {
+      const end = cmd.indexOf("'", i + 1);
+      word += cmd.slice(i + 1, end < 0 ? cmd.length : end); inWord = true; i = end < 0 ? cmd.length : end + 1;
+    } else if (ch === '"') {
+      let j = i + 1;
+      for (; j < cmd.length && cmd[j] !== '"'; j++) { if (cmd[j] === '\\' && j + 1 < cmd.length) j++; word += cmd[j]; }
+      inWord = true; i = j + 1;
+    } else if (ch === '\\' && i + 1 < cmd.length) {
+      word += cmd[i + 1]; inWord = true; i += 2;
+    } else if (ch === ' ' || ch === '\t') {
+      flush(); i++;
+    } else if ('\n;|()'.includes(ch) || (ch === '&' && cmd[i + 1] !== '>')) {
+      flush(); toks.push({ kind: 'sep' }); i += (ch === '|' || ch === '&') && cmd[i + 1] === ch ? 2 : 1;
+    } else if (ch === '>' || (ch === '&' && cmd[i + 1] === '>')) {
+      if (ch === '>' && inWord && /^\d+$/.test(word)) { word = ''; inWord = false; } else flush(); // `2>`: an fd, not a word
+      i += ch === '&' ? 2 : 1;
+      if (cmd[i] === '>' || cmd[i] === '|') i++;
+      if (cmd[i] === '&') { i++; toks.push({ kind: 'redir', writes: false }); } // `>&2`: an fd dup
+      else toks.push({ kind: 'redir', writes: true });
+    } else if (ch === '<') {
+      flush(); i++;
+      while (cmd[i] === '<') i++;
+      toks.push({ kind: 'redir', writes: false });
+    } else {
+      word += ch; inWord = true; i++;
+    }
+  }
+  flush();
+  return toks;
+}
+
+const isInPlaceFlag = (a: string): boolean => a === '--in-place' || a.startsWith('--in-place=') || /^-[a-zA-Z]*i/.test(a);
+
+/** One simple command of a Bash line (`a | b && c` is three). */
+export interface BashSegment {
+  /** The command name (basename, after env assignments and wrappers like `sudo`), or ''. */
+  cmd: string;
+  /** Its arguments, and every redirection target, as written. */
+  words: string[];
+  /** The directory it runs in — a preceding `cd` in the same line is followed. */
+  dir: string;
+  /** Absolute paths it writes via redirection, `tee` or `sed -i`. */
+  writes: string[];
+}
+
+export function bashSegments(command: string, cwd: string): BashSegment[] {
+  const out: BashSegment[] = [];
+  const toks = tokenize(command);
+  let dir = cwd;
+  let seg: string[] = [];
+  let redirected: string[] = [];
+  let writes: string[] = [];
+  const endSegment = (): void => {
+    let k = 0;
+    while (k < seg.length && (ASSIGNMENT.test(seg[k]) || WRAPPERS.has(seg[k]))) k++;
+    const cmd = path.basename(seg[k] ?? '');
+    const args = seg.slice(k + 1).filter((a) => a !== '');
+    if (cmd === 'tee') writes.push(...args.filter((a) => !a.startsWith('-')).map((a) => path.resolve(dir, a)));
+    else if ((cmd === 'sed' || cmd === 'gsed') && args.some(isInPlaceFlag)) {
+      writes.push(...args.filter((a) => !a.startsWith('-')).map((a) => path.resolve(dir, a)));
+    }
+    if (cmd || redirected.length) out.push({ cmd, words: [...args, ...redirected], dir, writes });
+    if (cmd === 'cd' && args.length === 1 && !/^[-~]/.test(args[0])) dir = path.resolve(dir, args[0]);
+    seg = []; redirected = []; writes = [];
+  };
+  for (let t = 0; t < toks.length; t++) {
+    const tok = toks[t];
+    if (tok.kind === 'sep') { endSegment(); continue; }
+    if (tok.kind === 'redir') {
+      const target = toks[t + 1];
+      if (target?.kind !== 'word') continue;
+      t++;
+      redirected.push(target.value);
+      if (tok.writes && target.value && target.value !== '/dev/null' && target.value !== '-') writes.push(path.resolve(dir, target.value));
+      continue;
+    }
+    seg.push(tok.value);
+  }
+  endSegment();
+  return out;
+}
+
+/** Absolute paths the command writes via redirection, `tee` or `sed -i`, resolved against `cwd`. */
+export function bashWriteTargets(command: string, cwd: string): string[] {
+  return bashSegments(command, cwd).flatMap((s) => s.writes);
+}