@mjasnikovs/pi-task 0.18.2 → 0.18.4

package/dist/task/prompts.js

@@ -61,7 +61,7 @@ ${title}`;
  * "Scaffold …" title re-expands the entire design into one task (validated: a real
  * /task-auto run implemented all 24 steps under step 1).
  */
-const REFINE_PROMPT = (raw, planContext, existingFiles) => `${planContext ? planContext + '\n\n---\n\n' : ''}You receive a user's task description for an AI coding agent. Rewrite it to be unambiguous and actionable.
+const REFINE_PROMPT = (raw, planContext, existingFiles, contracts) => `${planContext ? planContext + '\n\n---\n\n' : ''}You receive a user's task description for an AI coding agent. Rewrite it to be unambiguous and actionable.
 
 Output structure (four sections, exact headings, in this order):
 
@@ -86,8 +86,9 @@ Rules:
 - Preserve every concrete identifier verbatim (paths, function names, ports, env vars, file:line refs).
 - Do not invent requirements not implied by the input.
 - If the task references a design/spec document (an @-path or a named spec file), READ it and treat it as authoritative. Carry its concrete schema verbatim into GOAL/CONSTRAINTS — table and column names, types, endpoint methods and paths, enum values. The task title is only a pointer into that spec: where the title and the spec disagree, follow the spec, and never introduce a table, column, endpoint, or dependency the spec does not define.
+- CITE interface WIRING, do NOT synthesize it. A wiring specific — how modules/endpoints/files connect (a mount prefix, a route/mount table, a module→path mapping, an exported function/type signature, a file or module layout) — must be citable from the design or the CROSS-SLICE CONTRACTS. The design often pins the interface FACTS (the exact endpoint paths, exported names, layouts) WITHOUT stating the wiring that produces them; when it does, any wiring you write MUST reproduce those pinned facts EXACTLY. Do NOT infer a "uniform" or "tidy" pattern from them — e.g. do not assume one module maps to one mount prefix when the design's pinned facts for that module do not all sit under a single prefix (that exact inference is a seam bug: the consumers follow the pinned facts, the assembly follows your invented pattern, and the seam ships broken). If the design pins neither the fact nor the wiring, leave the detail unspecified rather than inventing a specific.
 - Do not output any preamble, commentary, or markdown headings beyond the four sections above.
-${existingFiles && existingFiles.trim() ? `\n${existingFiles.trim()}\n` : ''}
+${contracts && contracts.trim() ? `\n${contracts.trim()}\n` : ''}${existingFiles && existingFiles.trim() ? `\n${existingFiles.trim()}\n` : ''}
 Task: ${raw}`;
 // ─── Research fan-out prompts ─────────────────────────────────────────────────
 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.`;
@@ -288,7 +289,7 @@ function composeRetryEmphasis(problem) {
     }
     return `\nPREVIOUS ATTEMPT was invalid (${problem}). Ensure all four sections are present and the output starts with the literal word GOAL.\n`;
 }
-const COMPOSE_PROMPT = (refined, research, qa, retryProblem) => `You are composing the final implementation spec for an AI coding agent. Combine the refined task, the research, and the user's Q&A answers into one spec.
+const COMPOSE_PROMPT = (refined, research, qa, retryProblem, contracts) => `You are composing the final implementation spec for an AI coding agent. Combine the refined task, the research, and the user's Q&A answers into one spec.
 
 CRITICAL FORMAT RULES (read first):
 - Output the spec as plain markdown text. Do NOT wrap your entire output in a code block, shell fence, or heredoc. Do NOT prefix with \`\`\`sh / \`\`\`bash. Do NOT use \`cat << EOF > file\` patterns. Your response begins literally with "GOAL" on the first line.
@@ -334,14 +335,15 @@ Research:
 ${research}
 
 User Q&A:
-${qa}`;
+${qa}
+${contracts && contracts.trim() ? `\n${contracts.trim()}\n` : ''}`;
 // Fast triage pass run before the (expensive) full rewrite. It produces either
 // the single token CLEAN — meaning the compose draft needs no rewrite — or a
 // short defect list. When CLEAN, the orchestrator returns the draft unchanged
 // and skips the rewrite entirely; otherwise the defects are fed into
 // CRITIQUE_PROMPT as a focus list so the rewrite targets real problems instead
 // of re-deriving them from scratch.
-const CRITIQUE_TRIAGE_PROMPT = (spec, refined, qa) => `You are triaging an implementation spec for an AI coding agent. Decide whether it needs a rewrite. Do NOT rewrite it — only judge it.
+const CRITIQUE_TRIAGE_PROMPT = (spec, refined, qa, contracts) => `You are triaging an implementation spec for an AI coding agent. Decide whether it needs a rewrite. Do NOT rewrite it — only judge it.
 
 The refined task and the user's Q&A below are GROUND TRUTH. Judge the spec against them. Look for SUBSTANTIVE defects only:
 - ambiguity that would let the agent build the wrong thing
@@ -349,7 +351,8 @@ The refined task and the user's Q&A below are GROUND TRUTH. Judge the spec again
 - a VERIFY block that is missing, unrunnable, full of placeholders, or does not exercise the surface the task touches
 - scope drift: requirements, files, or deliverables not implied by the refined task or Q&A
 - a dropped or weakened CONSTRAINT from the refined task
-
+- a synthesized interface WIRING specific — a mount/route table, a module→path mapping, an exported signature, a file layout — that the design does not pin AND that does not reproduce the design's pinned interface facts. A "uniform" pattern (one module → one mount prefix, etc.) applied to an interface whose pinned facts are NOT uniform is a SEAM BUG: flag it naming the pinned fact it contradicts.
+${contracts && contracts.trim() ? `\n${contracts.trim()}\n` : ''}
 Do NOT flag cosmetic wording, style, or anything you would change only to "polish" prose. The bar is: would this defect change what the agent builds or whether the work can be verified?
 
 Output format — read carefully:
@@ -364,7 +367,7 @@ ${qa}
 
 Spec to triage:
 ${spec}`;
