@dzhechkov/p-replicator 1.5.17 → 1.6.0

package/tests/unit/roadmap-one-schema.test.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// One file, two canonical schemas. MEASURED: commands/next.md:84-96 documents feature-roadmap.json
+// with a `priority` field over the closed set mvp|high|medium|low, while
+// skills/cc-toolkit-generator-enhanced/references/templates/feature-suggestions.md names the SAME
+// path ("Generate as .claude/feature-roadmap.json") and documents a shape with NO priority at all —
+// and calls itself the single source of truth while being one of two. A generator following the
+// second produces a roadmap the package's own status line cannot read.
+//
+// The consumer was silent about it: statusline.cjs filters `f.priority === 'mvp'`, which is correct
+// against the schema, so a roadmap using `critical` — a value in NO documented enum — or carrying MVP
+// in `tags` rendered "mvp 0/0" and said nothing. The number was right and the reader learned nothing,
+// which is how a divergence becomes permanent.
+//
+// NOT DONE, deliberately: `tags.includes('mvp')` as a "fix". It would bless a document that also used
+// a value in no enum, and teach readers to accept whatever a generator emits. The counter matches the
+// specification; the documents diverged.
+//
+// Also REFUTED while measuring: the report's second defect, a supposed contradiction about who
+// creates the file. feature.md:44 sits under "### What does NOT happen in Mode 2" — it is scoped to
+// the mode where /replicate never runs. Both statements are true in their own mode; what was missing
+// is one place saying both, which P3 now requires.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const TPL = path.join(__dirname, '..', '..', 'templates', '.claude');
+const read = (rel) => fs.readFileSync(path.join(TPL, rel), 'utf-8');
+
+const NEXT = 'commands/next.md';
+const SUGGESTIONS = 'skills/cc-toolkit-generator-enhanced/references/templates/feature-suggestions.md';
+
+const STRIP = new RegExp('\\x1b\\[[0-9;]*m', 'g');
+
+/** Run the real status line over a real roadmap and return its plain-text Roadmap line. */
+function roadmapLine(features) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-schema-')));
+  try {
+    fs.mkdirSync(path.join(root, '.claude', 'hooks'), { recursive: true });
+    fs.copyFileSync(path.join(TPL, 'hooks', 'statusline.cjs'),
+      path.join(root, '.claude', 'hooks', 'statusline.cjs'));
+    fs.writeFileSync(path.join(root, '.claude', 'feature-roadmap.json'),
+      JSON.stringify({ version: '1.0', features }));
+    let code = 0;
+    let out = '';
+    try {
+      out = execFileSync(process.execPath, [path.join(root, '.claude', 'hooks', 'statusline.cjs')],
+        { cwd: root, env: Object.assign({}, process.env, { CLAUDE_PROJECT_DIR: root }),
+          encoding: 'utf8', stdio: 'pipe' }) || '';
+    } catch (err) {
+      code = err.status == null ? 1 : err.status;
+      out = err.stdout ? err.stdout.toString() : '';
+    }
+    const text = out.replace(STRIP, '');
+    return { code, line: text.split('\n').find((l) => l.includes('Roadmap')) || '' };
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+}
+
+describe('feature-roadmap.json has ONE schema, and the reader says when a file misses it', () => {
+  test('P1 — next.md declares itself canonical and closes the priority set', () => {
+    const src = read(NEXT);
+    assert.match(src, /\*\*This table is THE schema for `\.claude\/feature-roadmap\.json`\.\*\*/,
+      'the schema must claim the role explicitly, or a second document can claim it too');
+    assert.match(src, /any other\s+document that shows the file's fields must point here/,
+      'and say what other documents must do instead of restating it');
+    assert.match(src, /`priority` is a CLOSED set — `mvp`, `high`, `medium`, `low`/,
+      'the enum must be stated as closed, in the canonical place');
+  });
+
+  test('P2 — feature-suggestions.md points at the schema instead of restating one', () => {
+    const src = read(SUGGESTIONS);
+    assert.match(src, /follow `\.claude\/commands\/next\.md`, which holds the single schema/,
+      'the second document must defer, not describe');
+    // Cross-family QE: the first version was `!A || B`, which the new "single data file" phrase
+    // makes true whether or not the stale claim survives. The claim's ABSENCE is the property —
+    // but SCOPED: a later CLAUDE.md snippet in this same file calls the roadmap the source of truth
+    // for feature STATUS, which is both true and unrelated. Asserting over the whole file would have
+    // forbidden a correct sentence. The claim that mattered was the architecture line at the top.
+    const header = src.slice(0, src.indexOf('## 2.'));
+    assert.ok(!/single source of truth/.test(header),
+      'the schema-level claim must be gone from the architecture line, not merely accompanied');
+    assert.match(header, /single data file/, 'replaced by what it actually is');
+    // Its own JSON sketch must not teach the incompatible shape either: an example is what a
+    // generator copies, and an example without `priority` is a second schema in disguise.
+    const sketch = src.slice(src.indexOf('"features": ['), src.indexOf('```', src.indexOf('"features": [')));
+    assert.match(sketch, /"priority": "mvp\|high\|medium\|low"/,
+      'the example must carry the canonical priority field: ' + sketch.slice(0, 200));
+  });
+
+  test('P3 — one place answers who creates the file, for BOTH modes', () => {
+    // The report called this a contradiction. It is not: feature.md's claim is scoped to Mode 2.
+    // What was missing is a single answer, so a reader landing on one half does not conclude the
+    // other is wrong.
+    const src = read(NEXT);
+    assert.match(src, /Who creates the file/, 'the question must be answered where the schema lives');
+    assert.match(src, /Phase 3 generates it from the PRD MVP scope/, 'the /replicate half');
+    assert.match(src, /the user\s+writes it by hand/, 'and the Mode 2 half');
+  });
+
+  test('P4 — a priority outside the enum is MARKED, not silently zero', () => {
+    const r = roadmapLine([
+      { id: 'a', status: 'next', priority: 'critical' },
+      { id: 'b', status: 'done', priority: 'critical' },
+    ]);
+    assert.equal(r.code, 0, 'the status line must never fail the session');
+    assert.match(r.line, /⚠2 schema/,
+      'an unreadable roadmap must say so, and say HOW MUCH: ' + r.line);
+    // Cross-family QE: the first version replaced the count with '?', discarding what WAS
+    // established. The known count is still knowledge; show both.
+    assert.match(r.line, /mvp 0\/0 ⚠2/,
+      'the known count must survive beside the warning: ' + r.line);
+  });
+
+  test('P5 — MVP moved into tags, no priority at all: also MARKED', () => {
+    // The exact shape the field report was collected on.
+    const r = roadmapLine([
+      { id: 'a', status: 'next', tags: ['mvp'] },
+      { id: 'b', status: 'next', tags: ['mvp'] },
+    ]);
+    assert.equal(r.code, 0, 'the status line must never fail the session');
+    assert.match(r.line, /mvp 0\/0 ⚠2 schema/,
+      'a roadmap with no priority field at all must be marked, with its count: ' + r.line);
+  });
+
+  test('P8 — PARTIAL population is caught: one valid priority beside a broken sibling', () => {
+    // Cross-family QE named this false negative exactly: the first detector only inspected features
+    // that already HAD a string priority, so a valid entry standing next to a missing or non-string
+    // one passed silently — and a half-migrated roadmap is the most likely real one.
+    const r = roadmapLine([
+      { id: 'a', status: 'done', priority: 'mvp' },
+      { id: 'b', status: 'next' },                     // missing entirely
+      { id: 'c', status: 'next', priority: 3 },        // present, not a string
+    ]);
+    assert.equal(r.code, 0);
+    assert.match(r.line, /⚠2 schema/,
+      'both broken siblings must be counted, not hidden by the valid one: ' + r.line);
+    assert.match(r.line, /mvp 1\/1/,
+      'and what IS known must still be reported: ' + r.line);
+  });
+
+  test('P6 — a valid roadmap renders exactly as before, with no marker', () => {
+    // The guard on over-marking: a rule that fires on good input is worse than no rule.
+    const r = roadmapLine([
+      { id: 'a', status: 'done', priority: 'mvp' },
+      { id: 'b', status: 'next', priority: 'mvp' },
+      { id: 'c', status: 'next', priority: 'low' },
+    ]);
+    assert.equal(r.code, 0);
+    assert.match(r.line, /mvp 1\/2/, 'the real counts must still render: ' + r.line);
+    assert.doesNotMatch(r.line, /schema/, 'and no marker on a conforming file: ' + r.line);
+
+    // An EMPTY roadmap has nothing to be off-schema about; marking it would be a false alarm in the
+    // most common state of a fresh project.
+    const empty = roadmapLine([]);
+    assert.equal(empty.code, 0);
+    assert.doesNotMatch(empty.line, /schema/, 'an empty roadmap must not be marked: ' + empty.line);
+  });
+
+  test('P7 — every case exits 0: the marker informs, it never blocks', () => {
+    for (const features of [
+      [{ id: 'a', status: 'next', priority: 'critical' }],
+      [{ id: 'a', status: 'next', tags: ['mvp'] }],
+      [{ id: 'a', status: 'next', priority: 'mvp' }],
+      [],
+    ]) {
+      const r = roadmapLine(features);
+      assert.equal(r.code, 0,
+        'the status line is advisory and must stay non-blocking: ' + JSON.stringify(features));
+      // Cross-family QE: exit 0 alone is satisfied by a program that prints nothing at all. The
+      // line must actually be rendered in every case.
+      assert.notEqual(r.line, '',
+        'and must still RENDER a roadmap line: ' + JSON.stringify(features));
+    }
+  });
+});

