@mjasnikovs/pi-task 0.37.4 → 0.37.5

package/dist/task/final-gate.js

@@ -52,6 +52,7 @@ import * as path from 'node:path';
 import { runRepoHealthCheck, discoverHealthCommands } from './repo-health-check.js';
 import { readAcceptDebts, recheckAcceptDebts, writeAcceptDebts, buildAcceptDebtNote, annotateDebtConflicts } from './accept-debt.js';
 import { readDeclaredScripts, missingDeclaredScripts, runnableDeclaredScripts } from './launch-contract.js';
+import { readLaunchManifest, inertLaunchContractNote } from './launch-manifest.js';
 import { readEnvNotes, parseEnvNotes, isExcuseNote } from './env-notes.js';
 import { runRenderCheck } from './render-check.js';
 import { collectProjectEnv, pinnedLocalPort, runDeepRenderCheck } from './deep-render-check.js';
@@ -1378,11 +1379,28 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     // scripts that fell through decompose and shipped missing, unchecked. Diff the
     // plan-time-extracted declared scripts against the manifest; a missing one is a
     // launch-surface defect. FP-safe: empty declared list (nothing grounded) → no check.
+    //
+    // THE DIFF IS INERT WITHOUT A MANIFEST (nexttask 16A). It used to diff against
+    // `Object.keys(packageScripts(cwd))`, whose catch returns {} — so a project with
+    // NO package.json was indistinguishable from one with no scripts, and every
+    // declared script was reported missing in wording naming a file the project was
+    // never meant to have. Nothing upstream is npm-shaped (the extractor scrapes any
+    // design that says "script"), and this text seeds the autofix child's prompt, so
+    // on a CMake/cargo project the likely repair was to write a package.json.
+    // readLaunchManifest resolves package.json, else a Makefile's targets, else
+    // nothing — and nothing means no failure plus a note, never a silent pass.
     const declared = await readDeclaredScripts(cwd);