-const CRITIQUE_PROMPT = (spec, refined, qa, addVerifyEmphasis, triageDefects = null) => `You are reviewing the implementation spec below for ambiguity, weak acceptance criteria, and missing or unrunnable VERIFY commands.
+const CRITIQUE_PROMPT = (spec, refined, qa, addVerifyEmphasis, triageDefects = null, contracts) => `You are reviewing the implementation spec below for ambiguity, weak acceptance criteria, and missing or unrunnable VERIFY commands.
 
 CRITICAL FORMAT RULES (read first):
 - Output the rewritten spec as plain markdown. Do NOT wrap your entire output in a code block, shell fence, or heredoc. Do NOT prefix with \`\`\`sh / \`\`\`bash. Do NOT use \`cat << EOF > file\` patterns. Your response begins literally with "GOAL" on the first line.
@@ -378,6 +381,7 @@ SCOPE RULES (equally critical — do not break these):
 - CONSTRAINTS from the refined task MUST be preserved in spirit. Do not silently drop or weaken them.
 - If the spec below is malformed, empty, or wrapped in a heredoc, reconstruct it from the refined task and Q&A — not from your own invention.
 - Your job is to tighten language, sharpen acceptance criteria, and ensure VERIFY is runnable. Not to redesign the task.
+- WIRING vs pinned facts: if the spec states interface wiring (a mount/route table, a module→path mapping, an exported signature, a file layout), reconcile EACH wiring specific against the design's pinned interface facts (the CROSS-SLICE CONTRACTS below, if present, are those facts quoted verbatim). Keep every wiring specific that reproduces the pinned facts exactly; CORRECT any that do not; and do NOT invent wiring the design leaves unspecified. Watch specifically for a "uniform" pattern (one module → one mount prefix, one naming scheme) applied to an interface whose pinned facts are NOT uniform — that is a seam bug, fix only the entry that breaks, and leave the conforming entries unchanged.
 
 Rewrite the spec in the same four-section format (GOAL, CONSTRAINTS, ACCEPTANCE, VERIFY). Fix any issues you find within the scope rules above.
 
@@ -390,6 +394,7 @@ VERIFY QUALITY CHECK (apply during the rewrite):
 - Never accept \`true\`, \`echo ok\`, or other no-op commands as VERIFY content.
 
 ${addVerifyEmphasis ? 'REQUIRED: The output MUST include a VERIFY: section followed by a ```sh fenced block of runnable shell commands. The previous attempt was missing this.' : ''}