package/tests/unit/sparc-reconciliation.test.js

@@ -0,0 +1,117 @@
+'use strict';
+
+// sparc-prd-mini — Phase 5 must reconcile with Phase 4's data model before its checkpoint.
+//
+// The skill runs strictly linearly: Phase 4 PSEUDOCODE authors `## Data Structures` — entity types
+// with concrete field types — and only then does Phase 5 ARCHITECTURE choose the storage and
+// technology those structures have to live in. A sweep from Phase 5 to end-of-file found ZERO
+// re-reads of Pseudocode.md, so nothing ever noticed the two documents disagreeing. One ordering
+// fact explained three separately-reported field symptoms: a boolean where the schema took an enum,
+// an algorithm using a column the schema lacks, and a status with three values on one side and five
+// on the other.
+//
+// The fix is a RECONCILIATION step, deliberately NOT a reorder: SPARC is an acronym — Specification,
+// Pseudocode, Architecture, Refinement, Completion — and the skill is named `sparc-prd-mini`.
+// Swapping P and A would leave the file claiming a methodology it no longer follows. P5 below guards
+// that refused decision, so a later edit cannot quietly take it.
+//
+// These are PROMPT modules executed by a model, so the strongest deterministic layer available is
+// the file's own content. Each assertion is DISCRIMINATING: removing what it names turns it red.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SKILL = path.join(
+  __dirname, '..', '..', 'templates', '.claude', 'skills', 'sparc-prd-mini', 'SKILL.md',
+);
+
+function read() {
+  return fs.readFileSync(SKILL, 'utf-8');
+}
+
+/** The text between the Phase 5 heading and the Phase 6 heading — placement is the property. */
+function phase5(src) {
+  const start = src.indexOf('### Phase 5: ARCHITECTURE');
+  const end = src.indexOf('### Phase 6: REFINEMENT');
+  assert.ok(start > 0, 'Phase 5 heading must exist');
+  assert.ok(end > start, 'Phase 6 heading must follow Phase 5');
+  return src.slice(start, end);
+}
+
+describe('sparc-prd-mini — Phase 5 reconciles with Pseudocode (PR-005/PR-010)', () => {
+  test('P1 — the reconciliation step lives INSIDE Phase 5, before its checkpoint', () => {
+    const block = phase5(read());
+    assert.match(block, /СВЕРКА С ПСЕВДОКОДОМ/,
+      'the step must be inside Phase 5 — somewhere in the file is not the same property');
+    const step = block.indexOf('СВЕРКА С ПСЕВДОКОДОМ');
+    const checkpoint = block.indexOf('CHECKPOINT 5');
+    assert.ok(checkpoint > 0, 'Phase 5 must still carry its checkpoint');
+    assert.ok(step < checkpoint,
+      'reconciling AFTER the user has already approved the phase reconciles nothing');
+  });
+
+  test('P1b — the step is OUTSIDE the [MANUAL] CP5 block, so AUTO mode cannot skip it', () => {
+    // Cross-family QE (Codex gpt-5.6-sol) caught this: the first placement landed the step INSIDE
+    // the fenced `**[MANUAL] CP5:**` block, which AUTO mode is entitled to skip — a mandatory
+    // reconciliation that only happens in one of two run modes is not mandatory. P1's before/after
+    // ordering was true and still missed it, because "before the checkpoint text" and "outside the
+    // MANUAL-only block" are two different facts.
+    const block = phase5(read());
+    const step = block.indexOf('СВЕРКА С ПСЕВДОКОДОМ');
+    const manual = block.indexOf('**[MANUAL] CP5:**');
+    assert.ok(manual > 0, 'the MANUAL checkpoint marker must still exist');
+    assert.ok(step < manual,
+      'the step must precede the [MANUAL] marker — inside it, an AUTO run reconciles nothing');
+  });
+
+  test('P2 — it names BOTH artifacts to re-read, not "check for consistency"', () => {
+    const block = phase5(read());
+    assert.match(block, /Pseudocode\.md/, 'the step must name the file it re-reads');
+    assert.match(block, /## Data Structures/, 'and the data-model section within it');
+    // Codex: "an algorithm uses a missing column" cannot be detected from the type list alone.
+    assert.match(block, /## Core Algorithms/,
+      'the missing-column kind is undetectable without the algorithms — naming only the data '
+      + 'structures would promise a check the step cannot perform');
+  });
+
+  test('P3 — all three measured discrepancy kinds are named verbatim', () => {
+    const block = phase5(read());
+    // Each of these is a real symptom that reached code before this step existed. A generic
+    // "look for inconsistencies" would satisfy a reviewer and catch none of them.
+    // Checked in BOLD form, i.e. where the kinds are DEFINED. A first draft matched the bare
+    // phrase and did not discriminate: the same words also appear inside the example table row, so
+    // deleting a kind from the definition list left the assertion green. A phrase appearing in an
+    // example is not the same fact as a phrase defining a kind — the fifth instance of that trap
+    // in one day, so it is closed by construction here.
+    for (const kind of ['смена типа', 'отсутствующая колонка', 'несовпадение набора значений']) {
+      assert.ok(block.includes(`**${kind}**`),
+        `discrepancy kind must be DEFINED (bold) in the step, not merely mentioned: ${kind}`);
+    }
+  });
+
+  test('P4 — a written outcome is required in EVERY case, including no-change', () => {
+    const block = phase5(read());
+    assert.match(block, /## Reconciliation with Pseudocode/,
+      'the step must name the block it writes into Architecture.md');
+    assert.match(block, /Расхождений с/,
+      'the no-change case needs its own stated sentence — silence cannot distinguish '
+      + '"reconciled and clean" from "never reconciled"');
+  });
+
+  test('P5 — SPARC order is unchanged: the refused decision stays refused', () => {
+    const src = read();
+    const order = ['### Phase 3: SPECIFICATION', '### Phase 4: PSEUDOCODE',
+      '### Phase 5: ARCHITECTURE', '### Phase 6: REFINEMENT', '### Phase 7: COMPLETION'];
+    const at = order.map((h) => {
+      const i = src.indexOf(h);
+      assert.ok(i > 0, `heading must exist: ${h}`);
+      return i;
+    });
+    for (let i = 1; i < at.length; i += 1) {
+      assert.ok(at[i] > at[i - 1],
+        `phases must stay in S-P-A-R-C order — the acronym IS the method's name; ${order[i]} moved`);
+    }
+  });
+});

package/tests/unit/spec-pseudocode-traceability.test.js

@@ -0,0 +1,146 @@
+'use strict';
+
+// A scenario could promise a check that no algorithm performs, and nothing in the pipeline could
+// notice. MEASURED: Specification.md's user-story template produced Gherkin acceptance criteria with
+// no identifier of any kind, Pseudocode.md's algorithm template was "### Algorithm: [Name]" with no
+// back-reference, and a sweep of the skill for traceab|SC-\d|scenario id returned nothing. The two
+// documents are written one phase apart and were never compared again.
+//
+// WHAT THIS FEATURE CLAIMS, exactly. It establishes that a CLAIM exists and that its two ends name
+// each other. It does not establish that the algorithm performs the check — no comparison of names
+// can. The nearest precedent says the same of itself: the K2 gate's own source records that its C1
+// check is a grep and that PROSE satisfies it. So this catches "nobody wrote anything about this
+// scenario"; it does not catch "someone wrote a line that mentions it", and closing a gap with
+// paperwork is precisely the failure the field report is about. P6 asserts the limit is written into
+// the template, so the next reader sees the same caveat the author did.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SKILL = path.join(__dirname, '..', '..', 'templates', '.claude', 'skills',
+  'sparc-prd-mini', 'SKILL.md');
+const read = () => fs.readFileSync(SKILL, 'utf-8');
+
+function phase(src, heading, nextHeading) {
+  const start = src.indexOf(heading);
+  const end = src.indexOf(nextHeading, start + 1);
+  assert.ok(start > 0, 'missing section: ' + heading);
+  assert.ok(end > start, 'missing terminator: ' + nextHeading);
+  return src.slice(start, end);
+}
+
+const phase3 = (src) => phase(src, '### Phase 3: SPECIFICATION', '### Phase 4: PSEUDOCODE');
+const phase4 = (src) => phase(src, '### Phase 4: PSEUDOCODE', '### Phase 5: ARCHITECTURE');
+
+describe('a scenario and the algorithm that claims it can be traced to each other (PR-003)', () => {
+  test('P1 — Phase 3 gives every acceptance scenario an ID of a stated form', () => {
+    const block = phase3(read());
+    assert.match(block, /\[SC-<story-id>-1\]/,
+      'the ID must appear IN the template, so its form is unambiguous rather than described');
+    assert.match(block, /`SC-<US-id>-<n>`/, 'and the form must be stated');
+    // Cross-family QE: <story-id> had no definition and no uniqueness rule, so two scenarios could
+    // end up with the same name and a trace would point at either.
+    assert.match(block, /`US-<nnn>` — three digits, assigned in order, never reused/,
+      'the story id must be DEFINED, with a uniqueness rule, or the scenario id is not well-formed');
+    assert.match(block, /the scenarios of `US-007` are `SC-US-007-1`/,
+      'and shown worked once, so the composition is unambiguous');
+    assert.match(block, /nothing to trace to if a scenario has no\s+name/,
+      'and WHY, or a later editor drops the ID as noise');
+  });
+
+  test('P2 — Phase 4 algorithms declare what they realise, where they are written', () => {
+    const block = phase4(read());
+    // Structural, not textual: between the algorithm heading and its INPUT line. Cross-family QE
+    // noted the first version only proved the string occurs somewhere in the phase.
+    const at = block.indexOf('### Algorithm: [Name]');
+    assert.ok(at > 0, 'the algorithm template must exist');
+    const algo = block.slice(at, block.indexOf('COMPLEXITY', at));
+    assert.match(algo, /REALISES: \[SC-… ids this algorithm implements/,
+      'the declaration must sit in the algorithm block itself, not in a table someone must remember');
+    assert.ok(algo.indexOf('REALISES') < algo.indexOf('INPUT:'),
+      'and beside INPUT/OUTPUT where the algorithm is written, not appended after it');
+  });
+
+  test('P3 — the reconciliation is INSIDE Phase 4 and OUTSIDE the [MANUAL] CP4 block', () => {
+    // Placement is the property, twice over. A step after Phase 4 reconciles nothing in time; a step
+    // inside the fenced [MANUAL] block is skipped by an AUTO run, so a "mandatory" step would run in
+    // half of runs. The sibling Phase-5 feature shipped that exact defect and had it caught in
+    // review — "precedes the checkpoint text" and "outside the MANUAL-only block" are two different
+    // facts, and only the second one is the property.
+    const src = read();
+    const block = phase4(src);
+    const step = block.indexOf('**Шаг 4.9 — ПОКРЫТИЕ СЦЕНАРИЕВ');
+    const manual = block.indexOf('**[MANUAL] CP4:**');
+    assert.ok(step > 0, 'the coverage step must live inside Phase 4');
+    assert.ok(manual > step,
+      'and BEFORE the manual checkpoint block, not after it: ' + step + ' vs ' + manual);
+    // NOTE: an earlier version added a "not inside the fenced block" assertion here. It was VACUOUS
+    // — the fence is located FROM `manual`, so after `manual > step` the step cannot be inside it.
+    // Cross-family QE caught it. The assertion above is the real guard, and the mutation that moves
+    // the step into the fenced block turns it red, which is the evidence that matters.
+  });
+
+  test('P4 — a Scenario Coverage block is required in EVERY case, including all-covered', () => {
+    const block = phase4(read());
+    assert.match(block, /## Scenario Coverage/,
+      'the required output block must be named, or "reconcile" is advice');
+    assert.match(block, /in every\s+case, including the one where everything is covered/,
+      'an absent block and a block saying "all covered" are indistinguishable to the next reader');
+    assert.match(block, /Not claimed by any algorithm:/,
+      'and the uncovered scenarios must be listed, not summarised as a count');
+    // Cross-family QE: the check ran ONE WAY. An algorithm could declare REALISES for a scenario
+    // nobody ever wrote, and the dangling reference reads exactly like coverage.
+    assert.match(block, /Claimed by an algorithm but absent from Specification\.md:/,
+      'traceability must run both ways, or a dangling REALISES passes as coverage');
+    assert.match(block, /Both tables are required, and both may be the single word `none`/,
+      'and the empty case must be written out — an empty table and a forgotten one look identical');
+  });
+
+  test('P5 — the reason vocabulary is CLOSED, and the two escape hatches are rejected by name', () => {
+    const block = phase4(read());
+    const expected = ['ui-only', 'external-service', 'out-of-mvp-scope', 'data-only', 'config-only'];
+    for (const reason of expected) {
+      assert.ok(block.includes('`' + reason + '`'),
+        'the closed list must carry the reason: ' + reason);
+    }
+    assert.match(block, /CLOSED list of five/, 'and declare itself closed, with its size');
+    // CLOSED means closed: the first version asserted the values exist and let a sixth in silently.
+    // The count is the property, and it must agree with the stated size.
+    const at = block.indexOf('CLOSED list of five');
+    const table = block.slice(at, block.indexOf('Free text is NOT a reason', at));
+    const rows = table.split('\n').filter((l) => /^\| `[a-z-]+` \|/.test(l));
+    assert.equal(rows.length, expected.length,
+      'the reason table must have exactly the stated number of rows: ' + JSON.stringify(rows));
+    // Without these two named, "free text" creeps back as the default and the list means nothing.
+    assert.match(block, /Free text is NOT a reason, and `N\/A` is NOT a reason/,
+      'the two ways this field gets emptied must be rejected by name');
+    assert.match(block, /A field that accepts anything records nothing/,
+      'with the reason, so the rejection survives an editor who finds it unfriendly');
+  });
+
+  test('P6 — the template states its own limit', () => {
+    // The load-bearing honesty. A traceability block LOOKS like proof of implementation, and the
+    // field report's actual complaint is gaps closed with paperwork — which this cannot detect.
+    const block = phase4(read());
+    assert.match(block, /It does NOT establish that the algorithm's steps actually perform the check/,
+      'the limit must be written into the artifact, not only into the feature\'s own report');
+    assert.match(block, /nobody wrote anything about this\s+scenario/,
+      'and the class it DOES catch must be named, so the claim is bounded on both sides');
+  });
+
+  test('P7 — the phase order is still S→P→A→R→C', () => {
+    // Regression guard on the file this edits: the skill is named sparc-prd-mini and its phases are
+    // the acronym. A reorder would leave it claiming a methodology it no longer follows.
+    const src = read();
+    const order = ['### Phase 3: SPECIFICATION', '### Phase 4: PSEUDOCODE',
+      '### Phase 5: ARCHITECTURE', '### Phase 6: REFINEMENT', '### Phase 7: COMPLETION'];
+    let prev = -1;
+    for (const h of order) {
+      const at = src.indexOf(h);
+      assert.ok(at > prev, 'phases must appear in SPARC order; out of place: ' + h);
+      prev = at;
+    }
+  });
+});

package/tests/unit/statusline-honest-labels.test.js

@@ -0,0 +1,178 @@
+'use strict';
+
+// Two ways the status line said something untrue, both reproduced before the fix.
+//
+// 1. The progress bar was built from done/total and captioned `mvp`, with `Done x/y` rendered
+//    separately beside it — one glyph, two different quantities, read as one statement.
+//
+// 2. The domain regexes had no word boundaries, so ordinary sentences picked a domain:
+//      "Run healthchecks before deploy"  → healthcare   (`health` inside `healthchecks`)
+//      "We translate the UI"             → enterprise   (`sla` inside `tranSLAte`)
+//      "A slack bot for standups"        → enterprise   (`sla` inside `SLAck`)
+//      "Embankment mapping service"      → banking      (`bank` inside `emBANKment`)
+//    All four expressions were affected.
+//
+// THE TRAP, and it is why P3/P4 exist: `\b` is not the fix. It is defined over \w = [A-Za-z0-9_], so
+// there is no word boundary between a space and a Cyrillic letter — MEASURED, /\bбанк/.test('банк
+// России') is FALSE. A reflex `\b` fix would have silently deleted every Russian term while looking
+// correct in review. The boundaries are Unicode lookarounds with the `u` flag.
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const TPL = path.join(__dirname, '..', '..', 'templates', '.claude');
+const HOOK = path.join(TPL, 'hooks', 'statusline.cjs');
+const STRIP = new RegExp('\\x1b\\[[0-9;]*m', 'g');
+
+/** Run the REAL hook over a project whose CLAUDE.md says `text`, return its plain output. */
+function render(opts) {
+  const o = opts || {};
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'p-rep-labels-')));
+  try {
+    fs.mkdirSync(path.join(root, '.claude', 'hooks'), { recursive: true });
+    fs.copyFileSync(HOOK, path.join(root, '.claude', 'hooks', 'statusline.cjs'));
+    if (o.claudeMd !== undefined) fs.writeFileSync(path.join(root, 'CLAUDE.md'), o.claudeMd);
+    // The Domain segment lives INSIDE the Roadmap line, so a domain fixture needs a roadmap too —
+    // without one the hook takes its "no roadmap yet" branch and never renders a domain at all.
+    if (o.features === undefined && o.claudeMd !== undefined) {
+      o.features = [{ id: 'a', status: 'next', priority: 'mvp' }];
+    }
+    if (o.features) {
+      fs.writeFileSync(path.join(root, '.claude', 'feature-roadmap.json'),
+        JSON.stringify({ version: '1.0', features: o.features }));
+    }
+    const r = spawnSync(process.execPath, [path.join(root, '.claude', 'hooks', 'statusline.cjs')],
+      { cwd: root, env: Object.assign({}, process.env, { CLAUDE_PROJECT_DIR: root }),
+        encoding: 'utf8' });
+    return { code: r.status, text: (r.stdout || '').replace(STRIP, '') };
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+}
+
+const domainOf = (text) => {
+  const m = text.match(/Domain:\s*(\S+)/);
+  return m ? m[1] : null;
+};
+
+/** The source of parseDomain, for the assertions that must look at the expressions themselves. */
+function parseDomainSource() {
+  const src = fs.readFileSync(HOOK, 'utf-8');
+  const start = src.indexOf('function parseDomain');
+  const end = src.indexOf('\nfunction ', start + 1);
+  assert.ok(start > 0 && end > start, 'parseDomain must exist');
+  return src.slice(start, end);
+}
+
+describe('the status line says what it means (PR-011, two small fixes)', () => {
+  test('P1 — ordinary sentences no longer pick a domain', () => {
+    // Each case is the EXACT sentence that produced the false positive, so a future edit that
+    // half-fixes one term is visible rather than averaged away.
+    const cases = [
+      ['Run healthchecks before deploy', 'health inside healthchecks'],
+      ['We translate the UI into three languages', 'sla inside translate'],
+      ['A slack bot for standups', 'sla inside slack'],
+      ['Embankment mapping service', 'bank inside embankment'],
+      ['Translation memory service', 'sla again'],
+      // Cross-family QE counter-examples: a left-only boundary was not enough for the Russian stems.
+      ['Сервис организации банкетов под ключ', 'банк inside банкетов'],
+      ['Финты в футболе: разбор техники', 'финт inside финты'],
+      ['ЦБС городской библиотеки', 'цб inside ЦБС — a two-letter acronym cannot be made safe'],
+      ['Video conversion service', 'bare conversion is not commerce'],
+    ];
+    for (const [text, why] of cases) {
+      const r = render({ claudeMd: '# Project\n\n' + text + '\n' });
+      assert.equal(r.code, 0, 'the status line must never fail the session');
+      assert.equal(domainOf(r.text), null,
+        'still matched (' + why + '): ' + JSON.stringify(text) + ' → ' + domainOf(r.text));
+    }
+  });
+
+  test('P2 — real domains are still detected, Cyrillic stems included', () => {
+    // The half a reflex `\b` fix would have deleted. Every Cyrillic entry here is a STEM meant to
+    // match its inflections, so it must keep matching them.
+    const cases = [
+      ['Мобильный банк для МСБ', 'banking'],
+      ['Финтех-стартап', 'banking'],
+      ['A healthcare records system', 'healthcare'],
+      ['Клиника на 40 врачей', 'healthcare'],
+      ['Retail analytics platform', 'retail'],
+      ['Рекомендательная система товаров', 'retail'],
+      ['Enterprise SLA dashboard', 'enterprise'],
+      // Cross-family QE: these were MISSED by the first version — a fix that loses true positives
+      // trades one wrong answer for another.
+      ['Retailer inventory analytics', 'retail'],
+      ['Health tech startup', 'healthcare'],
+      ['Platform for enterprises', 'enterprise'],
+      ['Улучшаем конверсию воронки', 'retail'],
+      ['Банковское приложение', 'banking'],
+    ];
+    for (const [text, expected] of cases) {
+      const r = render({ claudeMd: '# Project\n\n' + text + '\n' });
+      assert.equal(domainOf(r.text), expected,
+        JSON.stringify(text) + ' should be ' + expected + ', got ' + domainOf(r.text));
+    }
+  });
+
+  test('P3 — no domain expression uses \\b', () => {
+    // Asserted on the source because `\b` fails SILENTLY around Cyrillic: it does not error, it just
+    // stops matching, and every Russian term would vanish while the code looked right.
+    // Comments stripped first: the comment above these expressions EXPLAINS why \b is wrong and
+    // therefore contains it. A mention is not a use — the same trap this suite has hit before.
+    const code = parseDomainSource().split('\n').filter((l) => !/^\s*\/\//.test(l)).join('\n');
+    assert.ok(!/\\b/.test(code),
+      '\\b is not a word boundary around Cyrillic in JavaScript — /\\bбанк/.test("банк России") is '
+      + 'false. Use a Unicode lookaround.');
+  });
+
+  test('P4 — the boundaries are Unicode lookarounds with the u flag', () => {
+    const src = parseDomainSource();
+    assert.match(src, /\(\?<!\[\\\\p\{L\}\\\\p\{N\}\]\)/,
+      'a left boundary over Unicode letters is required');
+    assert.match(src, /\(\?!\[\\\\p\{L\}\\\\p\{N\}\]\)/,
+      'and a right boundary for whole words');
+    assert.match(src, /'iu'/, "and the `u` flag, or \\p{L} is not a property escape at all");
+    // The stem/word distinction is the reason the Cyrillic half survives; losing it would take the
+    // inflections with it.
+    assert.match(src, /const stem = /, 'stems take a left boundary only');
+    assert.match(src, /const word = /, 'whole words take both');
+    // Cross-family QE: the helpers being DECLARED proves nothing — dead declarations plus one 'iu'
+    // token satisfied the assertions above while an unbounded /conversion/i survived beside them.
+    // Every domain expression must be BUILT by one of the two helpers.
+    const built = [...src.matchAll(/const (\w+) = (stem|word)\(/g)].map((m) => m[1]);
+    assert.ok(built.length >= 6,
+      'each domain must be built by stem() or word(): found ' + JSON.stringify(built));
+    const raw = [...src.matchAll(/const (\w+(?:Stem|Word)) = \//g)].map((m) => m[1]);
+    assert.deepEqual(raw, [],
+      'these are raw regex literals, bypassing the boundary helpers: ' + JSON.stringify(raw));
+  });
+
+  test('P5 — the bar is captioned with what it draws', () => {
+    const r = render({ features: [
+      { id: 'a', status: 'done', priority: 'mvp' },
+      { id: 'b', status: 'next', priority: 'mvp' },
+      { id: 'c', status: 'next', priority: 'low' },
+    ] });
+    const line = r.text.split('\n').find((l) => l.includes('Roadmap')) || '';
+    assert.match(line, /\[[●○]+\]\s+Done\s+1\/3/,
+      'the bar is built from done/total, so Done is its caption: ' + line);
+    assert.match(line, /mvp\s+1\/2/, 'and mvp keeps its own segment: ' + line);
+    assert.ok(!/\[[●○]+\]\s+mvp/.test(line),
+      'the bar must not be captioned with a quantity it does not draw: ' + line);
+  });
+
+  test('P6 — with no MVP features the bar is still rendered', () => {
+    // The field report proposed hiding the bar when mvpTotal === 0. The bar is CORRECT; hiding a
+    // working indicator to mask a wrong caption fixes the wrong half.
+    const r = render({ features: [
+      { id: 'a', status: 'done', priority: 'low' },
+      { id: 'b', status: 'next', priority: 'low' },
+    ] });
+    const line = r.text.split('\n').find((l) => l.includes('Roadmap')) || '';
+    assert.match(line, /\[[●○]+\]/, 'the bar must survive an mvp count of zero: ' + line);
+    assert.match(line, /Done\s+1\/2/, 'and still report the real progress: ' + line);
+    assert.match(line, /mvp\s+0\/0/, 'while the mvp segment says plainly that there are none');
+  });
+});