@sabaiway/agent-workflow-memory 2.3.0 → 3.0.1

package/references/scripts/migrate-gates.test.mjs

@@ -0,0 +1,284 @@
+// migrate-gates.test.mjs — spec for the consented legacy gates.json migration (strip-the-kit D8).
+// The migration is ATOMIC and COMPLETE: canonical legacy entries removed + the unit-tests cmd
+// extended with the lcov reporters + the coverage-check gate added LAST; customized entries are
+// NEVER auto-touched (loud report + recovery); preview writes NOTHING; apply is tmp+rename.
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  LEGACY_FORMS,
+  UNIT_TESTS_COVERAGE_FLAGS,
+  RETIRED_STORE_BASENAMES,
+  findRetiredStores,
+  buildMigrationPlan,
+  resultingGates,
+  formatPreview,
+  main,
+} from './migrate-gates.mjs';
+
+const KIT_TOOLS = mkdtempSync(join(tmpdir(), 'migrate-gates-kit-'));
+writeFileSync(join(KIT_TOOLS, 'coverage-check.mjs'), '// the installed checker the migration points at\n');
+
+const mkProject = (gates) => {
+  const root = mkdtempSync(join(tmpdir(), 'migrate-gates-'));
+  mkdirSync(join(root, 'docs', 'ai'), { recursive: true });
+  writeFileSync(join(root, 'docs', 'ai', 'gates.json'), `${JSON.stringify({ _README: 'mine', gates }, null, 2)}\n`);
+  return root;
+};
+const gatesOf = (root) => JSON.parse(readFileSync(join(root, 'docs', 'ai', 'gates.json'), 'utf8')).gates;
+const quiet = () => {
+  const out = [];
+  const err = [];
+  return { log: (l) => out.push(String(l)), error: (l) => err.push(String(l)), out, err };
+};
+
+const LEGACY_LEDGER = { id: 'review-ledger', title: 'L', cmd: 'node "/kit/tools/review-ledger.mjs" --check' };
+const LEGACY_FOLD = { id: 'fold-completeness', title: 'F', cmd: 'node /kit/tools/fold-completeness.mjs --check' };
+const UNIT = { id: 'unit-tests', title: 'U', cmd: 'node --test tools/*.test.mjs' };
+const CUSTOM = { id: 'my-ledger-wrap', title: 'C', cmd: 'node scripts/wrap.mjs && node /kit/tools/review-ledger.mjs --check' };
+
+describe('migrate-gates — the pure migration plan', () => {
+  it('matches BOTH documented legacy forms (quoted and bare paths) and removes them', () => {
+    for (const form of LEGACY_FORMS) assert.ok(form.re instanceof RegExp);
+    const { plan } = buildMigrationPlan([LEGACY_LEDGER, LEGACY_FOLD], KIT_TOOLS);
+    assert.deepEqual(plan.filter((r) => r.action === 'remove').map((r) => r.entry.id), ['review-ledger', 'fold-completeness']);
+  });
+
+  it('extends the canonical unit-tests cmd with the lcov reporters (flags inserted after `node --test`)', () => {
+    const { plan, unitTestsExtended } = buildMigrationPlan([UNIT], KIT_TOOLS);
+    assert.ok(unitTestsExtended);
+    const extended = plan.find((r) => r.action === 'extend').entry;
+    assert.equal(extended.cmd, `node --test ${UNIT_TESTS_COVERAGE_FLAGS} tools/*.test.mjs`);
+  });
+
+  it('an already-extended unit-tests cmd is left alone (idempotent)', () => {
+    const done = { id: 'unit-tests', title: 'U', cmd: `node --test ${UNIT_TESTS_COVERAGE_FLAGS} tools/*.test.mjs` };
+    const { plan } = buildMigrationPlan([done], KIT_TOOLS);
+    assert.equal(plan.find((r) => r.entry.id === 'unit-tests').action, 'keep');
+  });
+
+  it('adds the coverage-check gate LAST with the RESOLVED quoted path; never a second one', () => {
+    const { plan } = buildMigrationPlan([UNIT], KIT_TOOLS);
+    const result = resultingGates(plan);
+    const last = result[result.length - 1];
+    assert.equal(last.id, 'coverage-check');
+    assert.equal(last.cmd, `node "${join(KIT_TOOLS, 'coverage-check.mjs')}" --check`);
+    const again = buildMigrationPlan(result, KIT_TOOLS);
+    assert.ok(!again.plan.some((r) => r.action === 'add'), 'a declaration already carrying the checker gains no duplicate');
+  });
+
+  it('a CUSTOMIZED dead-tool reference (compound form) is kept untouched and reported', () => {
+    const analysis = buildMigrationPlan([CUSTOM], KIT_TOOLS);
+    assert.equal(analysis.plan.find((r) => r.entry.id === 'my-ledger-wrap').action, 'keep');
+    assert.deepEqual(analysis.customized.map((g) => g.id), ['my-ledger-wrap']);
+    const preview = formatPreview(analysis, 'APPLY');
+    assert.match(preview, /CUSTOMIZED \(untouched\): my-ledger-wrap/);
+    assert.match(preview, /do NOT install the commit guard/);
+  });
+});
+
+describe('migrate-gates — the canonical anchor + final-capability validation (round-1 folds)', () => {
+  it('a canonical checker NOT in the last position is MOVED last (never left mid-list)', () => {
+    const canonical = { id: 'coverage-check', title: 'CC', cmd: `node "${join(KIT_TOOLS, 'coverage-check.mjs')}" --check` };
+    const { plan } = buildMigrationPlan([canonical, UNIT], KIT_TOOLS);
+    const result = resultingGates(plan);
+    assert.equal(result[result.length - 1].id, 'coverage-check', 'the canonical checker ends up LAST');
+    assert.ok(plan.some((r) => r.action === 'move' && r.entry.id === 'coverage-check'), 'the reorder is an explicit move action');
+    assert.ok(!plan.some((r) => r.action === 'add'), 'no duplicate checker is added');
+  });
+
+  it('a LOOKALIKE checker cmd is CUSTOMIZED (never counted canonical) and the canonical one is still added', () => {
+    const lookalike = { id: 'cov', title: 'C', cmd: 'node scripts/coverage-check.mjs --check' };
+    const analysis = buildMigrationPlan([lookalike, UNIT], KIT_TOOLS);
+    assert.ok(analysis.customized.some((g) => g.id === 'cov'), 'the lookalike is reported customized');
+    const result = resultingGates(analysis.plan);
+    assert.equal(result[result.length - 1].id, 'coverage-check', 'the REAL canonical checker is added last');
+  });
+
+  it('the result is judged final-capable ONLY with a canonical review-state present; missing → a LOUD warning with the candidate line, never "final-run-capable"', () => {
+    const analysis = buildMigrationPlan([UNIT], KIT_TOOLS);
+    assert.equal(analysis.finalCapable, false, 'no review-state → not final-capable');
+    const preview = formatPreview(analysis, 'APPLY');
+    assert.match(preview, /review-state/, 'the warning names the missing core check');
+    assert.match(preview, /"id": "review-state"|review-state\.mjs/, 'the paste-ready candidate is carried');
+    assert.doesNotMatch(preview, /already final-run-capable/);
+    const withRs = buildMigrationPlan(
+      [UNIT, { id: 'review-state', title: 'RS', cmd: `node "${join(KIT_TOOLS, 'review-state.mjs')}" --check` }],
+      KIT_TOOLS,
+    );
+    assert.equal(withRs.finalCapable, true);
+  });
+
+  it('a NON-canonical unit-tests cmd (npm test / wrapper) is CUSTOMIZED with the full flag set as the recovery', () => {
+    const npmTest = { id: 'unit-tests', title: 'U', cmd: 'npm test' };
+    const analysis = buildMigrationPlan([npmTest], KIT_TOOLS);
+    assert.equal(analysis.plan.find((r) => r.entry.id === 'unit-tests').action, 'keep');
+    assert.ok(analysis.customized.some((g) => g.id === 'unit-tests'), 'a non-canonical suite cmd is customized');
+    const preview = formatPreview(analysis, 'APPLY');
+    assert.match(preview, /--experimental-test-coverage/, 'the recovery carries the full flag set');
+  });
+
+  it('a PARTIALLY-flagged unit-tests cmd is CUSTOMIZED (a lone coverage flag never reads as configured)', () => {
+    const partial = { id: 'unit-tests', title: 'U', cmd: 'node --test --experimental-test-coverage tools/*.test.mjs' };
+    const analysis = buildMigrationPlan([partial], KIT_TOOLS);
+    assert.equal(analysis.plan.find((r) => r.entry.id === 'unit-tests').action, 'keep');
+    assert.ok(analysis.customized.some((g) => g.id === 'unit-tests'), 'the half-wired cmd is customized, never silently left');
+  });
+
+  it('a kitTools path with DQ-unsafe characters is a loud STOP before any write', () => {
+    const root = mkProject([UNIT]);
+    const evil = mkdtempSync(join(tmpdir(), 'migrate-gates-$evil-'));
+    writeFileSync(join(evil, 'coverage-check.mjs'), '// lookalike\n');
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', evil, '--apply'], io), 1);
+    assert.match(io.err.join('\n'), /double-quot|shell metacharacter/i);
+    rmSync(evil, { recursive: true, force: true });
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('CUSTOMIZED warnings + the guard warning print even when apply has nothing else to do', () => {
+    const root = mkProject([CUSTOM]);
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io), 0);
+    const text = io.out.join('\n');
+    assert.match(text, /CUSTOMIZED \(untouched\): my-ledger-wrap/, 'the customized row survives the no-op path');
+    assert.match(text, /do NOT install the commit guard/i, 'the guard warning survives the no-op path');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('a SYMLINKED docs (or docs/ai) PARENT is a STOP on preview AND apply (never written through)', () => {
+    const outside = mkdtempSync(join(tmpdir(), 'migrate-gates-target-'));
+    mkdirSync(join(outside, 'ai'), { recursive: true });
+    writeFileSync(join(outside, 'ai', 'gates.json'), `${JSON.stringify({ gates: [UNIT] })}\n`);
+    const root = mkdtempSync(join(tmpdir(), 'migrate-gates-symparent-'));
+    symlinkSync(outside, join(root, 'docs'));
+    for (const argv of [['--cwd', root, '--kit-tools', KIT_TOOLS], ['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply']]) {
+      const io = quiet();
+      assert.equal(main(argv, io), 1, `must STOP: ${argv.join(' ')}`);
+      assert.match(io.err.join('\n'), /symlink/i);
+    }
+    rmSync(root, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+  });
+});
+
+describe('migrate-gates — preview writes NOTHING; apply is atomic and complete', () => {
+  it('the dry-run default leaves gates.json byte-identical and prints the plan + the apply hint', () => {
+    const root = mkProject([LEGACY_LEDGER, UNIT]);
+    const before = readFileSync(join(root, 'docs', 'ai', 'gates.json'), 'utf8');
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS], io), 0);
+    assert.equal(readFileSync(join(root, 'docs', 'ai', 'gates.json'), 'utf8'), before, 'dry-run must write nothing');
+    const text = io.out.join('\n');
+    assert.match(text, /REMOVE review-ledger/);
+    assert.match(text, /EXTEND unit-tests/);
+    assert.match(text, /ADD coverage-check/);
+    assert.match(text, /apply exactly this migration: node "\/[^"]*migrate-gates\.mjs" --kit-tools/, 'the apply hint is a REAL runnable path (never a file: URL)');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('--apply lands the full migration: legacy gone, unit-tests extended, coverage-check LAST', () => {
+    const root = mkProject([UNIT, LEGACY_LEDGER, LEGACY_FOLD]);
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io), 0);
+    const gates = gatesOf(root);
+    assert.deepEqual(gates.map((g) => g.id), ['unit-tests', 'coverage-check']);
+    assert.match(gates[0].cmd, /--experimental-test-coverage/);
+    assert.equal(gates[gates.length - 1].id, 'coverage-check');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('an ALREADY-migrated declaration is a stated no-op on apply', () => {
+    const root = mkProject([UNIT, LEGACY_LEDGER]);
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], quiet()), 0);
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io), 0);
+    assert.match(io.out.join('\n'), /nothing to migrate/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('a MISSING gates.json is a stated no-op; a MALFORMED one is a loud STOP (never written over)', () => {
+    const empty = mkdtempSync(join(tmpdir(), 'migrate-gates-none-'));
+    const io = quiet();
+    assert.equal(main(['--cwd', empty, '--kit-tools', KIT_TOOLS], io), 0);
+    assert.match(io.out.join('\n'), /nothing to migrate/);
+    rmSync(empty, { recursive: true, force: true });
+
+    const root = mkProject([]);
+    writeFileSync(join(root, 'docs', 'ai', 'gates.json'), '{ not json');
+    const io2 = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io2), 1);
+    assert.match(io2.err.join('\n'), /malformed JSON/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('a SYMLINKED gates.json is a STOP on preview AND apply', () => {
+    const root = mkdtempSync(join(tmpdir(), 'migrate-gates-link-'));
+    mkdirSync(join(root, 'docs', 'ai'), { recursive: true });
+    writeFileSync(join(root, 'real.json'), '{"gates":[]}\n');
+    symlinkSync(join(root, 'real.json'), join(root, 'docs', 'ai', 'gates.json'));
+    for (const argv of [['--cwd', root, '--kit-tools', KIT_TOOLS], ['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply']]) {
+      const io = quiet();
+      assert.equal(main(argv, io), 1);
+      assert.match(io.err.join('\n'), /symlink/);
+    }
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('retired git-dir stores: previewed as CLEAN rows (nothing deleted), unlinked on apply, ENOENT a no-op', () => {
+    const root = mkProject([LEGACY_LEDGER]);
+    const g = (...a) => spawnSync('git', a, { cwd: root, encoding: 'utf8' });
+    g('init', '-q');
+    for (const name of RETIRED_STORE_BASENAMES) writeFileSync(join(root, '.git', name), '{"dead":1}\n');
+    assert.equal(findRetiredStores(root).length, RETIRED_STORE_BASENAMES.length, 'all three retired basenames are found');
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS], io), 0);
+    assert.match(io.out.join('\n'), /CLEAN .*agent-workflow-review-ledger\.v5-orphans\.jsonl/, 'the v5-orphans archive is previewed too');
+    assert.equal(findRetiredStores(root).length, RETIRED_STORE_BASENAMES.length, 'the dry-run deleted NOTHING');
+    const io2 = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io2), 0);
+    assert.deepEqual(findRetiredStores(root), [], 'apply unlinked every retired store');
+    assert.match(io2.out.join('\n'), /cleaned .*agent-workflow-fold-completeness\.jsonl/);
+    // A second apply: stores gone, declaration migrated — a stated no-op (ENOENT never errors).
+    const io3 = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io3), 0);
+    assert.match(io3.out.join('\n'), /nothing to migrate/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('stores alone (an already-migrated declaration) still get cleaned on apply', () => {
+    const root = mkProject([UNIT]);
+    const g = (...a) => spawnSync('git', a, { cwd: root, encoding: 'utf8' });
+    g('init', '-q');
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], quiet()), 0); // migrate first
+    writeFileSync(join(root, '.git', RETIRED_STORE_BASENAMES[0]), '{"dead":1}\n');
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io), 0);
+    assert.match(io.out.join('\n'), /cleaned .*agent-workflow-review-ledger\.jsonl/);
+    assert.deepEqual(findRetiredStores(root), []);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('outside a git tree the store cleanup is a silent no-op (no crash, gates.json still migrates)', () => {
+    const root = mkProject([LEGACY_LEDGER, UNIT]);
+    const io = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', KIT_TOOLS, '--apply'], io), 0);
+    assert.deepEqual(gatesOf(root).map((g2) => g2.id), ['unit-tests', 'coverage-check']);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it('--kit-tools is REQUIRED and must contain the checker (no runtime guessing)', () => {
+    const root = mkProject([UNIT]);
+    const io = quiet();
+    assert.equal(main(['--cwd', root], io), 2);
+    assert.match(io.err.join('\n'), /--kit-tools/);
+    const io2 = quiet();
+    assert.equal(main(['--cwd', root, '--kit-tools', root], io2), 1);
+    assert.match(io2.err.join('\n'), /coverage-check\.mjs/);
+    rmSync(root, { recursive: true, force: true });
+  });
+});