+    const contractNotes = [];
     if (declared.length > 0) {
-        const missing = missingDeclaredScripts(declared, Object.keys(packageScripts(cwd)));
-        if (missing.length > 0) {
-            fail(`launch contract: the design declares script(s) the shipped package.json does not expose: ${missing.join(', ')} (declared: ${declared.join(', ')})`);
+        const manifest = readLaunchManifest(cwd);
+        if (manifest.kind === 'none') {
+            contractNotes.push(inertLaunchContractNote(declared, manifest));
+        }
+        else {
+            const missing = missingDeclaredScripts(declared, manifest.names);
+            if (missing.length > 0) {
+                fail(`launch contract: the design declares script(s) the shipped ${manifest.file} does not expose: ${missing.join(', ')} (declared: ${declared.join(', ')})`);
+            }
         }
     }
     // Serve-entry closure (mx5 run 18, nexttask 2B): the tree builds a server app,
@@ -1416,7 +1434,12 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     // harvest lever refuted at discoverIntegrationCommands it cannot inject a fabricated
     // failure.
     if (lockCmds.length === 0 && cmds.length === 0 && !boot && failures.length === 0) {
-        const note = unobservedVerdict({ discovered: 0, observed: 0 }) ?? '';
+        // The inert-contract note rides here too: a non-npm project carrying a launch
+        // contract usually discovers no command either, and that is exactly the run
+        // whose silence must not read as "the contract was checked and was fine".
+        const note = [unobservedVerdict({ discovered: 0, observed: 0 }) ?? '', ...contractNotes]
+            .filter(n => n !== '')
+            .join(' ');
         return withDebts({ ok: true, unobserved: note, reason: note });
     }
     const ran = [];
@@ -1471,6 +1494,11 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
         // A declared script the manifest doesn't expose is already a launch-contract
         // failure above; executing it too would double-report (pre-aggregation the
         // contract diff early-returned, so this loop could assume presence).
+        // EXECUTION STAYS npm-ONLY. The diff above now also speaks Makefile (16A),
+        // but the runner below is literally `bun run <name>`; on a Makefile project
+        // `present` is empty, so every declared target is skipped rather than run
+        // through the wrong tool. Widening the RUNNER is a separate lever with its
+        // own A/B, not a free rider on an inertness fix.
         const present = new Set(Object.keys(packageScripts(cwd)).map(s => s.toLowerCase()));
         const scripts = packageScripts(cwd);
         // CONFIG-GAP INPUTS (mx5 run 20), read once: the tracked file list and the
@@ -1704,7 +1732,8 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     const unobserved = [
         bootUnobserved,
         unobservedVerdict({ discovered: dynAttempted, observed: dynObserved }),
-        ...configGapNotes
+        ...configGapNotes,
+        ...contractNotes
     ]
         .filter(n => n !== null)
         .join(' ');

package/dist/task/launch-manifest.d.ts

@@ -0,0 +1,37 @@
+/** Which manifest kind the diff resolved for a tree. `none` ⇒ the diff is INERT. */
+export type LaunchManifestKind = 'npm' | 'make' | 'none';
+export interface LaunchManifest {
+    kind: LaunchManifestKind;
+    /** The manifest the diff is taken against, for the failure text. '' when none. */
+    file: string;
+    /** Entrypoint names the manifest exposes: npm script keys / Makefile targets. */
+    names: string[];
+    /** Why nothing is checkable (kind === 'none' only). */
+    why?: string;
+}
+/**
+ * The explicit targets a Makefile declares. Deliberately conservative — this list
+ * only ever has to answer "does the project expose `migrate`", so a missed exotic
+ * target costs a false FAIL and is the one error worth avoiding:
+ *   • recipe lines (leading TAB) are skipped — they are shell, not targets;
+ *   • `:=` / `::=` / `?=` / `+=` assignments are skipped;
+ *   • pattern rules (`%.o: %.c`) and dot-targets (`.PHONY:`) fail TARGET_NAME_RE,
+ *     which is also why the names listed AFTER `.PHONY:` are ignored here: they are
+ *     prerequisites, and every one of them that is real is declared by its own rule.
+ * Multiple targets on one line (`build test:`) all count.
+ */
+export declare function makeTargets(src: string): string[];
+/**
+ * Resolve the manifest the launch contract may be diffed against.
+ *
+ * A package.json that exists but does not parse resolves to `none`, not to "zero
+ * scripts": diffing against a manifest you could not read is exactly the mistake
+ * this module exists to stop, and a broken manifest is the static checks' business.
+ */
+export declare function readLaunchManifest(cwd: string): LaunchManifest;
+/**
+ * The one line an INERT contract leaves behind. It rides in the gate's UNOBSERVED
+ * channel rather than in `warnings` for the reason nexttask 16A gives: a check that
+ * silently did nothing must not read later as a check that passed.
+ */
+export declare function inertLaunchContractNote(declared: string[], manifest: LaunchManifest): string;

package/dist/task/launch-manifest.js

@@ -0,0 +1,128 @@
+/**
+ * launch-manifest — WHICH manifest the launch-contract diff is entitled to diff
+ * against, and whether there is one at all (nexttask 16A).
+ *
+ * The defect this closes (unobserved, proven by construction). The extraction end
+ * of the launch contract has no ecosystem test anywhere in it:
+ * `enumerateScriptCandidates` scrapes backticked, script-name-shaped tokens out of
+ * any design paragraph that says "script", and `keepGroundedScripts` can only DROP
+ * a candidate. So a CMake / cargo / poetry / Makefile design saying *"the Makefile
+ * must expose `build`, `test`, `migrate`"* records exactly the same artifact an npm
+ * design does. The diff end hardcoded the ecosystem anyway:
+ *
+ *     missingDeclaredScripts(declared, Object.keys(packageScripts(cwd)))
+ *     …where packageScripts' catch returns {} — so "this project has no
+ *     package.json" was indistinguishable from "its package.json declares no
+ *     scripts", and every declared script was reported missing, at rank 1, in
+ *     wording that NAMES a file the project was never meant to have.
+ *
+ * That text seeds the autofix child's prompt (final-gate.ts's FinalGateOutcome.reason),
+ * so the most likely repair on a CMake project was to write a package.json.
+ *
+ * IAR1 is how close this got: `plan-debug.log:10` records "launch-contract
+ * extraction: 0 grounded script(s) kept from 3 emitted" — a non-npm project that
+ * reached extraction and emitted three candidates, saved only by its design not
+ * backticking them in a "script" paragraph.
+ *
+ * THE RULE, and it is deliberately two ecosystems wide, not three:
+ *   • package.json present and parseable ⇒ diff against its `scripts` keys, exactly
+ *     as before (byte-identical failure text on every npm tree — mx5's missing
+ *     `build`/`seed` is a TRUE positive and must keep failing).
+ *   • no package.json but a Makefile ⇒ diff against its TARGETS. The capability was
+ *     already in final-gate.ts (`makeHasTarget`); the diff simply never called it.
+ *   • neither ⇒ the check is INERT. No failure, and a note saying the contract was
+ *     recorded but is not checkable here, so the silence is not read later as a pass
+ *     (the repo-health-check / env-template-closure discipline: ENOENT = pass, and a
+ *     check must never invent a file the project chose not to have).
+ *
+ * cargo/poetry/gradle are NOT here on purpose. The corpus on this box contains one
+ * project that ever recorded a launch contract (mx5, npm) and one non-npm project
+ * that reached extraction (IAR1, CMake). A third ecosystem would be a guess.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+/** GNU make's own lookup order, and nothing beyond it — this is one ecosystem. */
+const MAKEFILE_NAMES = ['GNUmakefile', 'makefile', 'Makefile'];
+/** A target we are willing to name in a failure: an ordinary word-shaped target. */
+const TARGET_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,39}$/i;
+/**
+ * A variable assignment, in every form make accepts (`=`, `:=`, `::=`, `?=`, `+=`,
+ * `!=`, with an optional `override`/`export`). Matched BEFORE the target rule
+ * because `FLAGS ::= -O2` otherwise reads as a target named `FLAGS`.
+ */
+const ASSIGN_RE = /^(?:override\s+|export\s+)?[A-Za-z_][A-Za-z0-9_.]*\s*(?:::|:|\?|\+|!)?=/;
+/**
+ * The explicit targets a Makefile declares. Deliberately conservative — this list
+ * only ever has to answer "does the project expose `migrate`", so a missed exotic
+ * target costs a false FAIL and is the one error worth avoiding:
+ *   • recipe lines (leading TAB) are skipped — they are shell, not targets;
+ *   • `:=` / `::=` / `?=` / `+=` assignments are skipped;
+ *   • pattern rules (`%.o: %.c`) and dot-targets (`.PHONY:`) fail TARGET_NAME_RE,
+ *     which is also why the names listed AFTER `.PHONY:` are ignored here: they are
+ *     prerequisites, and every one of them that is real is declared by its own rule.
+ * Multiple targets on one line (`build test:`) all count.
+ */
+export function makeTargets(src) {
+    const out = [];
+    const seen = new Set();
+    for (const raw of src.replace(/\r\n?/g, '\n').split('\n')) {
+        if (raw.startsWith('\t') || raw.trim().length === 0 || raw.trimStart().startsWith('#'))
+            continue;
+        if (ASSIGN_RE.test(raw))
+            continue;
+        const m = /^([^:#=]+):(?![=])/.exec(raw);
+        if (!m)
+            continue;
+        for (const tok of m[1].trim().split(/\s+/)) {
+            if (!TARGET_NAME_RE.test(tok))
+                continue;
+            const key = tok.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(tok);
+        }
+    }
+    return out;
+}
+/**
+ * Resolve the manifest the launch contract may be diffed against.
+ *
+ * A package.json that exists but does not parse resolves to `none`, not to "zero
+ * scripts": diffing against a manifest you could not read is exactly the mistake
+ * this module exists to stop, and a broken manifest is the static checks' business.
+ */
+export function readLaunchManifest(cwd) {
+    const pkg = path.join(cwd, 'package.json');
+    if (existsSync(pkg)) {
+        try {
+            const j = JSON.parse(readFileSync(pkg, 'utf8'));
+            return { kind: 'npm', file: 'package.json', names: Object.keys(j.scripts ?? {}) };
+        }
+        catch {
+            return { kind: 'none', file: '', names: [], why: 'its package.json could not be parsed' };
+        }
+    }
+    for (const name of MAKEFILE_NAMES) {
+        const mk = path.join(cwd, name);
+        if (!existsSync(mk))
+            continue;
+        try {
+            return { kind: 'make', file: name, names: makeTargets(readFileSync(mk, 'utf8')) };
+        }
+        catch {
+            break;
+        }
+    }
+    return { kind: 'none', file: '', names: [], why: 'it has no npm manifest and no Makefile' };
+}
+/**
+ * The one line an INERT contract leaves behind. It rides in the gate's UNOBSERVED
+ * channel rather than in `warnings` for the reason nexttask 16A gives: a check that
+ * silently did nothing must not read later as a check that passed.
+ */
+export function inertLaunchContractNote(declared, manifest) {
+    return (`launch contract: ${declared.length} declared script(s) (${declared.join(', ')}) were recorded, `
+        + `but this project could not be diffed against a manifest — ${manifest.why ?? 'no manifest'}. `
+        + 'The contract was NOT checked here.');
+}

package/package.json

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