@mjasnikovs/pi-task 0.18.2 → 0.18.4

package/dist/task/verify-work.js

@@ -69,6 +69,8 @@
  */
 import { USER_CANCELLED } from './child-runner.js';
 import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from './env-notes.js';
+import { buildContractsVerifyBlock } from './contracts.js';
+import { findSkipEscapes, skipEscapeVerifyFindings } from './skip-escape.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -137,7 +139,7 @@ export function extractSpecForVerification(taskBody) {
  * Guard: honest-clean fixture (prohibition in spec, probe silent) 5/5 PASS — no
  * paranoia. Reverted-violation ≡ clean at the diff level (no entry → no finding).
  */
-export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings) {
+export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings) {
     const probeBlock = probeFindings && probeFindings.length > 0 ?
         [
             'SELF-VERIFICATION NOTICE (deterministic, computed by the orchestrator from the diff):',
@@ -164,7 +166,58 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
             ''
         ]
         : [];
+    const probeGamingBlock = probeGamingFindings && probeGamingFindings.length > 0 ?
+        [
+            'CHECK-GAMING NOTICE (deterministic, computed by the orchestrator from the',
+            "task's diff): these added lines state their own purpose is to make a CHECK",
+            'pass (a test / verification / lint / gate), not to meet the requirement the',
+            'check stands for:',
+            ...probeGamingFindings.map(f => `- ${f}`),
+            'A check is a MESSENGER for a requirement. Code written to quiet the messenger',
+            'instead of meeting the requirement is a defect even when the check is green',
+            '(run-8 F6: a handler returned 401 "so the verification test passes" while the',
+            'real route stayed dead). Do NOT accept the passing check as proof. Read each',
+            "line's surrounding code and confirm the UNDERLYING requirement is genuinely",
+            'met — drive the real behavior directly (rule 4c). If the code only exists to',
+            'satisfy the check while the requirement is unmet, that is a FAIL naming the',
+            'gamed check and the unmet requirement.',
+            ''
+        ]
+        : [];
+    const skipEscapeBlock = skipEscapeFindings && skipEscapeFindings.length > 0 ?
+        [
+            "SKIP-ESCAPE NOTICE (deterministic, computed by the orchestrator from the spec's",
+            'OWN VERIFY block): these VERIFY commands wrap a required check in a fallback that',
+            'ANNOUNCES skipping it when a tool is absent — so the check can "pass" while never',
+            'actually running:',
+            ...skipEscapeFindings.map(f => `- ${f}`),
+            'Do NOT accept a skipped check as a passed check. For each, determine whether it',
+            'ACTUALLY ran and observed the real behavior. If its tool is absent so the required',
+            'behavior was never observed, that area is UNOBSERVED (rule 5c) — verdict UNOBSERVED,',
+            'not PASS. Only if you observe the required behavior another way (running the real',
+            'artifact directly) may it count as verified.',
+            ''
+        ]
+        : [];
+    const testAssemblyBlock = testAssemblyFindings && testAssemblyFindings.length > 0 ?
+        [
+            'TEST-ASSEMBLY NOTICE (deterministic, computed by the orchestrator from pure',
+            'import-graph shape): these test files rebuild production WIRING — they import the',
+            'same leaf modules the shipped entry composes and assemble their OWN copy of it,',
+            'instead of importing the production assembly:',
+            ...testAssemblyFindings.map(f => `- ${f}`),
+            'A green result on such a test proves that PRIVATE re-assembly, NOT the shipped',
+            'wiring — the copy can be wired differently (a different mount prefix, order, or',
+            'middleware) and pass while production is broken exactly at the seam the test was',
+            'meant to cover (rule 3f below). Before you count the covered area verified, drive',
+            'the behavior against the REAL shipped assembly/entry named above (start or invoke',
+            "the production entry point, not the test's hand-built app). If the real assembly",
+            'fails where the test passes, report FAIL and name the wiring seam.',
+            ''
+        ]
+        : [];
     const envBlock = envNotes && envNotes.trim().length > 0 ? [buildEnvNotesBlock(envNotes)] : [];
+    const contractsBlock = contracts && contracts.trim().length > 0 ? [buildContractsVerifyBlock(contracts)] : [];
     return [
         'You are a strict verification pass running right after an AI coding agent',
         'finished a task and committed it. The agent is known to mark work "done"',
@@ -179,8 +232,12 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         spec.trim(),
         '',
         ...envBlock,
+        ...contractsBlock,
         ...probeBlock,
         ...prohibitionBlock,
+        ...probeGamingBlock,
+        ...skipEscapeBlock,
+        ...testAssemblyBlock,
         'How to verify — verify the REAL, shipped deliverable exactly as an unaided fresh',
         'checkout (or CI run) would experience it:',
         '',
@@ -242,6 +299,38 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   server never starts, no entrypoint exists — that inability IS the defect:',
         '   report FAIL naming it. Do not stand up a substitute to get to green.',
         '',
+        '3e. NEGATIVE CONTROL IS MANDATORY — a success you cannot make fail is not evidence,',
+        '   and a check that only ever ran on the RIGHT input has not been shown to',
+        '   discriminate working from broken. For EACH behavioral check whose passing outcome',
+        '   you rely on (an endpoint returned success, a command exited 0, a call returned the',
+        '   expected value) you MUST also run that SAME check with one input deliberately',
+        '   wrong — a nonsense path, a bogus flag or subcommand, a malformed or absent',
+        '   argument, a target that does not exist — recreating whatever setup the check needs',
+        '   to do so (restart the server if a prior step killed it, re-invoke the command).',
+        '   Require a DIFFERENT, failing outcome from the wrong input. If the wrong input',
+        '   yields the SAME success (same status code, same body, same exit 0), the check',
+        '   cannot tell working from broken: it is VOID and the behavior it was meant to prove',
+        '   is UNVERIFIED — a FAIL naming the indiscriminate check (e.g. "a POST to a nonsense',
+        '   path returns the same 200 and body as the real endpoint, so the route is unproven',
+        '   — a catch-all fallback is masking it"). Skipping the control is not neutral: a',
+        '   required behavior left without a discriminating check is UNVERIFIED, and',
+        '   unverified is a FAIL, never a PASS. A wrong-input control exists for every',
+        '   artifact — HTTP request, CLI invocation, library call, schema load, config parse.',
+        '',
+        '3f. TEST-REBUILT ASSEMBLY: a test proves only the copy if it RE-CONSTRUCTS wiring that',
+        '   also exists in production — assembling its own app / entry point / config out of the',
+        '   same leaf modules the shipped entry composes, instead of importing and exercising the',
+        '   production assembly. Such a test can wire the leaves differently from production (a',
+        '   different prefix, order, adapter, or middleware) and pass green while the SHIPPED',
+        '   wiring is broken at exactly the seam the test was meant to cover — its green result',
+        '   never touched the production assembly at all. Whenever a spec-required behavior is',
+        '   covered ONLY by tests that build their own composition of the real modules, that',
+        '   behavior is UNVERIFIED off those tests: exercise the REAL shipped entry/assembly (run',
+        '   or invoke the production entry point, hit the real composed surface) and judge THAT.',
+        '   If the real assembly fails where the copy passes, report FAIL naming the wiring seam',
+        '   (e.g. "the entry mounts <module> at <X> but the test mounts it at <Y>, so the real',
+        '   path is dead while the test is green").',
+        '',
         '4. Treat the ACCEPTANCE criteria as the bar. If a command fails, or its real output',
         '   contradicts an ACCEPTANCE criterion, the work has NOT verified.',
         '',
@@ -258,6 +347,18 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   for…") that covers the change — judged against that stated exception, not against',
         '   your view of harmlessness.',
         '',
+        '4c. THE CHECK IS THE MESSENGER, NOT THE REQUIREMENT — code (or a comment) whose',
+        '   stated purpose is to make a check PASS, rather than to satisfy the requirement the',
+        '   check stands for, is a defect even when the check is green. The tell is the intent',
+        '   written down: "return X so the test passes", "hardcode this to satisfy the linter",',
+        '   "stub it out to appease CI". When you see such a line — or the CHECK-GAMING NOTICE',
+        '   above names one — do NOT treat the passing check as proof the requirement is met.',
+        '   Find the actual requirement the check was meant to prove and verify THAT directly',
+        '   against the real artifact (rule 3e negative control is the sharpest tool: a handler',
+        '   that answers the check-shaped request the same way for a WRONG input is gaming the',
+        '   check, not implementing the behavior). If the requirement is genuinely unmet while',
+        '   the check passes, the verdict is FAIL naming the gamed check and the real gap.',
+        '',
         '5. The ONLY thing you may assume is already provided is a genuinely EXTERNAL running',
         '   service or network resource (a database server, an API host) that the project',
         '   documents as a prerequisite. Before you rely on that assumption, PROBE for the',
@@ -282,8 +383,36 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   that is a FAIL naming the gap. Any schema surgery you performed to reach green IS the',
         '   defect.',
         '',
-        '6. If the spec legitimately has no runnable verification (a pure docs / config change',
-        '   with nothing to build or run), validating it cleanly is a PASS.',
+        '5c. A SPEC-REQUIRED CHECK THAT DID NOT ACTUALLY RUN IS NOT VERIFIED. The env-gap',
+        '   exception (rule 5) covers ONLY a genuinely EXTERNAL service the finished product',
+        "   connects to (a database, an API host). It does NOT cover a check the SPEC's own",
+        "   VERIFY block authored to OBSERVE the deliverable's required behavior. If such a",
+        '   check did not actually execute — the tool or runner it needs is not installed, or',
+        '   the VERIFY line short-circuits ITSELF with a skip-escape (`|| true`, `|| echo',
+        '   skipping`, `2>/dev/null || exit 0`, `command -v X ||` …) so a missing tool passes',
+        '   silently — then that behavior was NEVER OBSERVED. A skipped check is not a passed',
+        '   check: you may not count the area as verified, and "correctly skipped" is NOT a',
+        "   PASS. Do not let the work's own skip-escape waive the work's own gate. When a",
+        '   REQUIRED behavior could not be observed because its observation tooling is absent,',
+        '   the verdict is UNOBSERVED — report exactly what could not be observed and which',
+        '   tool was missing, so a human decides whether to provision the tool or accept the',
+        '   unproven behavior.',
+        '   DISCRIMINATOR (rule 5 vs rule 5c) — when something needed is absent, ask which it',
+        '   is: (rule 5, env-gap, do NOT fail the code) a SERVICE the FINISHED PRODUCT itself',
+        '   connects to at runtime to FUNCTION — a database, an API host, a message broker —',
+        '   whose absence is an environment gap; versus (rule 5c, UNOBSERVED) a HARNESS that',
+        '   exists only to OBSERVE or DRIVE the product during a check — a browser driver, a',
+        "   UI/terminal smoke, a snapshot or fuzz tool — whose absence leaves the product's own",
+        '   behavior unproven. The product NEEDS the former to work at all; it needs the latter',
+        '   only to be CHECKED. A command that fails because such a runtime SERVICE is absent',
+        '   stays a rule-5 env-gap and is NOT UNOBSERVED; a required behavior you could not',
+        '   OBSERVE because its test harness is absent IS UNOBSERVED.',
+        '',
+        '6. If the spec legitimately has no runnable verification at all (a pure docs / config',
+        '   change with nothing to build or run), validating it cleanly is a PASS. This is NOT',
+        '   the same as a required behavioral check that self-skipped or whose tool is absent',
+        '   (that is UNOBSERVED, rule 5c) — "nothing to verify" means the spec never demanded',
+        '   an observation, not that an observation was demanded and then dodged.',
         '',
         '7. Do NOT edit anything to make a check pass. Report what you actually saw.',
         '',
@@ -291,32 +420,53 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         'acceptance criterion is unmet — a required function absent, required data not persisted,',
         'a required behavior missing — the verdict is FAIL, even if typecheck and lint are green',
         'and even if the gap seems minor. Never downgrade an unmet criterion to a warning note.',
+        'Before concluding PASS, confirm every behavioral check you relied on has its paired',
+        'negative control (rule 3e) showing it CAN fail; a required behavior with no',
+        'discriminating check is UNVERIFIED, and the verdict is FAIL.',
         '',
         ENV_NOTE_EMIT_INSTRUCTION,
         '',
         'When you are done, output EXACTLY ONE of these as the final line:',
         "  WORK-VERIFIED: PASS              (the project's own command, run unaided, met the spec)",
         '  WORK-VERIFIED: FAIL <text>      (the shipped command failed or did not meet the spec; say what failed)',
+        '  WORK-VERIFIED: UNOBSERVED <text> (a spec-required behavioral check could not run because',
+        '                                    its observation tooling is absent — the behavior is',
+        '                                    unproven, not passed and not a code failure; rule 5c)',
         'Output the verdict line verbatim — it is parsed mechanically.'
     ].join('\n');
 }
 /**
- * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL` marker
- * (the model discusses before concluding, and bash output may echo the word
+ * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL|UNOBSERVED`
+ * marker (the model discusses before concluding, and bash output may echo the word
  * "VERIFY", so a distinct token and last-match win matter).
  *
+ * UNOBSERVED (rule 5c) is a distinct third outcome: a spec-required behavioral check
+ * could not run because its observation tooling is absent, so the behavior is neither
+ * proven nor shown broken. It is NOT a pass (`pass: false`) but carries `unobserved`
+ * so the gate can route it straight to the human — an unattended AUTOFIX re-run cannot
+ * provision a missing tool, so it must never auto-loop on this.
+ *
  * No marker at all is NOT a pass: a verification that cannot state a verdict is a
  * gray area, and the contract is that unverified work is reported as such.
  */
 export function parseVerifyVerdict(text) {
-    const re = /WORK-VERIFIED:\s*(PASS|FAIL)\b[ \t]*(.*)/gi;
+    const re = /WORK-VERIFIED:\s*(PASS|FAIL|UNOBSERVED)\b[ \t]*(.*)/gi;
     let last = null;
     for (let m = re.exec(text); m !== null; m = re.exec(text))
         last = m;
     if (!last)
         return { pass: false, detail: 'no verdict emitted' };
-    const pass = last[1].toUpperCase() === 'PASS';
-    return { pass, detail: pass ? '' : last[2].trim() || 'unspecified failure' };
+    const kind = last[1].toUpperCase();
+    if (kind === 'PASS')
+        return { pass: true, detail: '' };
+    if (kind === 'UNOBSERVED') {
+        return {
+            pass: false,
+            unobserved: true,
+            detail: last[2].trim() || 'a required behavior could not be observed'
+        };
+    }
+    return { pass: false, detail: last[2].trim() || 'unspecified failure' };
 }
 /**
  * Run the verification pass for one task. A missing spec is a pass. Otherwise run
@@ -359,6 +509,28 @@ export async function runWorkVerification(deps) {
             prohibitions = [];
         }
     }
+    // Test-assembly findings feed the prompt (rule 3f); a probe failure must never
+    // block verification — it is an optional sharpener like the substitution probe.
+    let testAssembly = [];
+    if (deps.testAssemblyProbe) {
+        try {
+            testAssembly = await deps.testAssemblyProbe();
+        }
+        catch {
+            testAssembly = [];
+        }
+    }
+    // Probe-gaming findings feed the prompt (rule 4c, F6); a probe failure must never
+    // block verification — an optional sharpener like the other diff-shape probes.
+    let probeGaming = [];
+    if (deps.probeGamingProbe) {
+        try {
+            probeGaming = await deps.probeGamingProbe();
+        }
+        catch {
+            probeGaming = [];
+        }
+    }
     // Environment facts from earlier gate children (best-effort; a cache failure
     // must never block verification).
     let envNotes = '';
@@ -370,6 +542,23 @@ export async function runWorkVerification(deps) {
             envNotes = '';
         }
     }
+    // Cross-slice contracts from decompose-time extraction (best-effort; a read
+    // fault must never block verification).
+    let contracts = '';
+    if (deps.contracts) {
+        try {
+            contracts = await deps.contracts();
+        }
+        catch {
+            contracts = '';
+        }
+    }
+    // DETERMINISTIC skip-escape finding, computed purely from the spec's own VERIFY
+    // block (see skip-escape.ts): a required check wrapped in a skip-announcing `||`
+    // fallback. Injected so rule 5c fires reliably — the model does not self-discover a
+    // graceful skip-escape (A/B: rule alone ~1-3/5), but acts on a finding naming the
+    // exact line, per the proven probe+rule pattern. Pure text analysis, no dep needed.
+    const skipEscapes = skipEscapeVerifyFindings(findSkipEscapes(deps.spec));
     // A child that emits NO verdict never judged the work (budget/context death mid-
     // investigation — seen live: an 11-minute verify wandered, died verdict-less, and
     // the resulting FAIL burned a full implementation re-run on an unjudged artifact).
@@ -377,7 +566,7 @@ export async function runWorkVerification(deps) {
     for (let attempt = 1;; attempt++) {
         let text;
         try {
-            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions), deps.signal);
+            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming), deps.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === USER_CANCELLED)
@@ -414,6 +603,12 @@ export async function runWorkVerification(deps) {
             return { ok: true };
         if (verdict.detail === 'no verdict emitted' && attempt === 1)
             continue;
+        // UNOBSERVED (rule 5c): a spec-required behavioral check could not run because
+        // its tooling is absent. Block like any FAIL, but flag it so the gate hands it
+        // straight to the human — re-running the impl turn cannot install a missing tool.
+        if (verdict.unobserved) {
+            return { ok: false, unobserved: true, reason: `work unobserved: ${verdict.detail}` };
+        }
         return {
             ok: false,
             reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`

package/dist/task/wiring-claims.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Deterministic synthesized-wiring scanner for a composed spec (run-8 F3, gen side).
+ *
+ * F3 (the dominant run-8 shipped defect): refine/compose invent a "uniform" wiring
+ * table — one module → one mount prefix, `/api/<x>` → `<x>Routes` for every module —
+ * though the design pins ENDPOINTS, not mounts, and one module's pinned endpoints do
+ * NOT all sit under a single prefix (photos: `POST /api/listings/:id/photos` AND
+ * `GET/DELETE /api/photos/:id`). Mounting that module at `/api/photos` double-prefixes
+ * the upload; consumers follow the pinned paths, assembly follows the invented table,
+ * the seam ships broken. See [[contract-registry-f3]] (#4, the verify-side + registry
+ * lever) — this is its GENERATION-side complement.
+ *
+ * A/B-measured on the live 27B (F3 critique trap): the CROSS-SLICE CONTRACTS registry
+ * is NECESSARY but the prompt+registry alone is a WEAK catcher (A/B arms 0/8, +registry
+ * only 1/8) — the model's attention goes to the obvious VERIFY weakness and it rarely
+ * does the path-composition reasoning even with the facts in front of it. The reliable
+ * lever is the SAME probe+rule pattern as [[skip-escape-scanner-f2]] / [[verify-
+ * substitution-ab]]: a deterministic finding that NAMES the exact synthesized mappings
+ * and juxtaposes the verbatim pinned facts, forcing focused reconciliation.
+ *
+ * This scanner does NOT decide which mapping is wrong — that needs routing-composition
+ * knowledge (a forbidden stack assumption). It surfaces every mapping that (a) is not a
+ * verbatim substring of the design/registry (so it is INFERRED, not cited) AND (b) touches
+ * a pinned cross-slice boundary (an operand appears in the registry) — i.e. it reshapes a
+ * shared contract. The 4 coincidentally-correct mappings are surfaced too, but framed as
+ * "reconcile each; keep the conforming ones" — the LLM decides, informed. Pure text/
+ * substring analysis; no stack, framework, or routing assumptions. Empty registry (single
+ * `/task`, or no shared boundary) ⇒ no-op.
+ */
+export interface WiringClaim {
+    /** The offending mapping line, verbatim (trimmed). */
+    line: string;
+    /** Left operand (the mapped-from token, e.g. a mount prefix). */
+    from: string;
+    /** Right operand (the mapped-to token, e.g. a module name). */
+    to: string;
+}
+/**
+ * Find synthesized wiring mappings in `spec`: `A <arrow> B` lines whose whole mapping
+ * is NOT a verbatim substring of `grounding` (design ∪ registry) yet an operand appears
+ * in `registry` (so it reshapes a pinned cross-slice boundary). Returns [] when the
+ * registry is empty (no shared contracts to reshape) — the whole check is a no-op then.
+ */
+export declare function findSynthesizedWiring(spec: string, grounding: string, registry: string): WiringClaim[];
+/**
+ * Render findings as the critique probe (probe+rule pattern): NAME the inferred
+ * mappings and juxtapose the verbatim pinned facts, then instruct focused
+ * reconciliation. Deliberately does NOT accuse a specific mapping — the model decides
+ * which (if any) fails to reproduce a pinned fact. Empty findings ⇒ '' (no block).
+ */
+export declare function wiringProbeText(findings: WiringClaim[], registry: string): string;
+/**
+ * Render findings as a critique-rewrite defect block (fed into the FOCUS list): the
+ * rewrite must reconcile each mapping against the pinned facts and correct only the
+ * one(s) that break. Mirrors skipEscapeDefectText's shape.
+ */
+export declare function wiringDefectText(findings: WiringClaim[], registry: string): string;
+/**
+ * Concatenate the design/spec docs the given texts @-reference (best-effort, readable
+ * files only) as extra grounding for findSynthesizedWiring — so a mapping the design
+ * states verbatim is treated as CITED, not synthesized. Unreadable/absent mentions are
+ * skipped; returns '' when nothing resolves.
+ */
+export declare function readReferencedDocs(cwd: string, ...texts: string[]): string;