package/references/templates/agent_rules.md

@@ -86,7 +86,7 @@ Apply these when authoring a plan, reviewing, folding a finding, or editing code
 - **Per-round emission.** Every review round emits **{round N · finding-origin tally · per-backend verdict}** so the crossover is a computed, visible signal, not a remembered rule.
 - **Recipe fidelity.** Council runs every backend the recipe names, **every round**; silently dropping a ready backend for quota/convenience is a forbidden downgrade — an unavailable backend is a LOUD, stated degrade, never a quiet drop.
 - **ExitPlanMode ≠ execute.** A harness "approved — start coding" prompt authorizes the PLAN only; this methodology overrides it. Continue into execution only as a DELIBERATE transition after the plan + cold-start prompt exist, never an implicit slide.
-- **Cost lanes.** Route every step to the **cheapest adequate executor** — L0 deterministic script (the batched gate matrix over `gates.json`, the rotation `--check`s) · L1 cheap subagent (extraction/drafting only; the orchestrator verifies) · L2 subscription bridge · L3 frontier judgment. A step with **no named guardrail does not move down** a lane, and the **red lines never move down** (council review models · real code · ADR/handover/changelog-entry wording · persuasive copy · go/no-go · the approval asks). Own-error repair: salvage recorded state first (L0/L1, batched), never frontier re-derivation. **Prompt economy:** read-only fan-out (research/sweeps/extraction) runs ONLY on restricted-tool vehicles — a full-tool subagent for read-only work is a forbidden lane downgrade (invisible prompt-flood + blast radius), and a subagent is never told to shell out for facts obtainable read-only; the orchestrator's own shell form is ONE plain pipeline per call (a `;`/`&&` chain or env-prefixed invocation never matches a prefix allow rule); a fan-out launcher that gates per call yields to the agent-spawn lane — capability-gated: without restricted-tool vehicles (generic full-tool spawning does not count), read-only research stays in the orchestrator's own context, never a vehicle mandate a host cannot satisfy. Judgment, code, synthesis stay at the frontier lane (a task that genuinely runs/writes keeps a full-tool subagent); honest limit: no deterministic gate classifies a dispatch — canon at the point of use + placed vehicles + the retro loop. **Writer economy:** a stage's repeated WRITER commands batch into ONE invocation — the review-ledger triad rides one batched write, other stage writers combine via one launcher per stage; never one writer call at a time (each write is its own prompt).
+- **Cost lanes.** Route every step to the **cheapest adequate executor** — L0 deterministic script (the batched gate matrix over `gates.json`, the rotation `--check`s) · L1 cheap subagent (extraction/drafting only; the orchestrator verifies) · L2 subscription bridge · L3 frontier judgment. A step with **no named guardrail does not move down** a lane, and the **red lines never move down** (council review models · real code · ADR/handover/changelog-entry wording · persuasive copy · go/no-go · the approval asks). Own-error repair: salvage recorded state first (L0/L1, batched), never frontier re-derivation. **Prompt economy:** read-only fan-out (research/sweeps/extraction) runs ONLY on restricted-tool vehicles — a full-tool subagent for read-only work is a forbidden lane downgrade (invisible prompt-flood + blast radius), and a subagent is never told to shell out for facts obtainable read-only; the orchestrator's own shell form is ONE plain pipeline per call (a `;`/`&&` chain or env-prefixed invocation never matches a prefix allow rule); a fan-out launcher that gates per call yields to the agent-spawn lane — capability-gated: without restricted-tool vehicles (generic full-tool spawning does not count), read-only research stays in the orchestrator's own context, never a vehicle mandate a host cannot satisfy. Judgment, code, synthesis stay at the frontier lane (a task that genuinely runs/writes keeps a full-tool subagent); honest limit: no deterministic gate classifies a dispatch — canon at the point of use + placed vehicles + the retro loop. **Writer economy:** a stage's repeated WRITER commands batch — evidence declarations ride consecutive plain invocations of ONE allow-listed tool, other stage writers combine via one launcher per stage; never an unbatched writer scatter (each gated write is its own prompt).
 
 ---
 