+${contracts && contracts.trim() ? `\n${contracts.trim()}\n` : ''}
 ${triageDefects ?
     `FOCUS — a triage pass already found these specific defects. Fix every one of them in your rewrite (without breaking the scope rules above):\n${triageDefects}\n`
     : ''}

package/dist/task/skip-escape.d.ts

@@ -0,0 +1,25 @@
+export interface SkipEscapeFinding {
+    /** The offending VERIFY command line, verbatim. */
+    line: string;
+    /** Why it is a skip-escape (human- and prompt-readable). */
+    reason: string;
+}
+/**
+ * Scan a composed spec's VERIFY block for skip-announcing escapes. Returns one
+ * finding per offending command line; empty when the spec has no VERIFY block or
+ * no skip-escapes. Comment/blank lines are already dropped by parseVerifyBlock.
+ */
+export declare function findSkipEscapes(spec: string): SkipEscapeFinding[];
+/**
+ * Render skip-escape findings as a defect block for the critique rewrite: a
+ * numbered instruction list the rewrite must resolve (remove the escape / run the
+ * check unconditionally, or drop the check if it is genuinely not required).
+ */
+export declare function skipEscapeDefectText(findings: SkipEscapeFinding[]): string;
+/**
+ * Render skip-escape findings as verify-child prompt lines (the deterministic
+ * finding that makes rule 5c fire reliably — the model does not self-discover a
+ * graceful skip-escape, but acts on a finding that names the exact line). Empty
+ * findings → empty array (caller emits no block).
+ */
+export declare function skipEscapeVerifyFindings(findings: SkipEscapeFinding[]): string[];

package/dist/task/skip-escape.js

@@ -0,0 +1,80 @@
+/**
+ * Deterministic skip-escape scanner for authored VERIFY blocks (run-8 F2).
+ *
+ * A skip-escape is a `||` fallback that lets a REQUIRED check pass SILENTLY when
+ * its tool is absent or it fails — e.g. `playwright test … || echo "skipping"`.
+ * mx5 run-8 shipped a blank/dead app partly because its only behavioral smoke
+ * tests were wrapped this way: the tool was absent, the check silently skipped,
+ * and the verify child blessed it as "correctly skipped".
+ *
+ * FP-MEASURED on the historical VERIFY blocks (~/hub/mx5/.pi-tasks, 22 tasks): a
+ * blanket `|| true` flag is ~90% false positives — teardown (`kill … || true`,
+ * `docker compose down … || true`), setup (`… install … || true`), and negative
+ * tests (`… && exit 1 || true`, where `|| true` catches an EXPECTED failure). Of
+ * 45 `||` uses, exactly one was the real F2 skip-escape, and it ANNOUNCED the skip
+ * ("Playwright not available — skipping browser smoke test"). So the crisp,
+ * ~zero-FP signal is a fallback whose text ADMITS it is dodging the check — that is
+ * the actionable finding here. Bare `|| true` is left to the verify child's runtime
+ * rule 5c, which can actually observe whether the check ran (a static scan cannot
+ * tell a required-check `|| true` from a teardown `|| true`).
+ *
+ * Pure shell-shape / text analysis; no stack or tool-name assumptions.
+ */
+import { parseVerifyBlock } from './spec-validation.js';
+/**
+ * A `||` (optionally after a `2>/dev/null`) whose fallback text ADMITS it is
+ * skipping / that a tool is unavailable. Anchored on the fallback wording, so it
+ * fires on `|| echo "skipping"`, `|| { echo "playwright not installed"; }`,
+ * `|| echo "runner unavailable — skipped"`, and misses benign teardown `|| true`.
+ */
+const SKIP_ANNOUNCE_RE = /\|\|[^|]*\b(skip|skipping|skipped|not\s+installed|not\s+available|unavailable)\b/i;
+/**
+ * Scan a composed spec's VERIFY block for skip-announcing escapes. Returns one
+ * finding per offending command line; empty when the spec has no VERIFY block or
+ * no skip-escapes. Comment/blank lines are already dropped by parseVerifyBlock.
+ */
+export function findSkipEscapes(spec) {
+    const cmds = parseVerifyBlock(spec);
+    if (!cmds)
+        return [];
+    const found = [];
+    for (const { raw } of cmds) {
+        if (SKIP_ANNOUNCE_RE.test(raw)) {
+            found.push({
+                line: raw,
+                reason: 'its `||` fallback announces skipping the check when a tool is absent — a '
+                    + 'required check must run unconditionally, not self-waive into a silent pass'
+            });
+        }
+    }
+    return found;
+}
+/**
+ * Render skip-escape findings as a defect block for the critique rewrite: a
+ * numbered instruction list the rewrite must resolve (remove the escape / run the
+ * check unconditionally, or drop the check if it is genuinely not required).
+ */
+export function skipEscapeDefectText(findings) {
+    return [
+        'SKIP-ESCAPE in the VERIFY block — a required check is wrapped so that a missing',
+        'tool or a failure passes SILENTLY (run-8 F2: the only smoke tests shipped this',
+        'way, skipped unnoticed, and a blank app was blessed). Rewrite the VERIFY block so',
+        'each of these checks RUNS UNCONDITIONALLY and its failure fails the block — remove',
+        'the `|| echo skipping`-style fallback. PREFER a check that needs no special tool at',
+        'all (start the artifact and probe its real behavior directly). Do NOT merely reshape',
+        'the escape into a `command -v X`/`if`-guard that still skips silently when the tool',
+        'is absent — that is the same defect: if the check truly needs a tool, its absence',
+        'must make the block EXIT NON-ZERO (surface it), never exit 0. If a check genuinely',
+        'cannot be required here, remove it entirely rather than leaving a self-waiving stub:',
+        ...findings.map((f, i) => `  ${i + 1}. ${f.line}`)
+    ].join('\n');
+}
+/**
+ * Render skip-escape findings as verify-child prompt lines (the deterministic
+ * finding that makes rule 5c fire reliably — the model does not self-discover a
+ * graceful skip-escape, but acts on a finding that names the exact line). Empty
+ * findings → empty array (caller emits no block).
+ */
+export function skipEscapeVerifyFindings(findings) {
+    return findings.map(f => `${f.line} — ${f.reason}`);
+}

