@mjasnikovs/pi-task 0.21.3 → 0.21.5

package/dist/task/accept-debt.d.ts

@@ -29,6 +29,11 @@
  *     `lsof` and the sandbox had neither) and no further attempt can move it. The
  *     run is allowed to converge on the REMAINING checks, carrying this one here
  *     so the next run's gate re-checks and re-surfaces it rather than losing it.
+ *     Also recorded for the ZERO-OBSERVATION verdict (final-gate.ts
+ *     unobservedVerdict): the whole gate observed nothing dynamic — usually because
+ *     the project's ecosystem exposes no discoverable command at all — so the run
+ *     completed on statics alone. Same treatment for the same reason: unprovable
+ *     here, so carry it forward rather than let a silent PASS bury it.
  *   - 'root-cause' — the task's verify FAILed because of a PRE-EXISTING defect in a
  *     file a DIFFERENT task created, which this task's own work never touched (mx5
  *     run 14: TASK_0007's `test/teardown.ts` TRUNCATE bug FAILed TASK_0013 and

package/dist/task/auto-orchestrator.d.ts

@@ -36,6 +36,8 @@ export interface AutoDeps extends GateDeps {
         failures?: string[];
         debtNote?: string;
         openDebts?: AcceptDebt[];
+        /** Set ⇒ the gate observed nothing dynamic: UNOBSERVED, not PASS. */
+        unobserved?: string;
     }>;
     /**
      * Bounded model-driven fix pass for a final-gate FAIL (see final-gate-fix.ts),

package/dist/task/auto-orchestrator.js

@@ -1063,6 +1063,11 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     announceDone(active, `${id} cancelled before the final integration gate — resume with /task-auto-resume.`, 'warning');
                     return;
                 }
+                // Set when the gate finished having observed NOTHING dynamic. Declared
+                // out here so the run-completion announcement below can say so: a run
+                // that completes on statics alone must not be announced the same way as
+                // one whose product was actually exercised.
+                let unobservedNote = null;
                 if (deps.finalGate) {
                     active.ui.notify(`${id}: running final integration gate…`, 'info');
                     // Run-level gate trail on the parent task file — same durable
@@ -1096,7 +1101,21 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     // Record the outcome symmetrically (mx5 run 10 item 7): only FAIL was
                     // ever trailed, so a PASSing gate was indistinguishable from a gate
                     // that never ran. The PASS reason names the commands that were run.
-                    if (fin.ok) {
+                    // THREE verdicts, not two (final-gate.ts unobservedVerdict): a gate
+                    // that observed nothing dynamic is UNOBSERVED, never PASS — IAR1
+                    // shipped `PASS — no integration command found` twice while carrying
+                    // open verify-FAIL debt. It does not block (justified there), but it
+                    // is labelled here, warned about, and recorded as durable debt so the
+                    // next run's gate re-surfaces it.
+                    if (fin.ok && fin.unobserved) {
+                        unobservedNote = fin.unobserved;
+                        await recGate(`final-gate: UNOBSERVED — ${fin.reason.slice(0, 300)}`);
+                        await recordFinalGateUnobservedDebt(cwd, id, fin.unobserved);
+                        active.ui.notify(`${id}: the final integration gate observed NOTHING dynamic — `
+                            + 'the run completed on static checks alone. Nothing verified '
+                            + 'that the assembled product builds, boots or works.', 'warning');
+                    }
+                    else if (fin.ok) {
                         await recGate(`final-gate: PASS — ${fin.reason.slice(0, 300)}`);
                     }
                     else {
@@ -1247,8 +1266,15 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             const fix = await deps.finalGateFix(active, cwd, seed);
                             if (fix.ok) {
                                 await deps.commit(cwd, `FINAL GATE AUTOFIX (${id})`);
-                                await recGate(`final-gate: autofix converged — ${fix.reason.slice(0, 200)}`);
-                                active.ui.notify(`${id}: final integration gate PASSES after autofix — ${fix.reason.slice(0, 140)}`, 'info');
+                                // A converged re-run that observed nothing dynamic is
+                                // UNOBSERVED on this door too — never announce it as a
+                                // PASS just because it arrived via autofix.
+                                if (fix.unobserved) {
+                                    unobservedNote = fix.unobserved;
+                                    await recordFinalGateUnobservedDebt(cwd, id, fix.unobserved);
+                                }
+                                await recGate(`final-gate: autofix ${fix.unobserved ? 'ended UNOBSERVED' : 'converged'} — ${fix.reason.slice(0, 200)}`);
+                                active.ui.notify(`${id}: final integration gate ${fix.unobserved ? 'is UNOBSERVED' : 'PASSES'} after autofix — ${fix.reason.slice(0, 140)}`, fix.unobserved ? 'warning' : 'info');
                                 fin = { ok: true, reason: fix.reason };
                                 break;
                             }
@@ -1367,7 +1393,12 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     }
                 }
                 await updateTaskFrontMatter(cwd, id, { state: 'completed' });
-                announceDone(active, `${id} complete — all ${entries.length} tasks done.`, 'info');
+                announceDone(active, `${id} complete — all ${entries.length} tasks done.`
+                    + (unobservedNote ?
+                        ' WARNING: the final integration gate was UNOBSERVED — it ran no '
+                            + 'dynamic check at all, so "complete" here means the statics '
+                            + 'passed and nothing more. Carried as debt for the next run.'
+                        : ''), unobservedNote ? 'warning' : 'info');
                 return;
             }
             // REFUSE to start on a conflicted tree: an unmerged index dooms every

package/dist/task/final-gate-fix.d.ts

@@ -103,6 +103,11 @@ export interface FinalFixResult {
     /** The fresh gate's individual ranked failures (see FinalGateOutcome.failures),
      *  so the caller can trail each entry — never just the first. */
     gateFailures?: string[];