@@ -103,7 +103,7 @@ Split a complex task across sessions for **focus and review hygiene**, not becau
 ## 4. User Interaction
 
 1. **Don't rush to commit.** Prepare changes, run local quality checks, report progress with test outcomes.
-2. **Get explicit approval** before staging/committing or moving to the next phase.
+2. **Get explicit approval** before COMMITTING or moving to the next phase — staging is reversible loop-work (the final-run ordering stages first, reviews the staged tree, then asks ONCE at the commit; a separate staging ask is a useless approval).
 
 ---
 

package/scripts/stamp-takeover.mjs

@@ -6,14 +6,14 @@
 // The deployment lineage is a SINGLE shared sequence; its current head is LINEAGE_HEAD.
 // Both `.memory-version` and the kit-fallback `.workflow-version` track THAT sequence —
 // never their package versions. So this substrate's package may be 1.0.0 while the stamp
-// it writes is the lineage head (2.0.0 today).
+// it writes is the lineage head (3.0.0 today).
 //
 // `decideTakeover` is a PURE function (stamp state in → action out) so the state machine is
 // unit-testable per row. `applyTakeover` is the thin fs wrapper; stamp writes are ATOMIC
 // (write temp + rename) so an interrupted write can never corrupt the prior stamp.
 //
 // The Markdown twin `migrations/legacy-stamp-takeover.md` documents the same table as the