package/dist/task/wiring-claims.js

@@ -0,0 +1,149 @@
+/**
+ * Deterministic synthesized-wiring scanner for a composed spec (run-8 F3, gen side).
+ *
+ * F3 (the dominant run-8 shipped defect): refine/compose invent a "uniform" wiring
+ * table — one module → one mount prefix, `/api/<x>` → `<x>Routes` for every module —
+ * though the design pins ENDPOINTS, not mounts, and one module's pinned endpoints do
+ * NOT all sit under a single prefix (photos: `POST /api/listings/:id/photos` AND
+ * `GET/DELETE /api/photos/:id`). Mounting that module at `/api/photos` double-prefixes
+ * the upload; consumers follow the pinned paths, assembly follows the invented table,
+ * the seam ships broken. See [[contract-registry-f3]] (#4, the verify-side + registry
+ * lever) — this is its GENERATION-side complement.
+ *
+ * A/B-measured on the live 27B (F3 critique trap): the CROSS-SLICE CONTRACTS registry
+ * is NECESSARY but the prompt+registry alone is a WEAK catcher (A/B arms 0/8, +registry
+ * only 1/8) — the model's attention goes to the obvious VERIFY weakness and it rarely
+ * does the path-composition reasoning even with the facts in front of it. The reliable
+ * lever is the SAME probe+rule pattern as [[skip-escape-scanner-f2]] / [[verify-
+ * substitution-ab]]: a deterministic finding that NAMES the exact synthesized mappings
+ * and juxtaposes the verbatim pinned facts, forcing focused reconciliation.
+ *
+ * This scanner does NOT decide which mapping is wrong — that needs routing-composition
+ * knowledge (a forbidden stack assumption). It surfaces every mapping that (a) is not a
+ * verbatim substring of the design/registry (so it is INFERRED, not cited) AND (b) touches
+ * a pinned cross-slice boundary (an operand appears in the registry) — i.e. it reshapes a
+ * shared contract. The 4 coincidentally-correct mappings are surfaced too, but framed as
+ * "reconcile each; keep the conforming ones" — the LLM decides, informed. Pure text/
+ * substring analysis; no stack, framework, or routing assumptions. Empty registry (single
+ * `/task`, or no shared boundary) ⇒ no-op.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Mapping arrows a wiring/mount table uses across notations. A colon is deliberately
+ *  NOT an arrow — it matches endpoint params (`/photos/:id`), section headers, and prose,
+ *  which would drown the signal. */
+const ARROW = '(?:→|->|=>|⇒|↦)';
+/** A `left <arrow> right` mapping on one line, tolerating a leading list bullet. */
+const MAPPING_LINE_RE = new RegExp(`^[ \\t]*[-*]?[ \\t]*(.+?)[ \\t]*${ARROW}[ \\t]*(.+?)[ \\t]*$`);
+/** An operand shorter than this is too generic to anchor a boundary match. */
+const MIN_OPERAND_LENGTH = 4;
+/** Collapse whitespace + lowercase; drop markdown backticks so quoting formatting
+ *  differences don't defeat the substring match. Mirrors contracts.ts's normalise. */
+function normalise(s) {
+    return s.replace(/`/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+/**
+ * Find synthesized wiring mappings in `spec`: `A <arrow> B` lines whose whole mapping
+ * is NOT a verbatim substring of `grounding` (design ∪ registry) yet an operand appears
+ * in `registry` (so it reshapes a pinned cross-slice boundary). Returns [] when the
+ * registry is empty (no shared contracts to reshape) — the whole check is a no-op then.
+ */
+export function findSynthesizedWiring(spec, grounding, registry) {
+    if (registry.trim().length === 0)
+        return [];
+    const groundHay = normalise(grounding + '\n' + registry);
+    const regHay = normalise(registry);
+    const found = [];
+    const seen = new Set();
+    for (const rawLine of spec.split('\n')) {
+        const m = MAPPING_LINE_RE.exec(rawLine);
+        if (!m)
+            continue;
+        const from = m[1].trim();
+        const to = m[2].trim();
+        const line = rawLine.replace(/^[ \t]*[-*][ \t]*/, '').trim();
+        const key = normalise(line);
+        if (key.length === 0 || seen.has(key))
+            continue;
+        // Cited, not synthesized: the whole mapping appears verbatim in the source.
+        if (groundHay.includes(key))
+            continue;
+        // Only a mapping that touches a PINNED shared boundary is an F3 suspect — this
+        // is the crisp discriminator that keeps internal-flow prose ("input → output")
+        // out. An operand (long enough to be specific) must appear in the registry.
+        const touchesBoundary = [from, to].some(op => {
+            const n = normalise(op);
+            return n.length >= MIN_OPERAND_LENGTH && regHay.includes(n);
+        });
+        if (!touchesBoundary)
+            continue;
+        seen.add(key);
+        found.push({ line, from: from.replace(/`/g, ''), to: to.replace(/`/g, '') });
+    }
+    return found;
+}
+/**
+ * Render findings as the critique probe (probe+rule pattern): NAME the inferred
+ * mappings and juxtapose the verbatim pinned facts, then instruct focused
+ * reconciliation. Deliberately does NOT accuse a specific mapping — the model decides
+ * which (if any) fails to reproduce a pinned fact. Empty findings ⇒ '' (no block).
+ */
+export function wiringProbeText(findings, registry) {
+    if (findings.length === 0)
+        return '';
+    return [
+        'SYNTHESIZED WIRING (deterministic finding) — the spec states these connect-the-',
+        'modules mappings that are NOT quoted verbatim from the design (they are INFERRED,',
+        'not cited) and that touch a pinned cross-slice boundary:',
+        ...findings.map((f, i) => `  ${i + 1}. ${f.line}`),
+        'The design pins these interface FACTS instead (verbatim, authoritative):',
+        ...registry
+            .trim()
+            .split('\n')
+            .filter(l => l.trim().length > 0)
+            .map(l => `  - ${l.trim()}`),
+        'For EACH mapping above, confirm it REPRODUCES the pinned facts EXACTLY. A module',
+        'whose pinned facts do NOT all sit under the single prefix it is mapped to CANNOT be',
+        'wired that way without breaking a path — that is a SEAM BUG: name the mapping and the',
+        'pinned fact it fails to produce. KEEP every mapping that does reproduce its facts; do',
+        'NOT alter a conforming one. If a boundary detail is genuinely unpinned, leave it',
+        'unspecified rather than inventing a mapping.'
+    ].join('\n');
+}
+/**
+ * Render findings as a critique-rewrite defect block (fed into the FOCUS list): the
+ * rewrite must reconcile each mapping against the pinned facts and correct only the
+ * one(s) that break. Mirrors skipEscapeDefectText's shape.
+ */
+export function wiringDefectText(findings, registry) {
+    return wiringProbeText(findings, registry);
+}
+// An @-file mention in a spec ("@DESIGN/foo.md"), minus trailing prose punctuation.
+// Mirrors phantom-imports' mention rules so grounding sees the same source docs.
+const MENTION_RE = /(?:^|\s)@([^\s]+)/g;
+const MENTION_TRAILING_PUNCT = /[.,;:!?)\]}>"']+$/;
+/**
+ * Concatenate the design/spec docs the given texts @-reference (best-effort, readable
+ * files only) as extra grounding for findSynthesizedWiring — so a mapping the design
+ * states verbatim is treated as CITED, not synthesized. Unreadable/absent mentions are
+ * skipped; returns '' when nothing resolves.
+ */
+export function readReferencedDocs(cwd, ...texts) {
+    const seen = new Set();
+    const parts = [];
+    for (const text of texts) {
+        for (const m of text.matchAll(MENTION_RE)) {
+            const rel = m[1].replace(MENTION_TRAILING_PUNCT, '');
+            if (rel === '' || seen.has(rel))
+                continue;
+            seen.add(rel);
+            try {
+                parts.push(fs.readFileSync(path.resolve(cwd, rel), 'utf8'));
+            }
+            catch {
+                // not a readable file — skip
+            }
+        }
+    }
+    return parts.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.2",
+    "version": "0.18.4",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",
@@ -14,7 +14,7 @@
     "scripts": {
         "build": "tsc -p tsconfig.build.json",
         "lint": "prettier --log-level warn --write 'src/**/*.ts' && eslint --fix . && tsc --noEmit",
-        "test": "bun test src/",
+        "test": "AGENT=1 bun test src/",
         "prepublishOnly": "bun run build"
     },
     "peerDependencies": {