@event4u/agent-config 14.12.0 → 14.14.0

package/src/agent-src/templates/scripts/memory_signal.ts

@@ -29,6 +29,7 @@
 
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -217,6 +218,45 @@ export interface SignalRecord {
  * The file path is the single source of truth: there is no external backend
  * to route to, so merge-safety holds in every mode.
  */
+export class ProvenanceRefusedError extends Error {}
+
+// lint-store-boundary: ignore — the provenance gate must RECOGNISE the global root to refuse it
+const _GLOBAL_STORE_MARKER = `.event4u${path.sep}agent-config`;
+
+export function _origin_is_global(origin: string): boolean {
+    if (!origin.includes('/') && !origin.includes(path.sep) && !origin.startsWith('~')) {
+        return false; // symbolic origins ('agent', 'claude', 'cursor', …) are not paths
+    }
+    const expanded = origin.startsWith('~')
+        ? path.join(os.homedir(), origin.slice(1)) // lint-store-boundary: ignore — the gate itself must recognise the global root
+        : origin;
+    let resolved: string;
+    try {
+        resolved = path.resolve(expanded);
+    } catch {
+        return false;
+    }
+    return resolved.includes(_GLOBAL_STORE_MARKER) || /(^|[\\/])\.event4u([\\/]|$)/.test(origin);
+}
+
+export function _assert_project_writable(record: { origin: string; subject?: unknown }): void {
+    if (record.subject === 'user') {
+        throw new ProvenanceRefusedError(
+            'provenance gate: subject: user records live global-only and may ' +
+                'never be written into a tracked project artifact (ADR-130).',
+        );
+    }
+    if (_origin_is_global(record.origin)) {
+        throw new ProvenanceRefusedError(
+            `provenance gate: origin resolves into the user-global store ` +
+                `(${record.origin}) — refused entry into tracked project intake (ADR-130).`,
+        );
+    }
+}
+
+/**
+ * Append a signal entry. Returns the written record, or null when skipped.
+ */
 export function emit(
     entry_type: string,
     p: string,
@@ -255,6 +295,10 @@ export function emit(
             }
         }
     }
+    if (!('subject' in record)) {
+        record.subject = 'project'; // additive default (ADR-130)
+    }
+    _assert_project_writable(record as { origin: string; subject?: unknown });
     fs.mkdirSync(INTAKE_ROOT, { recursive: true });
     const target = _monthly_file();
     fs.appendFileSync(target, `${_jsonDumpsUnicode(record)}\n`, 'utf-8');

package/src/agent-src/templates/scripts/work_engine/directives/backend/implement.ts

@@ -16,6 +16,9 @@
  * Flow:
  *
  * - `plan` outcome is not `success` → BLOCKED on precondition.
