@sun-asterisk/sungen 3.2.24 → 3.2.26

package/dist/harness/run-manifest.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRunManifest = buildRunManifest;
+exports.readRunManifest = readRunManifest;
+exports.writeRunManifest = writeRunManifest;
+exports.selectChanged = selectChanged;
+/**
+ * Run-manifest — which scenarios does a QA edit actually oblige us to re-run?
+ *
+ * The problem it serves: the JSON reporter writes ONE file per target, named only for the unit +
+ * platform + env, so a subset re-run overwrites the full run's results. `sungen results merge`
+ * restores the lost half, but only if the caller knew to back the file up first — and only after
+ * the caller decided WHICH cases to run. This module answers the second question deterministically
+ * so `run-test --change-only` is a computation, not a guess.
+ *
+ * Sibling of `manifest.ts`, deliberately not an extension of it: that one hashes spec.md sections
+ * to decide what to REGENERATE, this one hashes the compiled inputs to decide what to RE-RUN. Same
+ * conventions (deterministic hashing, `.sungen/` storage, a plan object), different question.
+ *
+ * The bias is fixed and one-directional: when an edit cannot be attributed to specific scenarios,
+ * EVERY scenario is selected. Over-running costs minutes; under-running reports a scenario green
+ * that never re-ran after the change that broke it, which is the failure this whole family of
+ * guards exists to prevent.
+ *
+ * Storage: `.sungen/run-manifest/<slug>.json`.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const yaml_1 = __importDefault(require("yaml"));
+const unit_paths_1 = require("./unit-paths");
+const read_text_1 = require("./read-text");
+const gherkin_parser_1 = require("../generators/gherkin-parser");
+const sha = (s) => (0, crypto_1.createHash)('sha256').update(s).digest('hex').slice(0, 16);
+/** Mirrors SelectorResolver.generateKey — a `[Ref]` becomes this before the YAML lookup. */
+const refToKey = (label) => label.normalize('NFC').toLowerCase().trim().replace(/\s+/g, ' ');
+const manifestPath = (cwd, unit) => path.join(cwd, '.sungen', 'run-manifest', `${(0, unit_paths_1.reportSlug)(unit)}.json`);
+/** Flatten a YAML mapping to `key → hash(value)`; a non-mapping file yields one whole-file entry. */
+function hashTopLevel(file) {
+    if (!fs.existsSync(file))
+        return {};
+    const text = (0, read_text_1.readTextFile)(file);
+    let doc;
+    try {
+        doc = yaml_1.default.parse(text);
+    }
+    catch {
+        // Unparseable: attribute nothing, and let the caller widen to the whole unit rather than
+        // silently treating a broken file as "no change".
+        return { __unparseable__: sha(text) };
+    }
+    // An empty or comment-only file parses to null. That is an EMPTY mapping — nothing to attribute
+    // and nothing to widen on — not an unrecognised shape. (A test-data file holding only a comment
+    // made the first probe widen to all 18 scenarios.)
+    if (doc === null || doc === undefined)
+        return {};
+    if (typeof doc !== 'object' || Array.isArray(doc))
+        return { __whole__: sha(text) };
+    const out = {};
+    for (const [k, v] of Object.entries(doc)) {
+        out[refToKey(k)] = sha(JSON.stringify(v ?? null));
+    }
+    return out;
+}
+/** Read the unit's compiled inputs and fingerprint them. */
+function buildRunManifest(cwd, unitDir, unit) {
+    const parser = new gherkin_parser_1.GherkinParser();
+    const scenarios = {};
+    const deps = {};
+    const bgParts = [];
+    for (const file of (0, unit_paths_1.featureFilesFor)(unitDir, unit)) {
+        const parsed = parser.parseFeatureFile(file);
+        if (parsed.background?.steps?.length) {
+            bgParts.push(parsed.background.steps.map((s) => `${s.keyword} ${s.text}`).join('\n'));
+        }
+        for (const sc of parsed.scenarios) {
+            const block = [...(sc.tags || []), ...sc.steps.map((s) => `${s.keyword} ${s.text}`)].join('\n');
+            scenarios[sc.name] = sha(block);
+            const sel = new Set();
+            const dat = new Set();
+            for (const st of sc.steps) {
+                if (st.selectorRef)
+                    sel.add(refToKey(st.selectorRef));
+                if (st.parentRef)
+                    sel.add(refToKey(st.parentRef));
+                if (st.childRef)
+                    sel.add(refToKey(st.childRef));
+                if (st.dataRef)
+                    dat.add(refToKey(st.dataRef));
+            }
+            deps[sc.name] = { selectors: [...sel].sort(), data: [...dat].sort() };
+        }
+    }
+    const selDir = path.join(unitDir, 'selectors');
+    const dataDir = path.join(unitDir, 'test-data');
+    const collect = (dir) => {
+        if (!fs.existsSync(dir))
+            return {};
+        const merged = {};
+        for (const f of fs.readdirSync(dir).filter((n) => /\.ya?ml$/.test(n)).sort()) {
+            Object.assign(merged, hashTopLevel(path.join(dir, f)));
+        }
+        return merged;
+    };
+    // Project-level config lives beside the units, not inside them.
+    const qaDir = path.join(cwd, 'qa');
+    const globals = {};
+    for (const name of ['app.yaml', 'datasources.yaml', 'capabilities.yaml']) {
+        const f = path.join(qaDir, name);
+        if (fs.existsSync(f))
+            globals[`qa/${name}`] = sha((0, read_text_1.readTextFile)(f));
+    }
+    return {
+        unit,
+        recordedAt: new Date().toISOString(),
+        scenarios,
+        selectorKeys: collect(selDir),
+        dataKeys: collect(dataDir),
+        deps,
+        background: sha(bgParts.join('\n---\n')),
+        globals,
+    };
+}
+function readRunManifest(cwd, unit) {
+    const p = manifestPath(cwd, unit);
+    // Absent baseline is the FIRST-RUN case, not an error — selectChanged widens to the whole unit.
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse((0, read_text_1.readTextFile)(p));
+    }
+    catch {
+        return null;
+    }
+}
+function writeRunManifest(cwd, unit, m) {
+    const p = manifestPath(cwd, unit);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(m, null, 2));
+    return p;
+}
+/** Keys whose hash differs, was added, or disappeared. */
+function movedKeys(before, after) {
+    const moved = new Set();
+    for (const k of new Set([...Object.keys(before), ...Object.keys(after)])) {
+        if (before[k] !== after[k])
+            moved.add(k);
+    }
+    return moved;
+}
+/**
+ * Which scenarios must re-run, given the recorded manifest and the current inputs.
+ *
+ * A selector key matches a step's `[Ref]` either exactly or as one of the resolver's suffixed
+ * forms (`key--button`, `key--3`), because that is how the lookup itself resolves.
+ */
+function selectChanged(before, after, 
+/**
+ * Run-affecting files an outside source (git) reports as changed. Passed in rather than read here
+ * so this function stays pure and testable; the CLI gathers the evidence. Non-empty + an
+ * otherwise-empty selection means something changed that per-key hashing cannot see (a rename, a
+ * new file shape) — unattributable, so it widens like the other unattributable cases.
+ */
+externalChanged = []) {
+    const titles = Object.keys(after.scenarios);
+    const selectAll = (reason) => ({
+        unit: after.unit,
+        scenarios: titles,
+        reasons: Object.fromEntries(titles.map((t) => [t, reason])),
+        all: true,
+        summary: { total: titles.length, selected: titles.length, firstRun: !before },
+    });
+    if (!before)
+        return selectAll('no previous run recorded');
+    const movedGlobals = movedKeys(before.globals || {}, after.globals || {});
+    if (movedGlobals.size) {
+        return selectAll(`project config changed (${[...movedGlobals].join(', ')}) — it reaches every scenario`);
+    }
+    if (before.background !== after.background)
+        return selectAll('the Background changed — it runs before every scenario');
+    if (after.selectorKeys.__unparseable__ || after.dataKeys.__unparseable__) {
+        return selectAll('a selectors/test-data file could not be parsed, so the edit cannot be attributed');
+    }
+    if (after.selectorKeys.__whole__ || after.dataKeys.__whole__) {
+        const movedWhole = movedKeys(before.selectorKeys, after.selectorKeys).size
+            || movedKeys(before.dataKeys, after.dataKeys).size;
+        if (movedWhole)
+            return selectAll('a selectors/test-data file is not a key mapping, so the edit cannot be attributed');
+    }
+    const movedSel = movedKeys(before.selectorKeys, after.selectorKeys);
+    const movedDat = movedKeys(before.dataKeys, after.dataKeys);
+    const touches = (key, dep) => key === dep || key.startsWith(`${dep}--`);
+    const reasons = {};
+    for (const title of titles) {
+        if (before.scenarios[title] !== after.scenarios[title]) {
+            reasons[title] = before.scenarios[title] ? 'its steps or tags changed' : 'new scenario';
+            continue;
+        }
+        const dep = after.deps[title] || { selectors: [], data: [] };
+        const sel = [...movedSel].filter((k) => dep.selectors.some((d) => touches(k, d)));
+        if (sel.length) {
+            reasons[title] = `selector changed: ${sel.slice(0, 3).join(', ')}`;
+            continue;
+        }
+        const dat = [...movedDat].filter((k) => dep.data.some((d) => touches(k, d)));
+        if (dat.length) {
+            reasons[title] = `test-data changed: ${dat.slice(0, 3).join(', ')}`;
+            continue;
+        }
+    }
+    let selected = titles.filter((t) => reasons[t]);
+    // Git cross-check. Per-key hashing is blind to structural moves — a renamed selectors file, a new
+    // file shape, an encoding change — because the keys simply appear or vanish. When an outside
+    // source reports run-affecting files changed and we attributed NOTHING, that is the same
+    // unattributable case as an unparseable YAML, so it widens rather than reporting "all current".
+    if (!selected.length && externalChanged.length) {
+        return selectAll(`git reports ${externalChanged.length} run-affecting file(s) changed (${externalChanged.slice(0, 3).join(', ')}) `
+            + 'that per-key hashing could not attribute');
+    }
+    return {
+        unit: after.unit,
+        scenarios: selected,
+        reasons,
+        all: false,
+        summary: { total: titles.length, selected: selected.length, firstRun: false },
+    };
+}
+//# sourceMappingURL=run-manifest.js.map