-// no-Node manual fallback. Dependency-free, Node >= 18.
+// no-Node manual fallback. Dependency-free, Node >= 22.
 
 import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
 import { dirname, basename, join, resolve } from 'node:path';
@@ -22,7 +22,7 @@ import { pathToFileURL } from 'node:url';
 
 // The shared agent-workflow deployment-lineage head. Bumped only when a project-migration
 // changes the deployed docs/ai structure — NOT on a packaging-only release.
-export const LINEAGE_HEAD = '2.0.0';
+export const LINEAGE_HEAD = '3.0.0';
 
 const SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
 

package/references/templates/verification-profile.json

@@ -1,10 +0,0 @@
-{
-  "_README": "Optional per-project VERIFICATION PROFILE for the fold-completeness gate (the language-independence contract). DELETE this file to reproduce the exact default behaviour (V8 line coverage + node:test TAP on stdout) — an absent profile is fully supported. Present, it GENERALIZES three inputs so a consumer on another language/runner can drive the same gate: (1) coverage.kind is \"v8\" (default) or \"lcov\" — with lcov, set coverage.lcovPath to where your suite leaves an LCOV file; (2) singleTest.argv is the shell-free command template for probing ONE test (placeholders {file} and {pattern} are required; a file-based resultFormat also requires {resultPath}), and singleTest.resultFormat is \"tap-stdout\" (default), \"tap-file\", or \"junit-xml\"; (3) findings.sarifPath (optional) points at a SARIF file for advisory-only findings (never gate-blocking). The suite COMMAND is NOT declared here — it stays your docs/ai/gates.json unit-tests gate (so the fold run and the gate share command-identity). Every DECLARED path (coverage.lcovPath, findings.sarifPath) MUST be gitignored or outside the repo (a symlink is refused): an in-tree, non-ignored file the suite writes would move the review fingerprint. Env knobs still override (AW_FOLD_SUITE_CMD / AW_FOLD_BOUND_CMD / AW_FOLD_RESULTS). Strict JSON — no comments.",
-  "schema": 1,
-  "coverage": { "kind": "v8" },
-  "singleTest": {
-    "argv": ["node", "--test", "--test-reporter", "tap", "--test-name-pattern={pattern}", "{file}"],
-    "resultFormat": "tap-stdout"
-  },
-  "findings": {}
-}