@mjasnikovs/pi-task 0.18.2 → 0.18.4

package/dist/task/env-notes.js

@@ -18,6 +18,19 @@
  * project setup: the verify-as-shipped rule ("any prep you needed IS the
  * defect") still governs every verdict — the block injected into prompts says
  * so explicitly. The cache only kills re-discovery time.
+ *
+ * PROVENANCE + RE-VALIDATION (run 8, F7): a verify child once grepped component
+ * names in a MINIFIED bundle (identifiers mangled ⇒ 0 hits by construction),
+ * wrote "build tree-shakes ALL route components — pre-existing issue" to the
+ * cache, and ten later tasks inherited it verbatim as a standing "pre-existing,
+ * unrelated" excuse to wave off a genuinely broken deliverable — nobody
+ * re-checked. Two guards close that class: (a) each note is stamped host-side
+ * with the ORIGIN task that recorded it (a note is second-hand hearsay, not the
+ * reader's own observation); (b) the injected block demands the reader
+ * RE-VALIDATE a note in the CURRENT tree before citing it to excuse a failure,
+ * flags EXCUSE-CLASS notes ("pre-existing", "unrelated", "tree-shaken") for
+ * exactly that scrutiny, and forbids treating a grep of a generated artifact as
+ * evidence of absence. Provenance is mechanical; re-validation is prompt-level.
  */
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
@@ -27,10 +40,16 @@ const ENV_NOTES_FILE = 'env-notes.md';
 const MAX_NOTES = 40;
 /** A single fact is one line; anything longer is prose, not a fact. */
 const MAX_NOTE_LENGTH = 240;
+/**
+ * Field separator between a fact and its origin in the stored file. A tab never
+ * occurs in a one-line fact (facts are prose), so it round-trips cleanly and any
+ * stray tab in an emitted fact is normalised to a space before storage.
+ */
+const ORIGIN_SEP = '\t';
 export function envNotesFile(cwd) {
     return path.join(tasksDir(cwd), ENV_NOTES_FILE);
 }
-/** The cached notes, one fact per line ('' when none were recorded yet). */
+/** The raw stored file ('' when none were recorded yet). Parse with parseEnvNotes. */
 export async function readEnvNotes(cwd) {
     try {
         return (await fsp.readFile(envNotesFile(cwd), 'utf8')).trim();
@@ -39,6 +58,27 @@ export async function readEnvNotes(cwd) {
         return '';
     }
 }
+/**
+ * Parse the stored file into fact+origin records. Legacy lines written before
+ * provenance (no separator) parse with an empty origin, so old caches still read.
+ */
+export function parseEnvNotes(raw) {
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const t = line.trim();
+        if (t.length === 0)
+            continue;
+        const i = t.indexOf(ORIGIN_SEP);
+        if (i === -1)
+            out.push({ fact: t, origin: '' });
+        else
+            out.push({ fact: t.slice(0, i).trim(), origin: t.slice(i + 1).trim() });
+    }
+    return out;
+}
+function serializeNote(n) {
+    return n.origin ? `${n.fact}${ORIGIN_SEP}${n.origin}` : n.fact;
+}
 /**
  * Pull `ENV-NOTE: <fact>` lines out of a child's answer text. Deduplicated,
  * length-capped; verdict markers can never match (different prefix).
@@ -58,54 +98,110 @@ export function extractEnvNotes(text) {
     }
     return notes;
 }
+/**
+ * EXCUSE-CLASS wording: a note that waves a problem off as someone else's or a
+ * prior condition ("pre-existing … mismatch", "unrelated to this task",
+ * "tree-shaken", "not applicable"). These are the notes that propagate across
+ * slices as standing excuses (mx5 run-8 F7) — every one of the run-8 cache's
+ * dozen such notes was either the false tree-shake fact or the schema mismatch
+ * the final gate later proved was a REAL defect. Pure text, stack-agnostic; the
+ * flag never drops or fails a note, it only marks it as needing live
+ * re-validation before it may EXCUSE a failure. FP is harmless by construction:
+ * a benign fact re-validates and is used, the marker only bites a citation-to-
+ * wave-off. Benign status facts ("5 pre-existing warnings") do not match — a
+ * "pre-existing" match requires a co-located problem word.
+ */
+const EXCUSE_PATTERNS = [
+    /\bunrelated\b/i,
+    /\bnot (?:my|our|this) (?:task|concern|deliverable|slice|problem)\b/i,
+    /\boutside (?:the|this) deliverable\b/i,
+    /\bnot applicable\b/i,
+    /\bnot specific to\b/i,
+    /\btree[-\s]?shak/i,
+    /\bpre-?existing\b[^.\n]*\b(?:fail|issue|mismatch|bug|error|broken|problem|affect)/i,
+    /\baffect(?:ing|s)? all\b/i
+];
+/** True when a fact reads like a standing excuse (see EXCUSE_PATTERNS). */
+export function isExcuseNote(fact) {
+    return EXCUSE_PATTERNS.some(re => re.test(fact));
+}
 /**
  * Append newly discovered facts to the cache, deduplicated against what is
- * already there (case-insensitive full-line match), keeping the newest
- * MAX_NOTES. Failures are swallowed — the cache is a sharpener, never a
+ * already there (case-insensitive fact match), keeping the newest MAX_NOTES.
+ * Each new fact is stamped with the `origin` task that recorded it; a fact
+ * already present keeps its ORIGINAL origin (provenance traces to who first
+ * established it). Failures are swallowed — the cache is a sharpener, never a
  * blocker.
  */
-export async function appendEnvNotes(cwd, notes) {
+export async function appendEnvNotes(cwd, notes, origin = '') {
     if (notes.length === 0)
         return;
     try {
-        const existing = (await readEnvNotes(cwd)).split('\n').filter(l => l.trim().length > 0);
-        const seen = new Set(existing.map(l => l.trim().toLowerCase()));
+        const existing = parseEnvNotes(await readEnvNotes(cwd));
+        const seen = new Set(existing.map(n => n.fact.toLowerCase()));
         const merged = [...existing];
         for (const note of notes) {
-            const key = note.trim().toLowerCase();
-            if (seen.has(key))
+            const fact = note.trim().replace(/\t/g, ' ');
+            const key = fact.toLowerCase();
+            if (key.length === 0 || seen.has(key))
                 continue;
             seen.add(key);
-            merged.push(note.trim());
+            merged.push({ fact, origin: origin.trim() });
         }
         const kept = merged.slice(-MAX_NOTES);
         await fsp.mkdir(tasksDir(cwd), { recursive: true });
-        await fsp.writeFile(envNotesFile(cwd), kept.join('\n') + '\n', 'utf8');
+        await fsp.writeFile(envNotesFile(cwd), kept.map(serializeNote).join('\n') + '\n', 'utf8');
     }
     catch {
         // best-effort cache
     }
 }
 /**
- * The prompt block a gate child receives when notes exist. The caveat is
- * load-bearing: facts save re-discovery time but grant no waiver from the
- * verify-as-shipped rule.
+ * The prompt block a gate child receives when notes exist. Two things are
+ * load-bearing: the no-waiver caveat (facts save re-discovery time but grant no
+ * license to prepare/repair) and the trust discipline (a note is second-hand
+ * until re-validated; an EXCUSE-CLASS note may not wave off a failure without a
+ * live re-check; a grep of a generated artifact is not evidence of absence).
  */
-export function buildEnvNotesBlock(notes) {
-    if (notes.trim().length === 0)
+export function buildEnvNotesBlock(raw) {
+    const notes = parseEnvNotes(raw);
+    if (notes.length === 0)
         return '';
+    const lines = notes.map(n => {
+        const origin = n.origin ? ` — recorded by ${n.origin}` : ' — origin unrecorded';
+        const flag = isExcuseNote(n.fact) ?
+            '  [EXCUSE-CLASS — re-validate in the CURRENT tree before citing this to wave off any failure]'
+            : '';
+        return `- ${n.fact}${origin}${flag}`;
+    });
     return [
-        'KNOWN ENVIRONMENT FACTS — discovered by earlier verification passes in this run',
-        '(informational, may be stale):',
-        ...notes
-            .trim()
-            .split('\n')
-            .map(n => `- ${n}`),
+        'KNOWN ENVIRONMENT FACTS — recorded by earlier verification passes in this run',
+        '(second-hand, may be stale or WRONG):',
+        ...lines,
+        '',
         'These facts only save you re-discovery time (where credentials/config live, which',
         'tools are installed, which services are reachable). They are NOT a license to',
         'prepare or repair the run: the verify-as-shipped rules below still govern the',
         'verdict — if the project needs something its own committed files do not provide,',
         'that remains the defect no matter what is listed here.',
+        '',
+        'TRUST DISCIPLINE — a false "pre-existing, unrelated" note once masked a real shipped',
+        'defect across many tasks in this exact pipeline; do not repeat it:',
+        '- A note above is second-hand hearsay from another task, not your own observation.',
+        '  You may CITE one to EXCUSE, wave off, or down-grade a failure ONLY IF you',
+        '  RE-VALIDATE its claim in the CURRENT tree right now and state the command or',
+        '  observation you used to reconfirm it.',
+        '- If a note fails re-validation (its claim is not true in the current tree), do NOT',
+        "  inherit it: treat the underlying problem as UNexcused and report it. Don't silently",
+        '  carry a stale fact forward.',
+        '- EVIDENCE HYGIENE: string-searching a MINIFIED, bundled, or otherwise generated or',
+        '  compiled artifact is NOT evidence that something is absent — identifiers there are',
+        '  renamed or stripped by construction, so a zero-hit grep proves nothing. Derive',
+        '  presence/absence only from SOURCE files or by EXECUTING the artifact and observing.',
+        '- A claim that a defect is "pre-existing", "unrelated", or "not this task" is an',
+        '  EXCUSE, not a fact (the ones above are marked): re-establish it live, and if it',
+        '  actually holds as a real defect, escalate it (report FAIL) rather than passing it',
+        '  on as a standing waiver.',
         ''
     ].join('\n');
 }
@@ -115,7 +211,11 @@ export const ENV_NOTE_EMIT_INSTRUCTION = [
     'THIS MACHINE or the project environment (a service reachable/absent at an address, where',
     'credentials/config live, a tool or runtime present/missing and its version), emit a line',
     '  ENV-NOTE: <one-line fact>',
-    'anywhere in your answer, one per fact. Facts about the ENVIRONMENT only — never task',
-    'verdicts, never spec content, never code judgments. These are cached for later',
-    'verification passes in this run so they do not re-discover the same things.'
+    'anywhere in your answer, one per fact. A fact is something you OBSERVED to be true of the',
+    'machine or environment — never a task verdict, never spec content, never a judgment about',
+    'the code. In particular do NOT record an absence you inferred from grepping a built or',
+    'minified artifact (identifiers there are mangled — a zero-hit grep proves nothing), and',
+    'do NOT record "X is pre-existing / unrelated / not my task": that is a verdict, not an',
+    'environment fact. These are cached for later verification passes in this run so they do',
+    'not re-discover the same things.'
 ].join('\n');

package/dist/task/gate-deps.d.ts

@@ -1,6 +1,7 @@
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import type { GateDeps } from './task-gates.js';
 import { type FinalFixResult } from './final-gate-fix.js';
+import { type AddedLine } from './probe-gaming.js';
 import { type ChangedFile } from './substitution-probe.js';
 /** A function that re-runs a task's implementation turn (AUTOFIX). Injected by the
  *  command so this module stays free of the orchestrators (avoids an import cycle). */
@@ -17,6 +18,15 @@ export type FinalGateFixFn = (ctx: ExtensionCommandContext, cwd: string, failRea
  * blocker.
  */
 export declare function collectChangedFiles(cwd: string, signal?: AbortSignal): Promise<ChangedFile[]>;
+/**
+ * Collect the task's added lines WITH CONTENT (path + text) for the probe-gaming
+ * probe (F6), which needs the actual line text the numstat-shape collector omits.
+ * Pre-commit the work is the tree-vs-HEAD diff plus untracked files (read whole, as
+ * all-added); on the post-enforce re-verify the tree is clean, so fall back to the
+ * last commit's diff. Failures degrade to an empty list — the probe is a sharpener,
+ * never a blocker. The `.pi-tasks/` bookkeeping is excluded from every git command.
+ */
+export declare function collectAddedLines(cwd: string, signal?: AbortSignal): Promise<AddedLine[]>;
 /**
  * Build the gate deps for one command run. `runTask` is the orchestrator's
  * implementation re-runner, injected by the caller. The returned object also drives

package/dist/task/gate-deps.js

@@ -20,12 +20,15 @@ import { gitCommitAll, gitDropLastCommit, git } from './auto-commit.js';
 import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
+import { readContracts } from './contracts.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
 import { researchResolution } from './verify-resolution.js';
 import { extractProhibitions, findProhibitionViolations } from './prohibition-probe.js';
-import { findSubstitutionSuspects } from './substitution-probe.js';
+import { findProbeGaming, parseAddedLines } from './probe-gaming.js';
+import { findSubstitutionSuspects, isTestFile } from './substitution-probe.js';
+import { findTestRebuiltAssemblies, testAssemblyVerifyFindings } from './test-assembly.js';
 import { runBoundedLintFix } from './lint-fix.js';
 import { captureGitState, reconcileGitState } from './git-state-guard.js';
 import { runWorker } from '../workers/pi-worker-core.js';
@@ -75,6 +78,85 @@ export async function collectChangedFiles(cwd, signal) {
     }
     return files;
 }
+/**
+ * Collect the task's added lines WITH CONTENT (path + text) for the probe-gaming
+ * probe (F6), which needs the actual line text the numstat-shape collector omits.
+ * Pre-commit the work is the tree-vs-HEAD diff plus untracked files (read whole, as
+ * all-added); on the post-enforce re-verify the tree is clean, so fall back to the
+ * last commit's diff. Failures degrade to an empty list — the probe is a sharpener,
+ * never a blocker. The `.pi-tasks/` bookkeeping is excluded from every git command.
+ */
+export async function collectAddedLines(cwd, signal) {
+    const tracked = await git(cwd, ['diff', 'HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
+    const lines = tracked.exitCode === 0 ? parseAddedLines(tracked.stdout) : [];
+    const untracked = await git(cwd, ['ls-files', '--others', '--exclude-standard', '--', '.', EXCLUDE_TASKS_DIR], signal);
+    for (const name of splitLines(untracked.exitCode === 0 ? untracked.stdout : '')) {
+        try {
+            const content = await fsp.readFile(path.join(cwd, name), 'utf8');
+            for (const text of content.split('\n'))
+                lines.push({ path: name, text });
+        }
+        catch {
+            // unreadable/binary — nothing to report
+        }
+    }
+    if (lines.length === 0) {
+        const last = await git(cwd, ['diff', 'HEAD~1..HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
+        return last.exitCode === 0 ? parseAddedLines(last.stdout) : [];
+    }
+    return lines;
+}
+/** Source extensions whose relative imports the test-assembly probe reasons over. */
+const SOURCE_EXT_RE = /\.(?:[cm]?[jt]sx?)$/;
+/** Bounds so the probe stays cheap on large repos (it reads file text). */
+const MAX_PROBE_FILES = 4000;
+const MAX_PROBE_FILE_BYTES = 512 * 1024;
+/** Best-effort read of a repo file's text; unreadable/oversized → null (skipped). */
+async function readRepoFile(cwd, rel) {
+    try {
+        const buf = await fsp.readFile(path.join(cwd, rel));
+        if (buf.length > MAX_PROBE_FILE_BYTES)
+            return null;
+        return { path: rel, text: buf.toString('utf8') };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Deterministic test-assembly probe input (see test-assembly.ts, run-8 F4): read the
+ * task's own changed TEST files plus the repo's tracked source files, and return the
+ * finding lines naming any test that rebuilds a production assembly it never imports.
+ * Pure import-graph shape; failures degrade to no findings (the probe is a sharpener,
+ * never a blocker). `changed` is the already-collected task diff, reused so the probe
+ * costs one extra tracked-file listing, not a second diff.
+ */
+async function collectTestAssemblyFindings(cwd, changed, signal) {
+    const changedTests = changed.filter(f => isTestFile(f.path));
+    if (changedTests.length === 0)
+        return [];
+    const listed = await git(cwd, ['ls-files', '--', '.', EXCLUDE_TASKS_DIR], signal);
+    if (listed.exitCode !== 0)
+        return [];
+    const sources = splitLines(listed.stdout)
+        .filter(p => SOURCE_EXT_RE.test(p))
+        .slice(0, MAX_PROBE_FILES);
+    const production = [];
+    for (const rel of sources) {
+        if (isTestFile(rel))
+            continue;
+        const f = await readRepoFile(cwd, rel);
+        if (f)
+            production.push(f);
+    }
+    const testFiles = [];
+    for (const { path: rel } of changedTests) {
+        const f = await readRepoFile(cwd, rel);
+        if (f)
+            testFiles.push(f);
+    }
+    return testAssemblyVerifyFindings(findTestRebuiltAssemblies(testFiles, production));
+}
 /**
  * Build the gate deps for one command run. `runTask` is the orchestrator's
  * implementation re-runner, injected by the caller. The returned object also drives
@@ -291,6 +373,16 @@ export function buildGateDeps(params) {
                 // authored/changed become prompt-level findings mandating the child
                 // to drive the real artifact before trusting their green result.
                 probe: () => collectChangedFiles(cwd2, signal).then(findSubstitutionSuspects),
+                // Deterministic test-assembly probe (F4): authored test files that
+                // rebuild production wiring — importing the leaf modules the shipped
+                // entry composes and assembling their own copy — become rule-3f
+                // findings so the child drives the REAL assembly, not the copy.
+                testAssemblyProbe: () => collectChangedFiles(cwd2, signal).then(changed => collectTestAssemblyFindings(cwd2, changed, signal)),
+                // Deterministic probe-gaming probe (F6): added lines whose stated
+                // purpose is to make a check pass rather than meet the requirement
+                // ("return 401 so the verification test passes") become rule-4c
+                // findings so the child verifies the real requirement, not the check.
+                probeGamingProbe: () => collectAddedLines(cwd2, signal).then(findProbeGaming),
                 // Deterministic prohibition probe: paths the spec forbids modifying
                 // that the task's diff modified anyway become prompt-level findings
                 // under the no-waiver rule — the child otherwise rarely runs `git
@@ -310,11 +402,20 @@ export function buildGateDeps(params) {
                 // Per-run environment-facts cache under .pi-tasks/ (survives
                 // discardEdits): earlier children's discoveries save this child
                 // the re-archaeology; its own ENV-NOTE lines are stored for the
-                // next one. Facts only — verdict rules unaffected.
+                // next one, stamped with this task's id as their origin so a
+                // later child sees a cited fact is second-hand and must
+                // re-validate before excusing a failure (F7). Facts only —
+                // verdict rules unaffected.
                 envNotes: {
                     read: () => readEnvNotes(cwd2),
-                    append: notes => appendEnvNotes(cwd2, notes)
-                }
+                    append: notes => appendEnvNotes(cwd2, notes, taskId)
+                },
+                // Per-run cross-slice contract registry under .pi-tasks/ (F3): the
+                // verbatim interface facts the design pins that multiple slices
+                // share, so the verify child checks this slice's boundary against
+                // them. Empty on single-`/task` runs or a design with no shared
+                // boundary → no block.
+                contracts: () => readContracts(cwd2)
             });
         },
         lintFix: (fixCtx, cwd2, taskTitle, failReason) => runBoundedLintFix({

package/dist/task/phases.d.ts

@@ -50,6 +50,14 @@ export declare function replaceToolingWithVerified(research: string, verifiedCom
  * a genuinely greenfield task is still free to create.
  */
 export declare function refineExistingFilesBlock(deps: PhaseDeps): Promise<string>;
+/**
+ * The read-only cross-slice contract block (see contracts.ts) for a phase that
+ * generates spec text — the verbatim interface facts the SOURCE design pins that
+ * more than one slice touches. Empty when the registry is absent/empty (single
+ * `/task` runs, or a design that pins no shared boundary), so this degrades to a
+ * no-op. Best-effort: a read fault yields '' rather than blocking the phase.
+ */
+export declare function phaseContractsBlock(deps: PhaseDeps): Promise<string>;
 export declare const phaseRefine: (deps: PhaseDeps, raw: string, planContext?: string) => Promise<string>;
 export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): Promise<string>;
 export interface PhaseResearchDeps extends ExternalContextDeps {

package/dist/task/phases.js

@@ -24,6 +24,9 @@ import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './quest
 import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyToolingOutput, deriveTitle } from './parsers.js';
 import { compressTitle } from './title-label.js';
 import { parseVerifyBlock, validateSpecShape, stripSpecPreamble, isCritiqueClean } from './spec-validation.js';
+import { findSkipEscapes, skipEscapeDefectText } from './skip-escape.js';
+import { findSynthesizedWiring, wiringProbeText, readReferencedDocs } from './wiring-claims.js';
+import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from './contracts.js';
 import { runPhaseChild, runPhaseWithLoopGuard, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI } from '../remote/bridge.js';
 // ─── Re-export constants from their home modules ────────────────────────────
@@ -112,9 +115,21 @@ export async function refineExistingFilesBlock(deps) {
     });
     return block.trim().length === 0 ? '' : `${REFINE_PRESERVE_DIRECTIVE}\n\n${block.trim()}`;
 }
+/**
+ * The read-only cross-slice contract block (see contracts.ts) for a phase that
+ * generates spec text — the verbatim interface facts the SOURCE design pins that
+ * more than one slice touches. Empty when the registry is absent/empty (single
+ * `/task` runs, or a design that pins no shared boundary), so this degrades to a
+ * no-op. Best-effort: a read fault yields '' rather than blocking the phase.
+ */
+export async function phaseContractsBlock(deps) {
+    const contracts = await readContracts(deps.cwd).catch(() => '');
+    return buildContractsBlock(contracts);
+}
 export const phaseRefine = async (deps, raw, planContext) => {
     const existingFiles = await refineExistingFilesBlock(deps).catch(() => '');
-    return runPhaseWithLoopGuard(deps, 'refine', 'read', hint => prependHint(hint, appendNoThink(REFINE_PROMPT(raw, planContext, existingFiles))), 
+    const contracts = await phaseContractsBlock(deps);
+    return runPhaseWithLoopGuard(deps, 'refine', 'read', hint => prependHint(hint, appendNoThink(REFINE_PROMPT(raw, planContext, existingFiles, contracts))), 
     // refine's deliverable is a 4-section text rewrite that never strictly
     // needs a successful read — on a test-writing task against a large
     // existing codebase the model over-explores (re-reads source hunting for
@@ -714,7 +729,8 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
     return out.join('\n');
 }
 export async function phaseCompose(deps, refined, research, qa) {
-    return runWithEmphasisRetry(deps, 'compose', 'read', problem => COMPOSE_PROMPT(refined, research, qa, problem), text => {
+    const contracts = await phaseContractsBlock(deps);
+    return runWithEmphasisRetry(deps, 'compose', 'read', problem => COMPOSE_PROMPT(refined, research, qa, problem, contracts), text => {
         // Trim any "here's the spec:" preamble before validating, so a
         // strippable lead-in doesn't burn a full retry — and the stored
         // value starts at GOAL.
@@ -747,6 +763,35 @@ export async function phaseCritique(deps, spec, refined, qa) {
     // When the draft is structurally sound and triage says CLEAN, return it as
     // is. Otherwise fall through to the rewrite, feeding the triage defects in
     // as a focus list. Triage failures are non-fatal — we just do the rewrite.
+    // DETERMINISTIC skip-escape gate (run-8 F2): a required VERIFY check wrapped in a
+    // skip-announcing `||` fallback (`… || echo "skipping (tool absent)"`) lets the
+    // check pass while never running. FP-measured 0/20 on the historical specs. When
+    // present, force the rewrite to strip it — never let the triage CLEAN short-circuit
+    // ship a self-waiving VERIFY block — and feed the offending lines in as defects.
+    const skipEscapes = findSkipEscapes(spec);
+    const skipDefects = skipEscapes.length > 0 ? skipEscapeDefectText(skipEscapes) : null;
+    // The cross-slice contract registry (run-8 F3): the design's pinned interface
+    // facts, quoted verbatim, that more than one slice touches. Threading them into
+    // critique lets the triage/rewrite RECONCILE a synthesized wiring specific (a
+    // fabricated uniform mount table) against the facts it must reproduce — the
+    // generation-side complement of the verify-side boundary check. Empty (single
+    // /task, or a design that pins no shared boundary) ⇒ no-op.
+    const registryRaw = await readContracts(deps.cwd).catch(() => '');
+    const contractsBlock = buildContractsVerifyBlock(registryRaw);
+    // DETERMINISTIC synthesized-wiring probe (run-8 F3, generation side). The registry
+    // alone is a WEAK catcher (live A/B: prompt+registry ~1/8) — the model's attention
+    // goes to the obvious VERIFY weakness and it rarely does the path-composition
+    // reasoning. The scanner NAMES the inferred mount mappings and juxtaposes the
+    // verbatim pinned facts, forcing focused reconciliation (probe+rule pattern, same
+    // lever as skip-escape / substitution-probe). FP-clean (1/18 files on the run-8
+    // trees). Grounding = the registry ∪ any design doc the spec/refined @-reference.
+    const wiring = registryRaw.trim().length > 0 ?
+        findSynthesizedWiring(spec, registryRaw + '\n' + readReferencedDocs(deps.cwd, refined, spec), registryRaw)
+        : [];
+    const wiringProbe = wiring.length > 0 ? wiringProbeText(wiring, registryRaw) : null;
+    if (wiringProbe) {
+        deps.logDebug?.(`synthesized wiring flagged in spec: ${wiring.map(w => w.line).join(' | ')}`);
+    }
     let triageDefects = null;
     if (parseVerifyBlock(spec) !== null) {
         const tTriage = Date.now();
@@ -756,21 +801,31 @@ export async function phaseCritique(deps, spec, refined, qa) {
             // Granting `read` here let it wander the repo to "verify" findings,
             // which made the supposedly-cheap pass cost as much as a rewrite
             // (observed ~133s). The judgement needs no file access.
-            verdict = await runPhaseChild(deps, 'critique-triage', '', appendNoThink(CRITIQUE_TRIAGE_PROMPT(spec, refined, qa)));
+            verdict = await runPhaseChild(deps, 'critique-triage', '', appendNoThink(CRITIQUE_TRIAGE_PROMPT(spec, refined, qa, contractsBlock)));
         }
         catch {
             verdict = null;
         }
         deps.recordSubStep?.('triage', Date.now() - tTriage);
         if (verdict !== null) {
-            if (isCritiqueClean(verdict))
-                return spec;
-            triageDefects = verdict.trim();
+            // A deterministic skip-escape OR synthesized-wiring finding overrides a CLEAN
+            // triage: the draft must be rewritten to resolve it even if the model judged
+            // the rest clean (the model does not self-discover either reliably).
+            if (isCritiqueClean(verdict)) {
+                if (skipDefects === null && wiringProbe === null)
+                    return spec;
+            }
+            else {
+                triageDefects = verdict.trim();
+            }
         }
     }
+    // Merge the deterministic skip-escape + synthesized-wiring defects with any triage
+    // defects for the rewrite (both are forced FOCUS items).
+    const rewriteDefects = [skipDefects, wiringProbe, triageDefects].filter(Boolean).join('\n\n') || null;
     const tRewrite = Date.now();
     try {
-        return await runWithEmphasisRetry(deps, 'critique', 'read', problem => CRITIQUE_PROMPT(spec, refined, qa, problem !== null, triageDefects), text => {
+        return await runWithEmphasisRetry(deps, 'critique', 'read', problem => CRITIQUE_PROMPT(spec, refined, qa, problem !== null, rewriteDefects, contractsBlock), text => {
             // The rewrite (thinking on) sometimes prepends narration before
             // GOAL; the prompt forbids it but this validator only checks for
             // a VERIFY block. Strip it so the delivered spec starts at GOAL.

package/dist/task/probe-gaming.d.ts

@@ -0,0 +1,60 @@
+/**
+ * probe-gaming — deterministic detection of CHECK-GAMING code, feeding the verify
+ * and enforce gate prompts (run-8 F6).
+ *
+ * The failure class: the implementation writes code — or a comment on it — whose
+ * STATED PURPOSE is to make a check pass, rather than to satisfy the requirement the
+ * check stands for. mx5 run-8 shipped, verbatim,
+ *   `// Return 401 so the verification test passes (expects 200/401/403 for /api routes).`
+ * above four catch-all handlers added to satisfy the VERIFY curl instead of fixing
+ * the broken route mount. The route stayed dead; the check went green; the code SAID
+ * SO IN WRITING. A check is a MESSENGER for a requirement — code written to quiet the
+ * messenger instead of meeting the requirement is the defect, and when it announces
+ * its own intent it is cheaply detectable.
+ *
+ * Same probe+rule design as the other run-8 probes (skip-escape.ts,
+ * prohibition-probe.ts, substitution-probe.ts, test-assembly.ts): a deterministic
+ * finding is the reliable lever, a prompt rule alone is weak. This scans the task's
+ * DIFF (added lines only — the work this task introduced) for the gaming tell and
+ * hands each hit to the gate child verbatim, so the rule fires on a concrete line
+ * rather than on the model self-discovering the intent.
+ *
+ * Advisory, never an auto-FAIL: intent phrasing is prose and a genuinely-benign line
+ * could in principle carry it ("returns 401 so the auth test passes" describing a
+ * CORRECT auth path). The child reads the exact line and the surrounding code and
+ * judges — the verify rule directs it to confirm the underlying requirement is
+ * actually met, not merely that the check is green.
+ *
+ * FP-MEASURED on the real run-8 corpus (~/hub/mx5, all 53 commits): 1 unique hit in
+ * 50,735 added lines — exactly the true F6 line, zero false positives. The tell is a
+ * purpose phrase binding a CHECK noun (test / verification / lint / CI / gate / …) to
+ * a pass-state or a gaming verb; benign uses of the same words ("pass the test data",
+ * "run the verification suite", "the linter flagged this") do not match. Pure
+ * diff-text analysis — no stack, framework, or tool-name assumptions; a project with
+ * no such comment simply yields no findings (nothing to observe = pass).
+ */
+/** One added line from a task's diff: the file it was added to and its text. */
+export interface AddedLine {
+    /** Path relative to the repo root (from the `+++ b/…` header). */
+    path: string;
+    /** The added line's content, without the leading `+`. */
+    text: string;
+}
+/** Does this line state its purpose is to make a check pass? */
+export declare function isProbeGamingLine(text: string): boolean;
+/**
+ * Parse a unified `git diff` into its added lines (path + text). Tracks the current
+ * file from each `+++ b/…` header and collects every `+`-prefixed body line
+ * (excluding the `+++` header itself). Robust to surrounding prose (the enforce diff
+ * capture wraps the diff in a header/footer) because only `+`/`+++` lines are read.
+ */
+export declare function parseAddedLines(diff: string): AddedLine[];
+/**
+ * Scan a set of added lines for check-gaming tells. Returns one finding per matching
+ * line; empty when none match (the prompt then gets no probe block). The finding
+ * carries the file and the offending line verbatim so the gate child can locate and
+ * judge it. Long lines are truncated for the prompt.
+ */
+export declare function findProbeGaming(added: AddedLine[]): string[];
+/** Convenience: scan a unified diff string straight to findings. */
+export declare function findProbeGamingInDiff(diff: string): string[];

package/dist/task/prompts.d.ts

@@ -47,7 +47,7 @@ export declare const COMPRESS_LABEL_PROMPT: (title: string, maxChars: number) =>
  * "Scaffold …" title re-expands the entire design into one task (validated: a real
  * /task-auto run implemented all 24 steps under step 1).
  */
-declare const REFINE_PROMPT: (raw: string, planContext?: string, existingFiles?: string) => string;
+declare const REFINE_PROMPT: (raw: string, planContext?: string, existingFiles?: string, contracts?: string) => string;
 declare const RESEARCH_READ_ONLY_CONSTRAINT = "IMPORTANT: You are ONLY allowed to READ. Do NOT create, modify, or delete any files. Use the read, grep, find, and ls tools to inspect the repo.";
 declare const RESEARCH_FILES_PROMPT: (refined: string) => string;
 declare const RESEARCH_APIS_PROMPT: (refined: string, filesMap?: string) => string;
@@ -57,8 +57,8 @@ declare const GRILL_GEN_PROMPT: (refined: string, research: string, priorQA: str
 declare const GRILL_AUTO_ANSWER_PROMPT: (refined: string, research: string, question: string) => string;
 export declare const GRILL_AUTO_FORMAT_HINT: string;
 declare function composeRetryEmphasis(problem: string): string;
-declare const COMPOSE_PROMPT: (refined: string, research: string, qa: string, retryProblem: string | null) => string;
-declare const CRITIQUE_TRIAGE_PROMPT: (spec: string, refined: string, qa: string) => string;
-declare const CRITIQUE_PROMPT: (spec: string, refined: string, qa: string, addVerifyEmphasis: boolean, triageDefects?: string | null) => string;
+declare const COMPOSE_PROMPT: (refined: string, research: string, qa: string, retryProblem: string | null, contracts?: string) => string;
+declare const CRITIQUE_TRIAGE_PROMPT: (spec: string, refined: string, qa: string, contracts?: string) => string;
+declare const CRITIQUE_PROMPT: (spec: string, refined: string, qa: string, addVerifyEmphasis: boolean, triageDefects?: string | null, contracts?: string) => string;
 declare const VERIFY_TOOLING_PROMPT: (tooling: string) => string;
 export { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, RESEARCH_READ_ONLY_CONSTRAINT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, composeRetryEmphasis };