package/dist/harness/run-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-manifest.js","sourceRoot":"","sources":["../../src/harness/run-manifest.ts"],"names":[],"mappings":"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"}

package/dist/harness/spec-branches.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Mutually-exclusive branches declared in the spec, and whether each one has a scenario (#630).
+ *
+ * A field report hit the same gap three times in three different flows, in three different
+ * shapes: an `### Exception Flow A` heading left entirely blank; a decision table
+ * (`DEC-003_EmptyStateCascade`) whose three arms produced ONE covered arm and two
+ * scenarios verifying that same arm under different names; and a pseudocode block with two
+ * attention-hint branches where only the first got a case.
+ *
+ * The narrative rule already existed — "AND condition → test each branch failing independently",
+ * "business rule → 1 behavioural TC per rule". It was missed anyway, three times. So the
+ * reviewers' own conclusion is the design here: what works is an ENFORCED enumeration, the way
+ * `Viewpoint items` are enumerated and completeness-checked, not another sentence of guidance.
+ *
+ * Deliberately conservative. A branch is only claimed when the spec makes the enumeration
+ * explicit — a named heading, a table that declares conditions and outcomes, or an if/else
+ * cascade — because a false "you missed a branch" costs more trust than it buys coverage.
+ */
+import { ScenarioInfo } from './parse';
+export interface SpecBranch {
+    /** Stable id for the message: the block name plus the arm. */
+    id: string;
+    /** The distinctive token the suite is expected to cite. */
+    label: string;
+    kind: 'exception-flow' | 'alternative-flow' | 'decision-arm' | 'pseudocode-arm';
+    /** Where it was found, so the author can go and read it. */
+    source: string;
+}
+export declare function specBranches(specText: string): SpecBranch[];
+export declare function unenumeratedBranches(branches: SpecBranch[], featureText: string): SpecBranch[];
+/**
+ * Scenarios whose assertions are IDENTICAL — "N cases" in a coverage sheet that verify one arm N
+ * times. The field report's decision table produced exactly this: two cases under different
+ * names, both asserting the same message, reported as two covered branches.
+ *
+ * Compares only the assertion side: two scenarios may legitimately share setup and differ in
+ * what they prove, but if what they PROVE is identical they are one test.
+ */
+export declare function sameOracleClusters(scenarios: ScenarioInfo[]): Array<{
+    oracle: string;
+    scenarios: string[];
+}>;
+export declare function permissionPairGaps(scenarios: ScenarioInfo[]): Array<{
+    scenario: string;
+    subject: string[];
+}>;
+export declare function awaitingSeedData(testDataText: string, scenarios: ScenarioInfo[]): Array<{
+    key: string;
+    scenarios: string[];
+}>;
+/**
+ * The fixed risk catalog for a multi-screen journey, reconciled against the flow (#651 F1-7).
+ *
+ * `SPEC-BRANCH-UNCOVERED` enforces the branches a spec DECLARES. This is the other half, and the
+ * one a field report asked for explicitly: the risks a spec is often SILENT about, which a
+ * reviewer notices and a generator does not. Their words — *"cả 2 flow đều thiếu 2-3 nhóm trong
+ * danh sách này, không phải vì không áp dụng mà vì không có bước bắt buộc rà lại checklist đó
+ * trước khi coi flow 'đủ'"*.
+ *
+ * The same families as the step × risk matrix in `sungen-tc-generation`, so guidance and gate
+ * cannot drift apart. A family counts as CONSIDERED when it is mentioned anywhere the author
+ * reasons: a declared flow's branch point, outcome or reason; a scenario; or the viewpoint. That
+ * makes "we thought about it and it does not apply" a one-line answer — the accounting the flow
+ * inventory already asks for — rather than a scenario nobody needs.
+ */
+export interface RiskFamily {
+    id: string;
+    label: string;
+    /** What the author writes when they HAVE considered it. */
+    re: RegExp;
+    /** Why it bites on a multi-screen journey specifically. */
+    why: string;
+}
+export declare const MULTI_SCREEN_RISKS: RiskFamily[];
+export declare function unconsideredRisks(contract: FlowContractLike, scenarios: ScenarioInfo[], viewpointText: string): RiskFamily[];
+/** The slice of the contract this needs — kept structural so the module stays import-light. */
+export interface FlowContractLike {
+    flows?: Array<{
+        id: string;
+        branchFrom?: string;
+        outcome?: string;
+        reason?: string;
+    }>;
+    minimalGuarantee?: string;
+    successGuarantee?: string;
+    precondition?: string;
+}
+//# sourceMappingURL=spec-branches.d.ts.map

package/dist/harness/spec-branches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-branches.d.ts","sourceRoot":"","sources":["../../src/harness/spec-branches.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,GAAG,cAAc,GAAG,gBAAgB,CAAC;IAChF,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;CAChB;AA6DD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CA8D3D;AAYD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,EAAE,CAc9F;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAgB5G;AAgBD,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,YAAY,EAAE,GACxB,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAmBhD;AAWD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAC9C,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAgB7C;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,kBAAkB,EAAE,UAAU,EA4B1C,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,aAAa,EAAE,MAAM,GAC3E,UAAU,EAAE,CAUd;AAED,+FAA+F;AAC/F,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtF,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/harness/spec-branches.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MULTI_SCREEN_RISKS = void 0;
+exports.specBranches = specBranches;
+exports.unenumeratedBranches = unenumeratedBranches;
+exports.sameOracleClusters = sameOracleClusters;
+exports.permissionPairGaps = permissionPairGaps;
+exports.awaitingSeedData = awaitingSeedData;
+exports.unconsideredRisks = unconsideredRisks;
+/**
+ * CamelCase identifiers only — an outcome LABEL (`StateNoItems`, `HintPrimary`).
+ *
+ * SCREAMING_SNAKE was in this pattern and produced two false branches on a real spec:
+ * `DEFAULT_FILTER` from `conditions !== DEFAULT_FILTER` and `MESSAGE_READ` from a permission check.
+ * Those are OPERANDS inside a condition, not arms of it — a constant names a value, an outcome
+ * names a result. Shape alone cannot tell them apart, so the shape that only outcomes use is the
+ * one to match (#651 follow-up).
+ */
+const IDENTIFIER = /\b([A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)+)\b/g;
+/**
+ * Code references are not branch labels. A table cell citing
+ * `src/components/molecules/HomeBoard/AlertPanel.tsx` yielded four "branches" —
+ * AlertPanel, TaskPanel, FeaturedList, HomeBoard — none of which is a branch at all.
+ * Backticked spans and anything path-shaped go before identifiers are read.
+ */
+function withoutCodeRefs(text) {
+    return text
+        .replace(/`[^`]*`/g, ' ') // inline code spans
+        .replace(/\[[^\]]*\]\([^)]*\)/g, ' ') // markdown links
+        .replace(/\S*\/\S*/g, ' ') // any path-like token
+        .replace(/\b\w+\.(?:tsx?|jsx?|vue|py|rb|go|java|kt|swift|md|ya?ml|json)\b/gi, ' ');
+}
+/** A named decision/rule block: `DEC-003_Foo`, `BR-001_Bar`, `ALG-002`. */
+const NAMED_BLOCK = /\b((?:DEC|BR|ALG|RULE|DISC)-\d+)(?:_([A-Za-z0-9]+))?\b/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+/**
+ * Split a markdown document into `{ heading, lines }` sections, so a table or fence can be
+ * attributed to the block that names it.
+ */
+function sections(text) {
+    const out = [{ heading: '', lines: [] }];
+    for (const raw of text.split('\n')) {
+        const h = raw.match(HEADING);
+        if (h)
+            out.push({ heading: h[2].replace(/[*`]/g, '').trim(), lines: [] });
+        else
+            out[out.length - 1].lines.push(raw);
+    }
+    return out;
+}
+/** Does this table declare CONDITIONS mapping to OUTCOMES (a decision table)? */
+function isDecisionTable(header, sectionHeading) {
+    const cells = header.map((c) => c.toLowerCase());
+    // A Given/When/Then table is a list of TEST CASES, not a decision to enumerate — each row is
+    // already a case. It matched on `when`+`then` and turned a real spec's test-case table into
+    // five phantom branches (#651 follow-up).
+    const isGherkinTable = cells.some((c) => /\bgiven\b/.test(c)) && cells.some((c) => /\bwhen\b/.test(c))
+        && cells.some((c) => /\bthen\b/.test(c));
+    const isTestCaseTable = cells.some((c) => /test[- ]?id|tc[- ]?id|case[- ]?id/.test(c));
+    if (isGherkinTable || isTestCaseTable)
+        return false;
+    const hasCondition = cells.some((c) => /condition|case|when|input|state|flag|criteria|nhánh|điều kiện/.test(c));
+    const hasOutcome = cells.some((c) => /outcome|result|then|display|shows?|expected|action|behaviou?r|kết quả/.test(c));
+    // A block the spec itself NAMES as a decision counts even if its columns are worded oddly.
+    return (hasCondition && hasOutcome) || /\b(?:DEC|decision|cascade|matrix)\b/i.test(sectionHeading);
+}
+function specBranches(specText) {
+    const out = [];
+    const seen = new Set();
+    const push = (b) => {
+        const k = `${b.id}|${b.label}`;
+        if (seen.has(k))
+            return;
+        seen.add(k);
+        out.push(b);
+    };
+    for (const sec of sections(specText)) {
+        // 1. An `### Exception Flow A` / `### Alternative Flow 2` heading IS one branch. Unambiguous.
+        const flowH = sec.heading.match(/^(exception|alternative|alternate)\s+flow\s*([A-Z0-9][\w-]*)?/i);
+        if (flowH) {
+            const label = sec.heading;
+            push({
+                id: label, label,
+                kind: /^exception/i.test(flowH[1]) ? 'exception-flow' : 'alternative-flow',
+                source: `heading "${sec.heading}"`,
+            });
+            continue;
+        }
+        const named = sec.heading.match(NAMED_BLOCK);
+        const blockName = named ? named[0] : sec.heading;
+        // 2. A decision table: each data row is one arm. Matched on the identifier the row names.
+        const rows = sec.lines.filter((l) => l.trim().startsWith('|') && !/^\|[\s|:-]+\|?$/.test(l.trim()));
+        if (rows.length >= 3) { // header + at least two arms
+            const header = rows[0].split('|').map((c) => c.trim()).filter(Boolean);
+            if (isDecisionTable(header, sec.heading)) {
+                for (const row of rows.slice(1)) {
+                    const ids = [...withoutCodeRefs(row).matchAll(IDENTIFIER)].map((m) => m[1]);
+                    // Only an identifier is distinctive enough to look for in a suite; a prose condition
+                    // would match half the feature file.
+                    for (const id of ids)
+                        push({ id: `${blockName}:${id}`, label: id, kind: 'decision-arm', source: `decision table under "${sec.heading}"` });
+                }
+            }
+        }
+        // 3. An if/elif/else cascade in a fenced block: each arm that NAMES an outcome identifier.
+        let inFence = false;
+        let fence = [];
+        for (const l of sec.lines) {
+            if (l.trim().startsWith('```')) {
+                if (inFence) {
+                    const body = fence.join('\n');
+                    const arms = (body.match(/\b(?:else\s+if|elif|if|else)\b/g) ?? []).length;
+                    if (arms >= 2) {
+                        for (const m of withoutCodeRefs(body).matchAll(IDENTIFIER)) {
+                            push({ id: `${blockName}:${m[1]}`, label: m[1], kind: 'pseudocode-arm', source: `pseudocode under "${sec.heading}"` });
+                        }
+                    }
+                    fence = [];
+                }
+                inFence = !inFence;
+                continue;
+            }
+            if (inFence)
+                fence.push(l);
+        }
+    }
+    return out;
+}
+/**
+ * Branches with no scenario citing them. A citation counts anywhere in the feature text —
+ * title, steps or a comment — because an author who deliberately excludes a branch writes the
+ * reason as a comment, and that is an accounting, not a gap.
+ */
+const GENERIC_WORD = new Set([
+    'flow', 'exception', 'alternative', 'alternate', 'the', 'and', 'with', 'without', 'when', 'then',
+    'user', 'visitor', 'screen', 'page', 'from', 'that', 'this', 'case', 'gate', 'step',
+]);
+function unenumeratedBranches(branches, featureText) {
+    const hay = featureText.toLowerCase();
+    return branches.filter((b) => {
+        // An IDENTIFIER is precise — require it verbatim. A HEADING is prose the author will
+        // rephrase ("Exception Flow A — drawer confirm gate" becomes "closing the drawer without
+        // confirming"), so match on its distinctive words instead: demanding the heading verbatim
+        // would report a branch that is covered under a better name.
+        if (b.kind === 'decision-arm' || b.kind === 'pseudocode-arm')
+            return !hay.includes(b.label.toLowerCase());
+        const words = [...new Set((b.label.toLowerCase().match(/[a-z][a-z-]{3,}/g) ?? []))]
+            .filter((w) => !GENERIC_WORD.has(w));
+        if (words.length === 0)
+            return !hay.includes(b.label.toLowerCase());
+        const hits = words.filter((w) => hay.includes(w)).length;
+        return hits < Math.min(2, words.length);
+    });
+}
+/**
+ * Scenarios whose assertions are IDENTICAL — "N cases" in a coverage sheet that verify one arm N
+ * times. The field report's decision table produced exactly this: two cases under different
+ * names, both asserting the same message, reported as two covered branches.
+ *
+ * Compares only the assertion side: two scenarios may legitimately share setup and differ in
+ * what they prove, but if what they PROVE is identical they are one test.
+ */
+function sameOracleClusters(scenarios) {
+    const byOracle = new Map();
+    for (const s of scenarios) {
+        if (s.manual)
+            continue; // a procedure's oracle is prose
+        const asserts = [...(s.steps ?? [])]
+            .filter((st) => st.bucket === 'then')
+            .map((st) => st.text.toLowerCase().replace(/\s+/g, ' ').trim())
+            .sort();
+        if (asserts.length === 0)
+            continue;
+        const key = asserts.join(' ; ');
+        byOracle.set(key, [...(byOracle.get(key) ?? []), s.name]);
+    }
+    return [...byOracle.entries()]
+        .filter(([, names]) => names.length > 1)
+        .map(([oracle, names]) => ({ oracle: oracle.slice(0, 100), scenarios: names }))
+        .sort((a, b) => b.scenarios.length - a.scenarios.length);
+}
+/**
+ * A "denied → hidden" scenario with no "allowed → shown" counterpart (#630).
+ *
+ * Two security cases proved that chat content is hidden when `MESSAGE_READ` is denied. If the code
+ * hid it unconditionally — ignoring the permission entirely — both still pass. The deny side alone
+ * cannot distinguish "the guard works" from "the feature is broken for everyone", so the pair is
+ * the test, exactly as `min-1 / min / max / max+1` is the test for a boundary.
+ *
+ * The mirror of the negative-claim rule the skill already has, on the other side.
+ */
+const DENY_SHAPE = /\b(?:denied|deny|denies|forbidden|not authoriz\w*|unauthoriz\w*|no permission|without (?:the )?(?:permission|right|access|flag)|permission (?:is )?off|flag (?:is )?off|revoked|restricted)\b/i;
+const HIDDEN_SHAPE = /\b(?:is hidden|are hidden|not (?:visible|shown|displayed)|blocked|masked|redacted|does not (?:show|render|appear))\b/i;
+const ALLOW_SHAPE = /\b(?:granted|allowed|permitted|authoriz\w*|has (?:the )?(?:permission|right|access)|permission (?:is )?on|flag (?:is )?on|with (?:the )?(?:permission|right|access))\b/i;
+function permissionPairGaps(scenarios) {
+    const denies = scenarios.filter((s) => DENY_SHAPE.test(s.haystack) && HIDDEN_SHAPE.test(s.haystack));
+    if (denies.length === 0)
+        return [];
+    const allows = scenarios.filter((s) => ALLOW_SHAPE.test(s.haystack) && !HIDDEN_SHAPE.test(s.stepsText));
+    // Words only — the scenario ID is stripped first, because `[a-z][a-z-]{4,}` happily matches
+    // `fl-er-` and an id fragment can never appear in the counterpart's title, so demanding it made
+    // the pair impossible to find.
+    const distinctive = (s) => [...new Set((s.name.replace(/^\S+\s*/, '').toLowerCase().match(/[a-z]{5,}/g) ?? []))]
+        .filter((w) => !GENERIC_WORD.has(w) && !/denied|denies|hidden|permission|scenario/.test(w));
+    const out = [];
+    for (const d of denies) {
+        const subject = distinctive(d);
+        // The counterpart has to be about the SAME thing — two shared distinctive words, the same
+        // bar the ledger's prose matching uses.
+        const paired = allows.some((a) => subject.filter((w) => a.haystack.includes(w)).length >= Math.min(2, subject.length));
+        if (!paired)
+            out.push({ scenario: d.name, subject: subject.slice(0, 4) });
+    }
+    return out;
+}
+/**
+ * Scenarios blocked on test data that is still a placeholder (#630).
+ *
+ * A deliverable reported "Pending" for a case whose design was finished and whose only blocker was
+ * an unseeded ENV-BOUND value — indistinguishable, on the report, from a case with an unresolved
+ * design problem. One is a data task, the other is test work; they should not read the same.
+ */
+const SEED_PLACEHOLDER = /^(?:TODO[_-]?SEED\w*|TODO|TBD|<[^>]+>|REPLACE[_-]?ME|FILL[_-]?ME|CHANGE[_-]?ME|XXX+)$/i;
+function awaitingSeedData(testDataText, scenarios) {
+    // One placeholder key is ONE data task, however many files or lines mention it — a real project
+    // reported the same key three times because its overlays each declare it (#651 follow-up).
+    const placeholders = [...new Set([...testDataText.matchAll(/^\s*([A-Za-z0-9_.-]+)\s*:\s*["']?([^"'\n#]+?)["']?\s*(?:#.*)?$/gm)]
+            .filter((m) => SEED_PLACEHOLDER.test(m[2].trim()))
+            .map((m) => m[1]))];
+    if (placeholders.length === 0)
+        return [];
+    return placeholders
+        .map((key) => ({
+        key,
+        scenarios: scenarios.filter((s) => s.stepsText.includes(`{{${key.toLowerCase()}`)
+            || new RegExp(`\\{\\{[a-z0-9_.-]*\\.${key.toLowerCase()}\\}\\}`).test(s.stepsText)).map((s) => s.name),
+    }))
+        .filter((p) => p.scenarios.length > 0);
+}
+exports.MULTI_SCREEN_RISKS = [
+    { id: 'double-submit', label: 'double submit / double activation',
+        re: /\b(?:double[- ]?(?:submit|click|tap|activation)|twice|two taps?|idempoten\w*|re-?submit|duplicate request)\b/i,
+        why: 'a second activation before the first response is the classic way one journey creates two records' },
+    { id: 'concurrency', label: 'two tabs / two devices at once',
+        re: /\b(?:two tabs?|second tab|another tab|multi[- ]?tab|two devices|second device|concurrent\w*|simultaneous\w*|race)\b/i,
+        why: 'a journey that buffers state client-side behaves differently when two of it run at once' },
+    { id: 'client-buffer', label: 'client-side buffer kept / lost',
+        re: /\b(?:session ?storage|local ?storage|buffer\w*|draft|unsaved|re-?hydrat\w*|restore[sd]?)\b/i,
+        why: 'state held between two steps must be proved BOTH ways — it survives a legitimate return, and it is lost when the spec says it is' },
+    { id: 'server-error', label: 'a mid-journey server error',
+        re: /\b(?:server error|5\d{2}\b|network (?:error|drop|failure)|offline|timeout|unavailable|fails? server-?side|retry)\b/i,
+        why: 'the interesting question is what survives the failure, not that an error appeared' },
+    { id: 'abandonment', label: 'abandonment / TTL of partial state',
+        re: /\b(?:abandon\w*|lapse[sd]?|expir\w*|ttl\b|stale|cleanup|24 ?h|dormant|never (?:completed|finished))\b/i,
+        why: 'a journey stopped halfway leaves state somebody owns; a flow test is where that becomes visible' },
+    { id: 'direct-access', label: 'direct URL access to a later step',
+        re: /\b(?:direct(?:ly)? access|deep[- ]?link|without (?:a |an |the )?(?:context|session|prior)|guard|not skippable|redirect\w*)\b/i,
+        why: 'every step after the first is reachable by URL, and only a journey test can check the guard' },
+    { id: 'auth-transition', label: 'where the session begins',
+        re: /\b(?:authenticat\w*|unauthenticat\w*|signed[- ]in|logged[- ]in|session (?:is )?(?:established|created|begins)|auto[- ]?login)\b/i,
+        why: 'the step where an actor stops being anonymous is a boundary no single screen owns' },
+    { id: 'escape-hatch', label: 'a documented way out of the journey',
+        re: /\b(?:cancel|back to top|exit|leave[sd]? the (?:journey|flow)|opt[- ]?out|skip|dismiss)\b/i,
+        why: 'a designed-for exit is an alternate flow with its own outcome, not an error' },
+    { id: 'side-effect-order', label: 'ordering of a delayed side effect',
+        re: /\b(?:mail|email|notification|webhook|queue|async|delayed|eventual\w*|dispatch\w*|side[- ]effect)\b/i,
+        why: 'a journey that triggers an out-of-band effect is where its ordering and its absence both matter' },
+];
+function unconsideredRisks(contract, scenarios, viewpointText) {
+    // Everywhere the author reasons about the journey. A mention in ANY of them is consideration —
+    // the check asks "did you think about this?", not "did you write a scenario for it?".
+    const corpus = [
+        viewpointText,
+        ...scenarios.map((s) => s.haystack),
+        ...(contract.flows ?? []).flatMap((f) => [f.id, f.branchFrom ?? '', f.outcome ?? '', f.reason ?? '']),
+        contract.minimalGuarantee ?? '', contract.successGuarantee ?? '', contract.precondition ?? '',
+    ].join('\n').toLowerCase();
+    return exports.MULTI_SCREEN_RISKS.filter((r) => !r.re.test(corpus));
+}
+//# sourceMappingURL=spec-branches.js.map