+    /** On a converged outcome: the re-run gate's UNOBSERVED note, if it observed
+     *  nothing dynamic (see FinalGateOutcome.unobserved). Carried so the caller
+     *  labels a converge-on-statics-alone the same way it labels a first-pass one —
+     *  "converged" must never quietly mean "we stopped being able to check". */
+    unobserved?: string;
     /** A write-guard rejected this attempt (deletion / shrink / probe-gaming). */
     guardTripped?: boolean;
     /** …and its edits were discarded. When a guard tripped and this is false, the
@@ -126,6 +131,7 @@ export interface FinalFixDeps {
         ok: boolean;
         reason: string;
         failures?: string[];
+        unobserved?: string;
     }>;
     /** Labels of every currently-discoverable gate command (static + integration),
      *  for the shrink guard. Pure discovery — nothing is executed. */

package/dist/task/final-gate-fix.js

@@ -295,5 +295,5 @@ export async function runFinalGateAutofix(deps) {
             gateFailures: fin.failures
         };
     }
-    return { ok: true, reason: fin.reason };
+    return { ok: true, reason: fin.reason, ...(fin.unobserved ? { unobserved: fin.unobserved } : {}) };
 }

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

@@ -38,6 +38,15 @@ export interface FinalGateOutcome {
      * run never completes silently carrying an accepted defect. Empty/absent = none.
      */
     openDebts?: AcceptDebt[];
+    /**
+     * Set (with the UNOBSERVED note) when the gate observed NOTHING dynamic — either
+     * no command was discoverable at all, or every discovered one was skipped as an
+     * environment gap. `ok` is still true (the statics did pass and there is nothing
+     * to fix), but this is NOT a PASS: the caller must record it as UNOBSERVED, never
+     * as "checked and fine". Absent ⇒ at least one dynamic command actually ran.
+     * See unobservedVerdict for the three-way verdict and the blocking decision.
+     */
+    unobserved?: string;
 }
 /**
  * The project's OWN whole-repo integration commands (test, then build — test
@@ -47,8 +56,9 @@ export interface FinalGateOutcome {
  *
  * THE MANIFEST ALLOWLIST BELOW IS NARROW, AND THAT IS A KNOWN, MEASURED GAP: a
  * C++/CMake project (no package.json) and a package.json whose only script is
- * `verify` both discover NOTHING here and fall through to the static-only PASS
- * at the `no integration command found` return below.
+ * `verify` both discover NOTHING here. That outcome is now reported as UNOBSERVED
+ * rather than as a PASS (see unobservedVerdict), which makes the blindness loud and
+ * durable — it does not remove it. The gap itself stands.
  *
  * The obvious fix — harvest each task's own `## verified tooling` section, which
  * DOES record the missing commands — was measured on 2026-07-27 and REFUTED. That
@@ -265,6 +275,48 @@ export declare function observabilityGapFailure(args: {
     /** Is this runner spawnable (bare or via a known install location)? */
     runnerResolvable: (bin: string) => boolean;
 }): string | null;