+ * - no RED evidence on `state.tests` → BLOCKED with
+ *   `@agent-directive: observe-red` so the agent writes and observes the
+ *   failing test for the next single behaviour BEFORE any production edit.
  * - `state.changes` empty → BLOCKED with `@agent-directive:
  *   apply-plan` so the agent applies the plan.
  * - `state.changes` populated but malformed (entries missing
@@ -26,6 +29,26 @@
  * `docs/contracts/implement-ticket-flow.md#deliverystate-the-only-shared-object`
  * — each entry is a dict with at least a `path`; optional
  * `lines` / `purpose` feed the delivery report.
+ *
+ * RED evidence lives at `state.tests.red` and is the engine-side carrier for
+ * the test-first default in `rules/think-before-action.md`. Two accepted
+ * shapes, and nothing else counts:
+ *
+ * - one observation, or a list of them, each a dict with a non-empty
+ *   `behaviour` and a `failure_class` from `_RED_FAILURE_CLASSES` — the three
+ *   valid RED classes the `test-driven-development` skill admits (a failing
+ *   assertion, a missing target, a contract failure). A broken fixture, a
+ *   syntax error in the test, a missing unrelated dependency and a runner
+ *   fault are NOT RED and are rejected by that same contract, not here.
+ * - `{exempt: "<reason>"}` — the recorded override for work the skill's
+ *   *Do NOT use when* list already excludes (scaffolding, generated files,
+ *   documentation). Recorded, never silent: an absent key is not an exemption.
+ *
+ * The gate is per behaviour, not per run: it names the behaviour it is waiting
+ * on and re-fires for the next one. It does NOT detect a batch — an agent that
+ * front-loads every test for the feature satisfies it, and the eval that fails
+ * a one-test-phase-then-one-code-phase plan is the control for that, not this
+ * step.
  */
 
 import type { DeliveryState} from '../../delivery_state.js';
@@ -39,6 +62,13 @@ export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [
         trigger: '`plan` outcome is not `success`',
         resolution: 're-run `/implement-ticket` from the start',
     },
+    {
+        code: 'no_red_evidence',
+        trigger: '`state.tests.red` carries neither an observed failing test for a ' +
+            'behaviour nor a recorded exemption',
+        resolution: 'agent directive `observe-red` → write the failing test for the ' +
+            'next single behaviour, observe it fail, record it',
+    },
     {
         code: 'empty_changes_delegate',
         trigger: '`state.changes` empty — plan not applied yet',
@@ -68,6 +98,13 @@ export function run(state: DeliveryState): StepResult {
         return _blocked_on_precondition(state);
     }
 
+    // Test-first, enforced where the engine can see it: no production work is
+    // emitted for a behaviour whose failing test has not been observed.
+    const redIssue = _diagnose_red(state.tests);
+    if (redIssue !== null) {
+        return _blocked_on_missing_red(state, redIssue);
+    }
+
     if (!_pyTruthy(state.changes)) {
         return _delegate_to_apply_plan(state);
     }
@@ -98,6 +135,59 @@ function _diagnose_changes(changes: Any[]): string[] {
     return issues;
 }
 
+/** The three RED classes the `test-driven-development` mode contract admits. */
+const _RED_FAILURE_CLASSES = ['assertion', 'missing_target', 'contract'] as const;
+
+/**
+ * `null` when `state.tests` carries usable RED evidence, else the complaint.
+ *
+ * Absent is a complaint, not an exemption — the whole point of the gate.
+ */
+function _diagnose_red(tests: Any): string | null {
+    if (!_isPlainObject(tests)) {
+        return 'no `state.tests.red` recorded';
+    }
+    const red = (tests as Record<string, unknown>).red;
+    if (!_pyTruthy(red)) {
+        return 'no `state.tests.red` recorded';
+    }
+    if (_isPlainObject(red) && _pyTruthy((red as Record<string, unknown>).exempt)) {
+        return null;
+    }
+    const observations = Array.isArray(red) ? red : [red];
+    for (const obs of observations) {
+        if (!_isPlainObject(obs)) {
+            return 'a `red` observation is not a dict';
+        }
+        const o = obs as Record<string, unknown>;
+        if (typeof o.behaviour !== 'string' || _pyStrip(o.behaviour).length === 0) {
+            return 'a `red` observation names no `behaviour`';
+        }
+        if (!_RED_FAILURE_CLASSES.includes(o.failure_class as (typeof _RED_FAILURE_CLASSES)[number])) {
+            return (
+                `\`red\` observation for \`${_pyStrip(o.behaviour)}\` has ` +
+                `\`failure_class\` outside ${_RED_FAILURE_CLASSES.join(', ')}`
+            );
+        }
+    }
+    return null;
+}
+
+function _blocked_on_missing_red(state: DeliveryState, issue: string): StepResult {
+    const ticketId = _ticketId(state);
+    return new StepResult({
+        outcome: Outcome.BLOCKED,
+        questions: [
+            agent_directive('observe-red', { ticket: ticketId }),
+            `> Ticket ${ticketId} — implement gate refused: ${issue}. Write the ` +
+                'failing test for the next single behaviour and observe it fail first.',
+            '> 1. Continue — write and run that one failing test',
+            '> 2. Record an exemption — `state.tests.red = {exempt: "<reason>"}`',
+        ],
+        message: `Ticket ${ticketId} needs an observed failing test before production work: ${issue}.`,
+    });
+}
+
 function _delegate_to_apply_plan(state: DeliveryState): StepResult {
     const ticketId = _ticketId(state);
     return new StepResult({

package/src/agent-src/templates/scripts/work_engine/directives/backend/index.ts

@@ -45,6 +45,17 @@ export const SUPPORTED_KINDS: ReadonlyArray<string> = ['ticket', 'prompt'];
 // test, verify, report). The leaf name is the dispatcher slot key; in Python
 // it is derived via `step.__name__.rsplit(".", 1)[-1]` — hardcoded here since
 // the modules are imported statically.
+//
+// `implement` stays BEFORE `test`, deliberately, and the order is not the
+// test-after instruction it looks like. The tuple is linear and runs once per
+// flow, so moving `test` in front of `implement` would buy exactly one test
+// phase followed by one code phase — batch-TDD, which is the second
+// anti-pattern rather than a fix for the first. Test-first is enforced INSIDE
+// `implement` instead: `./implement.ts` refuses to emit production work for a
+// behaviour whose failing test has not been observed (`state.tests.red`), so
+// the discipline is per behaviour while the tuple stays per flow. The `test`
+// slot here is the whole-suite verdict that gates `verify`, never the first
+// time a test is written.
 const _STEPS: ReadonlyArray<[string, { run: Step; AMBIGUITIES: ReadonlyArray<Record<string, string>> }]> = [
     ['refine', refine],
     ['memory', memory],

package/src/agent-src/templates/scripts/work_engine/directives/backend/test.ts

@@ -25,6 +25,13 @@
  *   be silently skipped, and the loop cannot report one as success.
  * - Optional keys (`targeted`, `full`, `duration_ms`,
  *   `followups`) feed the delivery report.
+ * - `red` is NOT a verdict. It is the per-behaviour RED evidence
+ *   `./implement.ts` gates on, written before any production edit, and it
+ *   says nothing about the suite. A `state.tests` carrying `red` and no
+ *   `verdict` therefore means the runner has not been invoked for the suite
+ *   yet → delegate, exactly as an empty `state.tests` does. A `verdict` that
+ *   is present and unrecognised still blocks on shape; this is a
+ *   not-yet-run case, never a relaxed verdict check.
  */
 
 import type { DeliveryState} from '../../delivery_state.js';
@@ -86,7 +93,7 @@ export function run(state: DeliveryState): StepResult {
     }
 
     const tests = state.tests;
-    if (!_pyTruthy(tests)) {
+    if (!_pyTruthy(tests) || _isRedOnly(tests)) {
         return _delegate_to_run_tests(state, policy.widen_tests);
     }
 
@@ -104,6 +111,21 @@ export function run(state: DeliveryState): StepResult {
     return new StepResult({ outcome: Outcome.SUCCESS });
 }
 
+/**
+ * True when `state.tests` carries only the pre-implement RED record.
+ *
+ * `red` is written by the `implement` gate's `observe-red` directive; it is
+ * evidence about one behaviour's first failing run, not a suite verdict. Only
+ * a MISSING `verdict` routes here — a present-but-wrong one still blocks.
+ */
+function _isRedOnly(tests: Any): boolean {
+    if (!_isPlainObject(tests)) {
+        return false;
+    }
+    const d = tests as Record<string, unknown>;
+    return !('verdict' in d) && _pyTruthy(d.red);
+}
+
 function _diagnose_tests(tests: Any): string[] {
     if (!_isPlainObject(tests)) {
         return [`state.tests must be a dict, got ${_pyTypeName(tests)}`];

package/src/agent-src/templates/scripts/work_engine/directives/backend/verify.ts

@@ -33,7 +33,16 @@ import { type Any, Outcome, StepResult, agent_directive } from '../../delivery_s
 import { resolve_policy } from '../../persona_policy.js';
 import { decide, partial_exit, record_attempt, retry_halt, unmet_dod, verdict_signature } from './_self_fix.js';
 
-const _ALLOWED_VERDICTS = ['success', 'blocked', 'partial'] as const;
+/**
+ * DERIVED, never re-declared. `delivery_state.ts` is the step vocabulary's
+ * declaration for the template tree (templates are self-contained by contract
+ * and may not import from `src/scripts/`, so the registry mirrors it rather
+ * than the other way round). Spelling the three values again here made this the
+ * THIRD copy, and a third copy is how one vocabulary becomes two truths --
+ * which is the defect the outcome-vocabulary reconciliation was opened to fix.
+ * Found by the widened duplicate detector, 2026-08-30.
+ */
+const _ALLOWED_VERDICTS = Object.values(Outcome) as ReadonlyArray<Outcome>;
 
 /** Declared ambiguity surfaces. Advisory personas skip this step entirely. */
 export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [

package/src/agent-src/templates/scripts/work_engine/directives/mixed/stitch.ts

@@ -20,7 +20,11 @@ import {
 /** Agent directive that drives end-to-end smoke scenarios. */
 export const INTEGRATION_TEST_DIRECTIVE = 'integration-test';
 
-const _ALLOWED_VERDICTS: ReadonlyArray<string> = ['success', 'blocked', 'partial'];
+/**
+ * DERIVED, never re-declared — see the note in `directives/backend/verify.ts`.
+ * This was the fourth copy of the step vocabulary.
+ */
+const _ALLOWED_VERDICTS: ReadonlyArray<string> = Object.values(Outcome);
 
 export const AMBIGUITIES: ReadonlyArray<Record<string, string>> = [
     {

package/src/agent-src/templates/scripts/work_engine/stack/runner.ts

@@ -236,7 +236,7 @@ export function resolve_toolchain(
         quality.push(..._php_quality(project_root, composer, wrappers));
     }
     if (has_package) {
-        runners.push(..._js_runners(pkg, wrappers));
+        runners.push(..._js_runners(pkg, wrappers, _package_manager(project_root, pkg)));
         quality.push(..._js_quality(pkg, wrappers));
     }
     if (has_python) {
@@ -347,7 +347,7 @@ function _php_runners(root: string, composer: Manifest, wrappers: Wrappers): Run
     ];
 }
 
-function _js_runners(pkg: Manifest, wrappers: Wrappers): RunnerResult[] {
+function _js_runners(pkg: Manifest, wrappers: Wrappers, manager: string): RunnerResult[] {
     const deps = _all_dependencies(
         pkg,
         'dependencies',
@@ -383,17 +383,17 @@ function _js_runners(pkg: Manifest, wrappers: Wrappers): RunnerResult[] {
 
     // e2e runner — separate bucket, excluded unless --include-e2e.
     if ('@playwright/test' in deps || 'playwright' in deps) {
-        const cmd = _script_command(scripts, ['test:e2e', 'e2e', 'playwright']) || 'npx playwright test';
+        const cmd = _script_command(scripts, ['test:e2e', 'e2e', 'playwright'], manager) || 'npx playwright test';
         out.push(
             new RunnerResult('js', 'playwright', cmd, SPEED_E2E, HIGH, '@playwright/test in package deps'),
         );
     } else if ('cypress' in deps) {
-        const cmd = _script_command(scripts, ['test:e2e', 'e2e', 'cypress']) || 'npx cypress run';
+        const cmd = _script_command(scripts, ['test:e2e', 'e2e', 'cypress'], manager) || 'npx cypress run';
         out.push(new RunnerResult('js', 'cypress', cmd, SPEED_E2E, HIGH, 'cypress in package deps'));
     }
 
     // slow bucket — an explicit slow/integration script.
-    const slow_cmd = _script_command(scripts, ['test:slow', 'test:integration']);
+    const slow_cmd = _script_command(scripts, ['test:slow', 'test:integration'], manager);
     if (slow_cmd) {
         out.push(
             new RunnerResult(
@@ -487,19 +487,100 @@ function _task_runner_wrappers(root: string, pkg: Manifest): Wrappers {
     }
     const scripts: Manifest = _isDict(pkg.scripts) ? pkg.scripts : {};
     if (_isDict(scripts) && 'test' in scripts) {
-        out['js-test'] = `${_package_manager(root)} test`;
+        out['js-test'] = `${_package_manager(root, pkg)} test`;
     }
     return out;
 }
 
-function _package_manager(root: string): string {
-    if (_is_file(path.join(root, 'pnpm-lock.yaml'))) {
-        return 'pnpm';
+/**
+ * Lockfile → manager, in the order `monorepo-workspace/SKILL.md` § 1 states.
+ * Kept as data rather than a chain of ifs so `PACKAGE_MANAGER_BRANCHES` below
+ * can assert the count against the documented one.
+ */
+const LOCKFILE_MANAGERS: ReadonlyArray<readonly [string, string]> = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['package-lock.json', 'npm'],
+];
+
+/**
+ * The five branches `monorepo-workspace/SKILL.md` § 1 specifies, named so a
+ * test can assert none went missing. The skill is the contract and it was
+ * already correct; this list exists because the code implemented three of the
+ * five and nothing noticed.
+ */
+export const PACKAGE_MANAGER_BRANCHES: readonly string[] = [
+    'packageManager',
+    'pnpm',
+    'yarn',
+    'bun',
+    'npm',
+] as const;
+
+export interface PackageManagerResolution {
+    /** The resolved manager, or `null` when the cascade deliberately refuses. */
+    manager: string | null;
+    /** Which branch answered — one of `PACKAGE_MANAGER_BRANCHES`, or `'ambiguous'`. */
+    via: string;
+    /** Non-empty when the cascade refuses: the reported finding. */
+    finding: string;
+}
+
+/**
+ * Resolve the package manager per `monorepo-workspace/SKILL.md` § 1.
+ *
+ * Two behaviours the previous three-branch version did not have, and both are
+ * in the skill rather than invented here:
+ *
+ *  - `packageManager` in the root `package.json` is the DECLARATION and wins
+ *    when present, because it is what Corepack enforces. A lockfile is an
+ *    inference; a declaration is not.
+ *  - **Two lockfiles is a finding, not a tie to break.** The old code returned
+ *    `pnpm` for a repository carrying both `pnpm-lock.yaml` and `yarn.lock`,
+ *    silently picking the first branch it tested. That is a guess presented as
+ *    an answer, and the skill says to report both and stop.
+ */
+export function _resolve_package_manager(
+    root: string,
+    pkg?: Manifest,
+): PackageManagerResolution {
+    const declared = pkg === undefined ? undefined : pkg['packageManager'];
+    if (typeof declared === 'string' && declared.trim() !== '') {
+        // `pnpm@9.1.0` → `pnpm`. Corepack's own format.
+        const name = declared.trim().split('@')[0] as string;
+        if (name !== '') {
+            return { manager: name, via: 'packageManager', finding: '' };
+        }
+    }
+    const present = LOCKFILE_MANAGERS.filter(([file]) => _is_file(path.join(root, file)));
+    const distinct = [...new Set(present.map(([, mgr]) => mgr))];
+    if (distinct.length > 1) {
+        return {
+            manager: null,
+            via: 'ambiguous',
+            finding:
+                `two package-manager lockfiles present (${present.map(([f]) => f).join(', ')}) ` +
+                'and no `packageManager` declaration — report both and stop, per ' +
+                'monorepo-workspace SKILL.md § 1',
+        };
     }
-    if (_is_file(path.join(root, 'yarn.lock'))) {
-        return 'yarn';
+    if (distinct.length === 1) {
+        const mgr = distinct[0] as string;
+        return { manager: mgr, via: mgr, finding: '' };
     }
-    return 'npm';
+    return { manager: 'npm', via: 'npm', finding: '' };
+}
+
+/**
+ * The resolved manager as a bare string for command construction. Falls back to
+ * `npm` on the ambiguous case so a caller building a command string still gets
+ * one — the FINDING is what carries the ambiguity, and a caller that needs it
+ * calls `_resolve_package_manager` directly.
+ */
+function _package_manager(root: string, pkg?: Manifest): string {
+    return _resolve_package_manager(root, pkg).manager ?? 'npm';
 }
 
 // --------------------------------------------------------------------------
@@ -580,10 +661,17 @@ function _script_uses(scripts: Manifest, name: string, tool: string): boolean {
     return typeof value === 'string' && value.includes(tool);
 }
 
-function _script_command(scripts: Manifest, names: string[]): string {
+/**
+ * Build a `<manager> run <script>` command for the first matching script name.
+ *
+ * `manager` used to be hardcoded `npm`. Every command the work engine hands an
+ * agent for verification inherited that, so a pnpm or yarn repository was told
+ * to run a command its lockfile contradicts.
+ */
+function _script_command(scripts: Manifest, names: string[], manager: string): string {
     for (const name of names) {
         if (typeof scripts[name] === 'string') {
-            return `npm run ${name}`;
+            return `${manager} run ${name}`;
         }
     }
     return '';

package/src/config/agent-settings.template.yml

@@ -1264,6 +1264,31 @@ hooks:
   rtk_wrap:
     enabled: false
 
+  # Runtime event journal (road-to-runtime-event-journal Phase 1, step 1.4).
+  # Default-OFF. When enabled, the `journal-record` concern appends one
+  # durable, episode-keyed event record per dispatched hook event to
+  # `<git-common-dir>/agent-journal/journal.sqlite` — a Class-A write that
+  # opens, writes and exits. It emits nothing to the model, never warns and
+  # never blocks: a locked database, a missing `node:sqlite`, a malformed
+  # envelope or a full disk all degrade to silence.
+  #
+  # OFF rather than ON — unlike the sibling append-a-JSONL instruments — because
+  # this one CREATES a storage surface (a SQLite database and a directory under
+  # your `.git/`) rather than appending to a gitignored directory that already
+  # exists. ADR-124 § 3's default-off floor for engine-shaped state is not
+  # superseded by ADR-249.
+  #
+  # The record type has no field able to hold free-form content: ids, an event
+  # name, a bounded capability identifier, repo-relative locators, and two
+  # 12-hex digests (`repository_id`, `worktree_id`). No prompt, no file body, no
+  # absolute path — enforced by a committed key set, a compile-time guard and a
+  # write-time value check, not by a scrubbing pass.
+  #
+  # Retention: a 30-day TTL anchored on episode close, plus explicit,
+  # time-bounded, human-only holds that themselves expire (180 days).
+  runtime_journal:
+    enabled: false
+
   # PreToolUse anti-slop nudge (road-to-anti-slop-detector Phase 3). Default-OFF.
   # When enabled, runs the lint_design_slop registry against about-to-be-written
   # UI content (html/css/jsx/…) and WARNS (exit 2, never blocks) on P0/P1
@@ -1330,9 +1355,13 @@ hooks:
   # benchmark measured the native graph at recall 0.365 vs grep 0.797 on
   # graph-shaped questions across 3 real repos (internal/bench/reports/
   # code-graph-vs-grep.md; claim code-graph-retrieval-null). `enabled: false`
-  # is permanent; deprecation notice lands at the next major, removal the
-  # major after — unless external evidence (a consumer case the graph answers
-  # and grep cannot) appears first.
+  # is the DEFAULT and is not permanent — the removal commitment this comment
+  # used to carry was withdrawn on 2026-08-15 (docs/MIGRATION.md, the code_graph
+  # row), and "permanent" was retracted with it. What holds is the default and
+  # its reopen condition, which is the same one that was always written here:
+  # external evidence — a consumer case the graph answers and disciplined grep
+  # cannot — or a re-measurement on a build that postdates the extractor repair
+  # of 2026-08-22, which the 2026-07-28 figures predate.
   #
   # The engine's parser pair is NO LONGER a runtime dependency (~51 MB that
   # every consumer installed for a path none of them can reach); it is a

package/src/config/assurance-capability-registry.json

@@ -7,10 +7,20 @@
   "grader": {
     "path": "src/scripts/grade_target_readiness.ts",
     "dimensions": 10,
-    "knockouts": ["test-presence", "static-analysis", "security-supply-chain", "ci-enforcement"],
+    "knockouts": [
+      "test-presence",
+      "static-analysis",
+      "security-supply-chain",
+      "ci-enforcement"
+    ],
     "note": "Grades 0 Absent / 1 Present / 2 Enforced-in-CI / 3 Independent-and-diff-scoped, verdict `min` over the four knockouts, printed as `L<n> — bound by <dimension>`. Emits no aggregate figure — a test greps its own output for `%` and `/100`. `null` is 'this tool cannot tell' and is NOT a zero; on a knockout it binds at L0 with its reason printed."
   },
-  "state_vocabulary": ["available", "missing", "degraded", "unknown"],
+  "state_vocabulary": [
+    "available",
+    "missing",
+    "degraded",
+    "unknown"
+  ],
   "capabilities": {
     "unit-test": {
       "axis": "target",
@@ -53,30 +63,32 @@
       "owner_surface": "src/skills/test-driven-development/SKILL.md",
       "projection": null,
       "state": "available",
-      "rationale": "A process obligation, not a repository artefact: an observed failing test is a fact about a run, and no repository scan can recover it. Owned by the TDD skill's RED → GREEN → REFACTOR cycle, which this roadmap explicitly does not duplicate.",
-      "evidence": "src/skills/test-driven-development/SKILL.md:140 — 'Each case from the list then gets its own RED → GREEN cycle'",
-      "revisit_if": "a durable RED-run identifier is emitted somewhere a later reader can check, at which point this becomes projectable"
+      "rationale": "Was `projection: null` on the rationale that \"an observed failing test is a fact about a run, and no repository scan can recover it\". That held until 2026-08-26, when this entry's own `revisit_if` fired: `src/scripts/_lib/test_red_state.ts` now emits a durable RED-run record carrying the target, the observed failure CLASS, and a run identifier a later reader can cite. The classification stays the TDD skill's -- the store records the class the caller observed and never decides it, because a store that classified would be a second opinion competing with the contract. `projection` stays null on the contract's own terms: it names a grader DIMENSION, and `grade_target_readiness` reads a target repository, while this record is gitignored per-run state at `agents/runtime/state/test-results.json` on the machine that ran the test. An `axis: self` fact no shipped probe can read off a target is exactly the null case. Still owned by the RED -> GREEN -> REFACTOR cycle; what changed is that the cycle now leaves a trace.",
+      "evidence": "src/scripts/_lib/test_red_state.ts + tests/scripts/test_red_state.test.ts (22 tests). The load-bearing half is the invalid set: a broken fixture, a test syntax error, a missing unrelated dependency and a runner fault are recorded and marked NOT a valid red, so a production edit cannot be cleared by a failure that was never about the behaviour under test. Sensitivity proven -- admitting `broken-fixture` to the valid set turns 4 of the 22 red.",
+      "revisit_if": "The record is gitignored per-run state, so it proves a red was observed on THIS machine and nothing about CI or another developer. Revisit if a cross-machine claim is ever wanted: that needs a tracked artefact, which is a different decision under ADR-124 and not this entry's to make. Also revisit if a consumer of the record starts fuzzy-matching targets -- exact match is what stops a red observed for one behaviour clearing an edit to another."
     },
     "mutation-sensitivity": {
       "axis": "target",
       "owner_surface": "src/scripts/grade_target_readiness.ts",
-      "projection": "test-strength",
+      "projection": "advanced-testing-signals",
       "state": "degraded",
       "limitations": [
         "detection only — the grader reads stryker/infection/mutmut config presence and never runs a mutation pass",
+        "the projected dimension is UNSCORED as of 2026-08-27 \u2014 `advanced-testing-signals` emits `grade: null` plus an `observations` array, because config presence orders targets by adoption and was being read as effectiveness",
+        "the CI observation is `mutation-testing-ci-reference-detected`, never `-enforcement-`: static matching over a workflow file establishes that a mutation tool is REFERENCED there, and cannot establish that the step is enabled, blocking, reached on the required branches, or ever executed. Renamed 2026-08-27 after an independent cross-model review found the original name handed a consumer an assurance token the probe does not earn",
         "no universal min-MSI constant exists here and none may be added (AC-8)",
         "a tool-assisted rig for THIS package was refused on measured grounds by the sibling roadmap"
       ],
       "rationale": "Config presence is detected; sensitivity is never measured by this tree. For AC's own suite the manual control-inversion probe in testing-anti-patterns is the substitute, and it is a named substitute rather than a silent one.",
       "evidence": "src/skills/testing-anti-patterns/SKILL.md:185 — 'No mutation-testing rig required: comment the control out, run that one spec, put it back.' · agents/roadmaps/archive/road-to-test-independence-and-mutation-evidence.md — rig REFUSED (measured), 10 hand probes in minutes",
-      "revisit_if": "a mutation adapter ships that runs a changed-surface pass and reports survivors and timeouts separately"
+      "revisit_if": "a mutation adapter ships that runs a changed-surface pass and reports survivors and timeouts separately — but read this as a DESCRIPTION of what would lift the degraded state, never as authorization to build one. Council 2026-08-27 (anthropic + openai, 2/2 convergent) applied the mechanism-match test and found a changed-surface adapter to be the SAME mechanism the sibling roadmap measured and refused; changed-surface narrows the scope, which weakens the automation case rather than strengthening it. The governing condition is that refusal's own: a survivor population too large to hand-probe. Nothing has measured one."
     },
     "property-test": {
       "axis": "target",
       "owner_surface": "src/scripts/grade_target_readiness.ts",
-      "projection": "test-strength",
+      "projection": "advanced-testing-signals",
       "state": "available",
-      "rationale": "fast-check and Hypothesis are probed as property-based libraries.",
+      "rationale": "fast-check and Hypothesis are probed as property-based libraries. Probed and reported, never graded: since 2026-08-27 the projected dimension emits the observation `property-testing-library-detected` and no grade, because a declared dependency does not establish that any property test was written or run.",
       "evidence": "src/scripts/grade_target_readiness.ts — 'fast-check' and 'hypothesis' tokens present; asserted > 0 in the full fixture",
       "revisit_if": "the probe stops distinguishing a present property library from an absent one"
     },