package/dist/task/task-gates.js

@@ -96,17 +96,29 @@ export async function runGatesForTask(ctxIn, deps, p) {
                     continue;
                 }
             }
-            const recOutcome = deps.recommend ?
-                await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
-                : { recommend: 'autofix', rationale: failReason };
-            await rec(`resolution: recommended ${recOutcome.recommend.toUpperCase()}`);
+            // UNOBSERVED (rule 5c): a spec-required behavioral check could not run because
+            // its observation tooling is absent. An unattended AUTOFIX re-run cannot install
+            // a missing tool, so it would only burn MAX_AUTO_AUTOFIX turns and re-FAIL — the
+            // decision (provision the tool, or accept the unproven behavior) is the human's.
+            // Skip the (moot) recommendation research and force the picker.
+            const isUnobserved = verified.unobserved === true;
+            const recOutcome = isUnobserved ? { recommend: 'autofix', rationale: failReason }
+                : deps.recommend ?
+                    await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
+                    : { recommend: 'autofix', rationale: failReason };
+            await rec(isUnobserved ?
+                'resolution: verify UNOBSERVED — spec-required check could not run (tooling absent); '
+                    + 'forcing the human picker, an unattended re-run cannot provision it'
+                : `resolution: recommended ${recOutcome.recommend.toUpperCase()}`);
             // AUTO-RESOLVE the AUTOFIX path: when the research says the work is
             // genuinely wrong, re-run the fix WITHOUT prompting the user. The picker is
             // reserved for the ACCEPT recommendation (the human decides whether to bless
             // an artifact the gate FAILed) and for the bounded fallback: after
             // MAX_AUTO_AUTOFIX consecutive unattended attempts that still FAIL, hand
             // control back so a person can break a non-converging loop.