+/**
+ * The THIRD verdict. observabilityGapFailure above covers "commands were DISCOVERED
+ * but every one failed to spawn" — a rank-0 FAIL. It deliberately returns null for
+ * `attempted === 0`, and until now that silence fell straight through to
+ * `PASS — no integration command found (statics passed)`: the run-16 blindness class
+ * entering through a different door, where "we never checked" reads exactly like "we
+ * checked and it was fine". Measured 2026-07-27: IAR1 (C++/CMake, no package.json)
+ * shipped that verdict TWICE while carrying 2 and 3 open verify-FAIL debts, and
+ * godot-engine (package.json whose only script is `verify`) reproduces it live today.
+ *
+ * So: observed anything dynamic ⇒ PASS; discovered-but-all-spawn-failed ⇒ the
+ * existing FAIL; observed NOTHING ⇒ this note, carried on an `ok: true` outcome.
+ *
+ * WHY NON-BLOCKING (decided, not deferred — the evidence cuts both ways and this is
+ * the resolution):
+ *  - Blocking's case: both real occurrences also carried open verify-FAIL debt, so
+ *    the runs with no dynamic evidence were exactly the runs already known to be
+ *    carrying defects.
+ *  - Against, and decisive: (1) that debt is ALREADY surfaced unconditionally at the
+ *    gate moment, on PASS as on FAIL — the IAR1 records literally read "PASS — no
+ *    integration command found … UNRESOLVED VERIFY-FAIL DEBT still open (2)". The
+ *    missing signal was never the debt, it was the word PASS endorsing the run, and
+ *    that is what this fixes. (2) `ok: false` routes into the autofix picker, whose
+ *    seed is `reason`; "no integration command is discoverable" is not fixable by
+ *    editing code, so the highest-probability child response is to FABRICATE a
+ *    runnable command to satisfy the gate — the same fabrication class that refuted
+ *    the `## verified tooling` harvest (see discoverIntegrationCommands) and that had
+ *    run 11's fix child `rm` a sibling's deliverable. (3) That harvest being refuted
+ *    means IAR1 and godot-engine can NEVER discover a command, so blocking would end
+ *    every non-npm run in `failed` permanently, with no remedy — the task's own I3
+ *    ("show blocking does not block IAR1/godot post-Task-1") is unsatisfiable, and
+ *    its stated consequence is to downgrade to a warning and say so. This is that.
+ * The teeth are elsewhere and are real: the verdict word changes, the gate trail says
+ * UNOBSERVED, and the caller records a durable final-gate debt that the NEXT run's
+ * gate re-surfaces (it can never auto-close — it is not static-class).
+ */
+export declare function unobservedVerdict(args: {
+    /** Dynamic commands the gate discovered and tried to run (0 ⇒ nothing existed). */
+    discovered: number;
+    /** Of those, how many actually RAN (a real pass or a real fail). */
+    observed: number;
+}): string | null;
 export { taskThatIntroduced };
 /**
  * Run the final gate: static analysis first, then the lockfile consistency

package/dist/task/final-gate.js

@@ -76,8 +76,9 @@ function makeHasTarget(cwd, target) {
  *
  * THE MANIFEST ALLOWLIST BELOW IS NARROW, AND THAT IS A KNOWN, MEASURED GAP: a
  * C++/CMake project (no package.json) and a package.json whose only script is
- * `verify` both discover NOTHING here and fall through to the static-only PASS
- * at the `no integration command found` return below.
+ * `verify` both discover NOTHING here. That outcome is now reported as UNOBSERVED
+ * rather than as a PASS (see unobservedVerdict), which makes the blindness loud and
+ * durable — it does not remove it. The gap itself stands.
  *
  * The obvious fix — harvest each task's own `## verified tooling` section, which
  * DOES record the missing commands — was measured on 2026-07-27 and REFUTED. That
@@ -789,6 +790,55 @@ export function observabilityGapFailure(args) {
         + `could even spawn in this environment${runnerNote}; `
         + `the gate observed nothing dynamic and cannot vouch for the assembled app`);
 }
+/**
+ * The THIRD verdict. observabilityGapFailure above covers "commands were DISCOVERED
+ * but every one failed to spawn" — a rank-0 FAIL. It deliberately returns null for
+ * `attempted === 0`, and until now that silence fell straight through to
+ * `PASS — no integration command found (statics passed)`: the run-16 blindness class
+ * entering through a different door, where "we never checked" reads exactly like "we
+ * checked and it was fine". Measured 2026-07-27: IAR1 (C++/CMake, no package.json)
+ * shipped that verdict TWICE while carrying 2 and 3 open verify-FAIL debts, and
+ * godot-engine (package.json whose only script is `verify`) reproduces it live today.
+ *
+ * So: observed anything dynamic ⇒ PASS; discovered-but-all-spawn-failed ⇒ the
+ * existing FAIL; observed NOTHING ⇒ this note, carried on an `ok: true` outcome.
+ *
+ * WHY NON-BLOCKING (decided, not deferred — the evidence cuts both ways and this is
+ * the resolution):
+ *  - Blocking's case: both real occurrences also carried open verify-FAIL debt, so
+ *    the runs with no dynamic evidence were exactly the runs already known to be
+ *    carrying defects.
+ *  - Against, and decisive: (1) that debt is ALREADY surfaced unconditionally at the
+ *    gate moment, on PASS as on FAIL — the IAR1 records literally read "PASS — no
+ *    integration command found … UNRESOLVED VERIFY-FAIL DEBT still open (2)". The
+ *    missing signal was never the debt, it was the word PASS endorsing the run, and
+ *    that is what this fixes. (2) `ok: false` routes into the autofix picker, whose
+ *    seed is `reason`; "no integration command is discoverable" is not fixable by
+ *    editing code, so the highest-probability child response is to FABRICATE a
+ *    runnable command to satisfy the gate — the same fabrication class that refuted
+ *    the `## verified tooling` harvest (see discoverIntegrationCommands) and that had
+ *    run 11's fix child `rm` a sibling's deliverable. (3) That harvest being refuted
+ *    means IAR1 and godot-engine can NEVER discover a command, so blocking would end
+ *    every non-npm run in `failed` permanently, with no remedy — the task's own I3
+ *    ("show blocking does not block IAR1/godot post-Task-1") is unsatisfiable, and
+ *    its stated consequence is to downgrade to a warning and say so. This is that.
+ * The teeth are elsewhere and are real: the verdict word changes, the gate trail says
+ * UNOBSERVED, and the caller records a durable final-gate debt that the NEXT run's
+ * gate re-surfaces (it can never auto-close — it is not static-class).
+ */
+export function unobservedVerdict(args) {
+    if (args.observed > 0)
+        return null;
+    // Kept short ON PURPOSE: the run-level trail line slices the reason at 300 chars,
+    // and the whole point of this verdict is that the durable record carries it.
+    const why = args.discovered === 0 ?
+        'no integration, lockfile or boot command was discoverable here, so the gate ran '
+            + 'nothing at all'
+        : `all ${args.discovered} discovered command(s) skipped as environment gaps, so the `
+            + 'gate ran nothing observable';
+    return (`UNOBSERVED — NOT a pass: ${why}; statics passed, but this run produced NO evidence `
+        + 'that the assembled product builds, boots or works.');
+}
 /**
  * Boot check hit an address-in-use bind failure. If the port is held by one of OUR
  * own orphaned gate children (a `dev`/`start` run), reap it and retry the boot once
@@ -885,15 +935,19 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     const lockCmds = discoverLockfileChecks(cwd);
     const { cmds } = discoverIntegrationCommands(cwd);
     const boot = discoverBootCommand(cwd);
-    // ZERO-DISCOVERY STILL READS AS A PASS HERE, AND THAT IS THE OPEN DEFECT. Nothing was
-    // discovered, so nothing ran, so observabilityGapFailure (attempted === 0 → null) never
-    // fires: "we never checked" is reported identically to "we checked and it was fine". IAR1
-    // shipped this verdict TWICE while carrying open verify-FAIL debt (its .pi-tasks/
-    // TASK_AUTO_0001.md:31 and TASK_AUTO_0002.md:37). The fix is to make this outcome
-    // UNOBSERVED rather than PASS — it needs no new command source and so cannot inject a
-    // fabricated failure, unlike the harvest lever refuted at discoverIntegrationCommands above.
+    // ZERO DISCOVERY IS UNOBSERVED, NEVER A PASS (see unobservedVerdict). Nothing was
+    // discovered, so nothing ran, so observabilityGapFailure (attempted === 0 → null) does
+    // not fire — and this outcome used to be reported as `PASS — no integration command
+    // found (statics passed)`, i.e. "we never checked" reading identically to "we checked
+    // and it was fine". IAR1 shipped that verdict TWICE while carrying open verify-FAIL
+    // debt (its .pi-tasks/TASK_AUTO_0001.md:31 and TASK_AUTO_0002.md:37). The outcome stays
+    // `ok: true` (non-blocking, justified at unobservedVerdict) but is now labelled, trailed
+    // and carried as debt by the caller. It needs no new command source, so unlike the
+    // harvest lever refuted at discoverIntegrationCommands it cannot inject a fabricated
+    // failure.
     if (lockCmds.length === 0 && cmds.length === 0 && !boot && failures.length === 0) {
-        return withDebts({ ok: true, reason: 'no integration command found (statics passed)' });
+        const note = unobservedVerdict({ discovered: 0, observed: 0 }) ?? '';
+        return withDebts({ ok: true, unobserved: note, reason: note });
     }
     const ran = [];
     // Full-skip blindness counters (mx5 run 16): every dynamic spawn counts an
@@ -1071,10 +1125,20 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
         });
     }
     const warningNote = warnings.length > 0 ? ` — WARNING: ${warnings.join('; WARNING: ')}` : '';
+    // The same three-way verdict at the other zero-observation door: commands WERE
+    // discovered, none spawn-failed (so the run-16 guard correctly stayed silent — every
+    // skip was a tool-level env gap), and yet nothing ran. That was `statics passed
+    // (integration commands not runnable here)`, which is the identical "we never checked"
+    // silence wearing different words. Unchanged when anything at all was observed, so a
+    // project with runnable commands is byte-for-byte unaffected.
+    const unobserved = unobservedVerdict({ discovered: dynAttempted, observed: dynObserved });
     return withDebts({
         ok: true,
-        reason: (ran.length > 0 ?
-            `statics + ${ran.map(c => `\`${c}\``).join(', ')} passed`
-            : 'statics passed (integration commands not runnable here)') + warningNote
+        ...(unobserved ? { unobserved } : {}),
+        reason: (unobserved ? `${unobserved} — ` : '')
+            + (ran.length > 0 ?
+                `statics + ${ran.map(c => `\`${c}\``).join(', ')} passed`
+                : 'statics passed (integration commands not runnable here)')
+            + warningNote
     });
 }

package/dist/task/phases.js

@@ -1343,6 +1343,50 @@ export const PHASES = [
         }
     }
 ];
+// INTEGRATION-DEPTH APPEND (2026-07-27): the lever proposed for this exact site —
+// deterministically append a known-runnable integration command to the VERIFY block
+// whenever a task's ACCEPTANCE claims runtime behaviour — is REFUTED at STEP 0 and was
+// NOT built. Nothing below is wired; this is the record.
+//
+// The defect is real and reproduces on four unrelated stacks. Measured with
+// scripts/verify-integration-depth-step0.ts (published metric regex in that file;
+// re-runnable, no model time): VERIFY blocks that boot or hit the real integrated
+// product — mx5 7/41, IAR1 3/10, godot-engine 2/20, runner 0/2, total 12/73 (16.4%).
+// That total OVERSTATES the truth: godot's two hits only match because the block greps
+// a URL out of CLAUDE.md, and IAR1's TASK_0006 curls a GitHub tarball to check a hash,
+// so genuine product integration is ~9/73 (~12%). The addressable class — runtime claim
+// in ACCEPTANCE, a boot command available with provenance, static-only VERIFY anyway —
+// is 29/73 (39.7%), clearing the task's 25% kill condition, but 27 of those 29 are mx5.
+//
+// What kills the lever is its input, not its premise. It needs a command that is
+// (1) provenance-bearing, (2) proven runnable, (3) terminating, and (4) integration-
+// shaped. Measured on scratch clones with scripts/integration-command-provenance.ts,
+// that intersection is EMPTY on every stack available here:
+//   mx5    `bun run dev` is the only command matching the metric and it does not
+//          terminate (probe killed it at 60s) — appending it hangs the verify child
+//          until the 15-minute command watchdog and then FAILs. Every command that DOES
+//          terminate (`bun run build` exit 0) fails the metric.
+//   godot  `godot --headless --quit` (0.8s, exit 0) and the real GUT runner (1.7s,
+//          exit 0) are both appendable — and neither matches the metric, which is
+//          web-shaped (curl/localhost/PORT=/run dev/http://). Nothing appendable can
+//          move the registered metric on a non-web stack, so the two-stack A/B the
+//          task requires is unsatisfiable by construction, not by sample size.
+//   IAR1   no candidate at all: cmake is absent from this box (the N5 finding).
+// R4 forbids swapping the metric after seeing results, so a broadened "boots the real
+// product" metric is a separate pre-registered experiment, not a rescue of this one.
+//
+// The deeper finding: on the stack holding 93% of the addressable mass, integration is
+// not a COMMAND. mx5's 7 integrated blocks are whole task-specific procedures — pick a
+// free port (3911/41234/42421/3001), export DATABASE_URL, boot, seed, log in, assert N
+// endpoints, tear down. A host-side append cannot synthesize that from provenance
+// (launch-contract.md records script NAMES only — no port, no health URL), and
+// synthesizing it from the task's own `## verified tooling` is the N5 fabrication road.
+// That machinery already exists in ONE place that owns ports, seeding and teardown: the
+// final gate's render check. The mx5-class defect belongs there (nexttask TASK 6), not
+// in per-task VERIFY blocks.
+//
+// Durable assets kept: both rigs above and their unit tests. Do NOT wire an append here
+// without a command source that satisfies all four properties at once.
 export async function postCommitPhase(phase, deps, pc, out) {
     if (phase.name !== 'refine')
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.21.3",
+    "version": "0.21.5",
     "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",