-            const autoFixNow = recOutcome.recommend === 'autofix' && autoFixCount < MAX_AUTO_AUTOFIX;
+            const autoFixNow = !isUnobserved
+                && recOutcome.recommend === 'autofix'
+                && autoFixCount < MAX_AUTO_AUTOFIX;
             let choice;
             if (autoFixNow) {
                 autoFixCount += 1;

package/dist/task/test-assembly.d.ts

@@ -0,0 +1,87 @@
+/**
+ * test-assembly — deterministic detection of TEST-REBUILT PRODUCTION WIRING, feeding
+ * the verify gate's prompt (run-8 F4; third recurrence of the test-the-copy class,
+ * runs 3, 4, 8).
+ *
+ * The failure class: a test file re-constructs wiring that ALSO exists in production
+ * — it builds its own app assembly / its own entry point out of the same leaf modules
+ * the production entry composes, then tests THAT private copy. The copy can be wired
+ * differently from production and stay green while the shipped wiring is broken. Run-8
+ * fixture: `test/photos.test.ts` imports the real `authRoutes` + `photosRoutes` leaves,
+ * mounts them into its OWN app at a DIFFERENT prefix than the production entry, and
+ * runs 102/102 green — while the shipped upload path is dead because production mounts
+ * the same leaf at the wrong prefix. The verify child, judging "do the tests pass",
+ * saw green and counted the photos area verified. The seam the test was supposed to
+ * cover is exactly the seam it re-implemented away.
+ *
+ * This is the VERIFY-SIDE complement of the generation-side wiring probe
+ * (wiring-claims.ts, item #5) and shares the load-bearing lesson of
+ * substitution-probe / skip-escape / wiring-claims: a deterministic finding that NAMES
+ * the suspect file is the reliable lever; a bare prompt rule is weak. rule 3b already
+ * tells the child to spot-check that self-authored tests exercise the real artifact,
+ * but F4 slips through because these tests DO import the real leaf modules — they just
+ * bypass the real ASSEMBLY, which rule 3b's "did it import and call the module" check
+ * does not catch. This probe supplies the missing concrete fact.
+ *
+ * THE SIGNAL is pure import-graph SHAPE, zero stack/framework assumptions (no "app",
+ * no "route", no "mount", no language runtime): a test file T is flagged when there is
+ * a production file E (the assembly/entry) such that
+ *   - T does NOT import E (it bypasses the shipped assembly), AND
+ *   - T and E both import ≥2 of the SAME leaf modules, where each such leaf is
+ *     imported by E and by NO OTHER production file (E is the leaf's SOLE production
+ *     composition site).
+ * The "E-exclusive leaf" condition is the crisp discriminator that keeps ordinary
+ * shared-utility imports out: a test importing an api client + a schema module that
+ * every page also imports is NOT re-assembly (those utilities have many production
+ * importers); a test importing two route modules that only the server entry composes
+ * IS re-assembly. Measured on the run-8 fixture tree: flags exactly the four backend
+ * tests that rebuild the server entry's route composition (including the real
+ * photos seam bug) and leaves clean the single-leaf direct test, the utility-sharing
+ * page test, and the source-grepping test — 0 false positives.
+ *
+ * Findings are ADVISORY (probe+rule): they mandate the child to exercise the REAL
+ * shipped assembly directly before counting the area verified; they never auto-FAIL.
+ * A test that re-composes wiring which happens to match production survives once the
+ * child drives the real entry; only one whose real assembly is broken gets named.
+ */
+/** A source file the probe reasons over: repo-relative path + its full text. */
+export interface RepoFile {
+    /** Path relative to the repo root (used verbatim in the finding text). */
+    path: string;
+    /** Full file contents (import statements are parsed out of it). */
+    text: string;
+}
+/** One test file that rebuilds a production assembly instead of importing it. */
+export interface TestAssemblyFinding {
+    /** The test file re-constructing the wiring. */
+    testFile: string;
+    /** The production assembly / entry it bypasses (sole composer of the leaves). */
+    assemblyFile: string;
+    /** The leaf modules (repo-relative, extensionless) the test re-composes. */
+    leaves: string[];
+}
+/** The importing file's OWN module id (path minus extension / `/index`). */
+export declare function moduleIdOf(filePath: string): string;
+/**
+ * The set of repo-relative, extensionless module ids that `text` imports via RELATIVE
+ * specifiers (a specifier starting with `.`). Bare/external specifiers (`hono`,
+ * `bun:sql`, `node:fs`) are ignored — they never name a repo file, so they cannot be
+ * a re-composed production leaf. Resolution is pure path arithmetic against the
+ * importer's directory; the filesystem is never touched.
+ */
+export declare function relativeImports(filePath: string, text: string): string[];
+/**
+ * Find test files that rebuild a production assembly. `changedTestFiles` are the
+ * task's own authored/changed test files (path + text); `productionFiles` are the
+ * repo's non-test source files (path + text) used to build the import graph and the
+ * per-leaf production in-degree. Returns one finding per re-assembling test, sorted
+ * for determinism. Empty when no test re-composes an E-exclusive leaf set.
+ */
+export declare function findTestRebuiltAssemblies(changedTestFiles: RepoFile[], productionFiles: RepoFile[]): TestAssemblyFinding[];
+/**
+ * Render findings as verify-child prompt lines (probe+rule pattern — the concrete
+ * finding that makes the rule fire reliably). One line per re-assembling test naming
+ * the test, the shipped assembly it bypasses, and the re-composed leaves. Empty
+ * findings → empty array (caller emits no block).
+ */
+export declare function testAssemblyVerifyFindings(findings: TestAssemblyFinding[]): string[];

package/dist/task/test-assembly.js

@@ -0,0 +1,163 @@
+/**
+ * test-assembly — deterministic detection of TEST-REBUILT PRODUCTION WIRING, feeding
+ * the verify gate's prompt (run-8 F4; third recurrence of the test-the-copy class,
+ * runs 3, 4, 8).
+ *
+ * The failure class: a test file re-constructs wiring that ALSO exists in production
+ * — it builds its own app assembly / its own entry point out of the same leaf modules
+ * the production entry composes, then tests THAT private copy. The copy can be wired
+ * differently from production and stay green while the shipped wiring is broken. Run-8
+ * fixture: `test/photos.test.ts` imports the real `authRoutes` + `photosRoutes` leaves,
+ * mounts them into its OWN app at a DIFFERENT prefix than the production entry, and
+ * runs 102/102 green — while the shipped upload path is dead because production mounts
+ * the same leaf at the wrong prefix. The verify child, judging "do the tests pass",
+ * saw green and counted the photos area verified. The seam the test was supposed to
+ * cover is exactly the seam it re-implemented away.
+ *
+ * This is the VERIFY-SIDE complement of the generation-side wiring probe
+ * (wiring-claims.ts, item #5) and shares the load-bearing lesson of
+ * substitution-probe / skip-escape / wiring-claims: a deterministic finding that NAMES
+ * the suspect file is the reliable lever; a bare prompt rule is weak. rule 3b already
+ * tells the child to spot-check that self-authored tests exercise the real artifact,
+ * but F4 slips through because these tests DO import the real leaf modules — they just
+ * bypass the real ASSEMBLY, which rule 3b's "did it import and call the module" check
+ * does not catch. This probe supplies the missing concrete fact.
+ *
+ * THE SIGNAL is pure import-graph SHAPE, zero stack/framework assumptions (no "app",
+ * no "route", no "mount", no language runtime): a test file T is flagged when there is
+ * a production file E (the assembly/entry) such that
+ *   - T does NOT import E (it bypasses the shipped assembly), AND
+ *   - T and E both import ≥2 of the SAME leaf modules, where each such leaf is
+ *     imported by E and by NO OTHER production file (E is the leaf's SOLE production
+ *     composition site).
+ * The "E-exclusive leaf" condition is the crisp discriminator that keeps ordinary
+ * shared-utility imports out: a test importing an api client + a schema module that
+ * every page also imports is NOT re-assembly (those utilities have many production
+ * importers); a test importing two route modules that only the server entry composes
+ * IS re-assembly. Measured on the run-8 fixture tree: flags exactly the four backend
+ * tests that rebuild the server entry's route composition (including the real
+ * photos seam bug) and leaves clean the single-leaf direct test, the utility-sharing
+ * page test, and the source-grepping test — 0 false positives.
+ *
+ * Findings are ADVISORY (probe+rule): they mandate the child to exercise the REAL
+ * shipped assembly directly before counting the area verified; they never auto-FAIL.
+ * A test that re-composes wiring which happens to match production survives once the
+ * child drives the real entry; only one whose real assembly is broken gets named.
+ */
+import { isTestFile } from './substitution-probe.js';
+/** Code file extensions whose relative imports we resolve. Not a stack assumption —
+ *  purely which quoted specifiers name a repo file; other languages simply produce
+ *  no matches and the whole probe degrades to nothing. */
+const CODE_EXT_RE = /\.(?:[cm]?[jt]sx?)$/;
+/**
+ * Static import/re-export declarations: `import … from 'x'`, `import 'x'`,
+ * `export … from 'x'`. Anchored to line start (after optional whitespace) so an
+ * import-shaped STRING inside an assertion (`expect(src).toContain("import x from
+ * '../y'")`, a source-grepping test) is NOT mistaken for a real import — that string
+ * is indented behind `expect(`, never at line start.
+ */
+const STATIC_IMPORT_RE = /^[ \t]*(?:import|export)\s+(?:[^'"\n]*\sfrom\s+)?['"]([^'"]+)['"]/gm;
+/** Dynamic `import('x')` / `require('x')` calls (the call-paren form is unlikely to
+ *  appear inside an assertion string, so matching anywhere is safe enough). */
+const CALL_IMPORT_RE = /(?:require|import)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+/** Strip a code extension and a trailing `/index` so `./a`, `./a.ts`, and
+ *  `./a/index.ts` all collapse to the same module id. */
+function stripToModuleId(p) {
+    return p.replace(CODE_EXT_RE, '').replace(/\/index$/, '');
+}
+/** Normalise a POSIX-style relative path (resolve `.`/`..` segments) without touching
+ *  the filesystem — the analysis is pure text shape. */
+function normalisePosix(p) {
+    const segments = [];
+    for (const seg of p.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..')
+            segments.pop();
+        else
+            segments.push(seg);
+    }
+    return segments.join('/');
+}
+/** The importing file's OWN module id (path minus extension / `/index`). */
+export function moduleIdOf(filePath) {
+    return stripToModuleId(filePath);
+}
+/**
+ * The set of repo-relative, extensionless module ids that `text` imports via RELATIVE
+ * specifiers (a specifier starting with `.`). Bare/external specifiers (`hono`,
+ * `bun:sql`, `node:fs`) are ignored — they never name a repo file, so they cannot be
+ * a re-composed production leaf. Resolution is pure path arithmetic against the
+ * importer's directory; the filesystem is never touched.
+ */
+export function relativeImports(filePath, text) {
+    const dir = filePath.includes('/') ? filePath.slice(0, filePath.lastIndexOf('/')) : '';
+    const ids = new Set();
+    for (const re of [STATIC_IMPORT_RE, CALL_IMPORT_RE]) {
+        re.lastIndex = 0;
+        for (let m = re.exec(text); m !== null; m = re.exec(text)) {
+            const spec = m[1];
+            if (!spec.startsWith('.'))
+                continue;
+            ids.add(stripToModuleId(normalisePosix(`${dir}/${spec}`)));
+        }
+    }
+    return [...ids];
+}
+/**
+ * Find test files that rebuild a production assembly. `changedTestFiles` are the
+ * task's own authored/changed test files (path + text); `productionFiles` are the
+ * repo's non-test source files (path + text) used to build the import graph and the
+ * per-leaf production in-degree. Returns one finding per re-assembling test, sorted
+ * for determinism. Empty when no test re-composes an E-exclusive leaf set.
+ */
+export function findTestRebuiltAssemblies(changedTestFiles, productionFiles) {
+    // Only genuine production (non-test) files can be the bypassed assembly.
+    const prod = productionFiles.filter(f => !isTestFile(f.path));
+    const prodImports = new Map();
+    const inDegree = new Map();
+    for (const f of prod) {
+        const imps = relativeImports(f.path, f.text);
+        prodImports.set(f.path, new Set(imps));
+        for (const m of imps)
+            inDegree.set(m, (inDegree.get(m) ?? 0) + 1);
+    }
+    const findings = [];
+    for (const t of [...changedTestFiles].sort((a, b) => a.path.localeCompare(b.path))) {
+        if (!isTestFile(t.path))
+            continue;
+        const tImports = new Set(relativeImports(t.path, t.text));
+        if (tImports.size < 2)
+            continue;
+        let best = null;
+        for (const e of [...prod].sort((a, b) => a.path.localeCompare(b.path))) {
+            if (e.path === t.path)
+                continue;
+            // The test imports the real assembly → it is exercising the shipped wiring,
+            // not a copy. Good citizen, never flagged.
+            if (tImports.has(moduleIdOf(e.path)))
+                continue;
+            const eImports = prodImports.get(e.path);
+            // Leaves E is the SOLE production composer of, that this test re-imports.
+            const leaves = [...tImports].filter(m => eImports.has(m) && inDegree.get(m) === 1);
+            if (leaves.length >= 2 && (best === null || leaves.length > best.leaves.length)) {
+                best = { testFile: t.path, assemblyFile: e.path, leaves: leaves.sort() };
+            }
+        }
+        if (best)
+            findings.push(best);
+    }
+    return findings;
+}
+/**
+ * Render findings as verify-child prompt lines (probe+rule pattern — the concrete
+ * finding that makes the rule fire reliably). One line per re-assembling test naming
+ * the test, the shipped assembly it bypasses, and the re-composed leaves. Empty
+ * findings → empty array (caller emits no block).
+ */
+export function testAssemblyVerifyFindings(findings) {
+    return findings.map(f => `${f.testFile} imports and re-composes ${f.leaves.length} leaf module(s) `
+        + `(${f.leaves.join(', ')}) that ${f.assemblyFile} is the ONLY production file to `
+        + `compose, yet it never imports ${f.assemblyFile} — it builds its OWN assembly of `
+        + `those leaves instead of exercising the shipped one`);
+}

package/dist/task/verify-work.d.ts

@@ -21,6 +21,12 @@ export interface VerifyOutcome {
     /** Short, human-readable reason. Always set when ok === false; on the pass
      *  path set to the no-op cause ('disabled', 'no spec to verify'). */
     reason?: string;
+    /** True when the FAIL is specifically an UNOBSERVED outcome (rule 5c): a
+     *  spec-required behavioral check could not run because its tooling is absent.
+     *  The gate routes this straight to the human picker instead of an unattended
+     *  AUTOFIX re-run, which cannot provision a missing tool. Only meaningful when
+     *  ok === false. */
+    unobserved?: boolean;
 }
 /**
  * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
@@ -55,17 +61,24 @@ export declare function extractSpecForVerification(taskBody: string): string | n
  * 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 declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[]): string;
+export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[]): string;
 /**
- * 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 declare function parseVerifyVerdict(text: string): {
     pass: boolean;
+    unobserved?: boolean;
     detail: string;
 };
 export interface VerificationDeps {
@@ -101,6 +114,22 @@ export interface VerificationDeps {
      * no-waiver rule (4b). Advisory, never auto-FAIL — real prohibitions can be
      * conditional prose. ABSENT or empty → no prohibition block. */
     prohibitionProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC test-assembly probe (see test-assembly.ts): authored test files
+     * that rebuild production WIRING — importing the leaf modules the shipped entry
+     * composes and assembling their own copy instead of the real assembly — become
+     * prompt findings under rule 3f (F4 test-the-copy, 3rd recurrence). Pure import-
+     * graph shape; the child then drives the real assembly before trusting the copy.
+     * ABSENT or empty → no test-assembly block. */
+    testAssemblyProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC probe-gaming probe (see probe-gaming.ts, run-8 F6): added lines
+     * in the task's diff whose stated purpose is to make a CHECK pass instead of
+     * meeting the requirement it stands for ("return 401 so the verification test
+     * passes"). Injected as findings under rule 4c so the child confirms the
+     * underlying requirement is genuinely met rather than trusting the green check.
+     * Pure diff-text analysis; ABSENT or empty → no probe block. */
+    probeGamingProbe?: () => Promise<string[]>;
     /**
      * Result of the git-state guard for the MOST RECENT runChild call (see
      * git-state-guard.ts): did the child mutate repo state (stash/checkout/file
@@ -124,6 +153,14 @@ export interface VerificationDeps {
         read: () => Promise<string>;
         append: (notes: string[]) => Promise<void>;
     };
+    /**
+     * Per-run cross-slice contract registry (see contracts.ts): `read` supplies the
+     * verbatim interface facts the SOURCE design pins that more than one slice
+     * touches, injected so the verify child checks THIS slice's boundary against
+     * them (F3 seam bugs are locally right but globally wrong). ABSENT/empty → no
+     * block (single `/task` runs, or a design pinning no shared boundary), unchanged.
+     */
+    contracts?: () => Promise<string>;
 }
 /**
  * Run the verification pass for one task. A missing spec is a pass. Otherwise run