@mjasnikovs/pi-task 0.18.30 → 0.18.32

package/dist/task/verify-work.js

@@ -140,7 +140,14 @@ export function extractSpecForVerification(taskBody) {
  * Guard: honest-clean fixture (prohibition in spec, probe silent) 5/5 PASS — no
  * paranoia. Reverted-violation ≡ clean at the diff level (no entry → no finding).
  */
-export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings, crossTaskDeletionFindings) {
+export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings, crossTaskDeletionFindings, 
+/**
+ * The mx5 run-13 (PROMPT 4) probes, grouped rather than appended as three more
+ * positional parameters — this signature was already at its limit. Each key is
+ * an independent finding list; absent/empty emits no block.
+ */
+projectSurface = {}) {
+    const { foreignPaths: foreignPathFindings, scriptEscapes: scriptEscapeFindings, runnerGlobs: runnerGlobFindings } = projectSurface;
     const probeBlock = probeFindings && probeFindings.length > 0 ?
         [
             'SELF-VERIFICATION NOTICE (deterministic, computed by the orchestrator from the diff):',
@@ -216,6 +223,57 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
             ''
         ]
         : [];
+    const foreignPathBlock = foreignPathFindings && foreignPathFindings.length > 0 ?
+        [
+            'SANDBOX PATH LEAK NOTICE (deterministic, computed by the orchestrator by',
+            "resolving every absolute path in the task's diff against THIS machine): this",
+            'task committed absolute paths that do not exist here, while the real file they',
+            'name sits inside this repo:',
+            ...foreignPathFindings.map(f => `- ${f}`),
+            "These are paths from the authoring agent's OWN environment, baked into a file",
+            'that ships. The command that reads such a path does not fail a check — it fails',
+            'to BUILD, so the checks that would have caught it never run and report nothing',
+            '(mx5 run 13: a leaked `/workspace` vite alias made `test:ct` collect 63 tests',
+            'and run 0, and the suite stayed dead for the rest of the run). A green or',
+            'EMPTY result from any command that reads these files is therefore NOT evidence.',
+            'Run the affected command yourself and confirm it actually EXECUTES work — count',
+            'the tests/steps that ran, not the exit code. Unless the leaked path resolves on',
+            'this machine, the verdict is FAIL naming the file and the path (rule 4e).',
+            ''
+        ]
+        : [];
+    const scriptEscapeBlock = scriptEscapeFindings && scriptEscapeFindings.length > 0 ?
+        [
+            'NEUTERED CHECK SCRIPT NOTICE (deterministic, computed by the orchestrator from',
+            'the manifest THIS task changed): these check scripts cannot report failure —',
+            'their exit status is 0 no matter what the checker finds:',
+            ...scriptEscapeFindings.map(f => `- ${f}`),
+            'You CANNOT discover this by running the script: it passes, which is the whole',
+            'defect (mx5 run 13 shipped a `lint` whose typecheck was disarmed by an inverted',
+            'grep and a `|| true` tail; every gate that ran it reported success without',
+            'measuring anything). A green result from one of these scripts is NOT evidence',
+            'for any acceptance criterion. To judge the area it claims to cover, run the',
+            'underlying checker DIRECTLY and unmodified (e.g. `tsc --noEmit` rather than',
+            '`npm run lint`) and judge THAT output. Unless the task spec explicitly requires',
+            'the script to tolerate failure, the verdict is FAIL naming the script (rule 4f).',
+            ''
+        ]
+        : [];
+    const runnerGlobBlock = runnerGlobFindings && runnerGlobFindings.length > 0 ?
+        [
+            'TEST-RUNNER GLOB COLLISION NOTICE (deterministic, computed by the orchestrator',
+            "from the manifest's declared runners and their config): two test runners claim",
+            'the same files:',
+            ...runnerGlobFindings.map(f => `- ${f}`),
+            "The scanning runner will import the other's spec files and abort on a module",
+            'loaded outside its own runner — so the suite dies WHOLESALE rather than',
+            'reporting failures (this is the THIRD occurrence: mx5 runs 7 and 13). Run both',
+            'test commands yourself and confirm each collects and runs its own files and only',
+            'its own. A run that errors during collection has verified nothing, whatever its',
+            'exit code says (rule 4g).',
+            ''
+        ]
+        : [];
     const testAssemblyBlock = testAssemblyFindings && testAssemblyFindings.length > 0 ?
         [
             'TEST-ASSEMBLY NOTICE (deterministic, computed by the orchestrator from pure',
@@ -255,6 +313,9 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         ...crossTaskDeletionBlock,
         ...probeGamingBlock,
         ...skipEscapeBlock,
+        ...foreignPathBlock,
+        ...scriptEscapeBlock,
+        ...runnerGlobBlock,
         ...testAssemblyBlock,
         'How to verify — verify the REAL, shipped deliverable exactly as an unaided fresh',
         'checkout (or CI run) would experience it:',
@@ -388,6 +449,32 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   tree). Otherwise the verdict is FAIL naming the deleted file and the task that',
         '   owns it.',
         '',
+        '4e. AN ABSOLUTE PATH TO PROJECT FILES IS A DEFECT — a committed path like',
+        "   `/workspace/src/shared` or `/home/<someone>/proj/src` names the authoring agent's",
+        '   OWN machine, not this one. Its distinctive damage is that it breaks the run BEFORE',
+        '   any check reports: a bad alias/config path makes the tool fail to RESOLVE or BUILD,',
+        '   so a suite "passes" having executed nothing. Treat a command that reports no',
+        '   failures but also no WORK — 0 tests run, 0 files emitted, an empty report — as',
+        '   unverified, never as green. Confirm the count of things that actually ran. A path',
+        '   to project-internal files must be relative to the file that carries it, or computed',
+        '   at runtime; if one does not resolve here, the verdict is FAIL naming file and path.',
+        '',
+        '4f. A CHECK THAT CANNOT FAIL PROVES NOTHING — before you cite a check script',
+        "   (`npm run lint`, `bun run test`) as evidence, read its DEFINITION in the project's",
+        '   manifest. A script ending in `|| true`, `; exit 0`, or piping a checker into an',
+        '   inverted grep exits 0 unconditionally: its green result is a constant, not a',
+        '   measurement, and running it again only reproduces the constant. When a script is',
+        '   built that way, run the underlying checker directly and judge its real output; and',
+        '   unless the spec required that tolerance, the script itself is a defect — the',
+        '   verdict is FAIL naming it.',
+        '',
+        '4g. TWO RUNNERS, ONE FILE SET, NO RESULTS — when a project declares more than one',
+        '   test runner, check that each collects only its own files. A runner that scans for',
+        "   `*.test.*` / `*.spec.*` project-wide will import another runner's specs and abort",
+        '   during COLLECTION. That failure mode looks nothing like a test failure: you get an',
+        '   import error, or a suite that reports zero tests. Always read how many tests each',
+        '   command actually COLLECTED and RAN; zero collected is never a pass.',
+        '',
         '5. The ONLY thing you may assume is already provided is a genuinely EXTERNAL running',
         '   service or network resource (a database server, an API host) that the project',
         '   documents as a prerequisite. Before you rely on that assumption, PROBE for the',
@@ -572,6 +659,39 @@ export async function runWorkVerification(deps) {
             crossDeletions = [];
         }
     }
+    // Sandbox-path-leak findings the deterministic repair could NOT fix, injected
+    // under rule 4e. A probe failure must never block verification.
+    let foreignPaths = [];
+    if (deps.foreignPathProbe) {
+        try {
+            foreignPaths = await deps.foreignPathProbe();
+        }
+        catch {
+            foreignPaths = [];
+        }
+    }
+    // Neutered check scripts in a manifest this task changed, injected under rule
+    // 4f. A probe failure must never block verification.
+    let scriptEscapes = [];
+    if (deps.scriptEscapeProbe) {
+        try {
+            scriptEscapes = await deps.scriptEscapeProbe();
+        }
+        catch {
+            scriptEscapes = [];
+        }
+    }
+    // Colliding test-runner globs, injected under rule 4g. A probe failure must
+    // never block verification.
+    let runnerGlobs = [];
+    if (deps.runnerGlobProbe) {
+        try {
+            runnerGlobs = await deps.runnerGlobProbe();
+        }
+        catch {
+            runnerGlobs = [];
+        }
+    }
     // Environment facts from earlier gate children (best-effort; a cache failure
     // must never block verification).
     let envNotes = '';
@@ -607,7 +727,11 @@ export async function runWorkVerification(deps) {
     for (let attempt = 1;; attempt++) {
         let text;
         try {
-            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming, crossTaskDeletionVerifyFindings(crossDeletions)), deps.signal);
+            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming, crossTaskDeletionVerifyFindings(crossDeletions), {
+                foreignPaths,
+                scriptEscapes,
+                runnerGlobs
+            }), deps.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === USER_CANCELLED)

package/dist/workers/research-cache.d.ts

@@ -22,6 +22,33 @@ export declare function configureResearchRun(enabled: boolean): string | undefin
  * of asking the same thing resolve to the same (correct) result.
  */
 export declare function normalizeQuery(s: string): string;
+/**
+ * A stable fingerprint of the project's declared dependency surface — the only input a
+ * cached docs digest actually depends on (a digest summarises a package's INSTALLED
+ * types/README at a pinned version). Built from package.json's dependency blocks with
+ * keys sorted, so formatting churn or an unrelated field edit does not invalidate it,
+ * while any add/remove/version-bump does.
+ *
+ * Returns undefined when the manifest is missing or unparseable — the caller then has
+ * NO positive evidence of freshness and must not reuse. Deliberately NOT the lockfile's
+ * hash or mtime: a lockfile is rewritten by installs that do not change any resolved
+ * version, which would defeat reuse for no correctness gain.
+ */
+export declare function depsFingerprint(cwd: string): Promise<string | undefined>;
+/**
+ * Resume hook: reuse the interrupted run's cache id when — and only when — the file
+ * proves it describes the same dependency surface. Returns the id now stamped into the
+ * environment (reused or fresh), or undefined when caching is off.
+ *
+ * Every uncertain path falls through to a fresh id, which merely re-fetches:
+ * caching disabled, no/corrupt cache file, a file with no fingerprint (written before
+ * this shipped), an unreadable manifest, or a fingerprint that no longer matches.
+ */
+export declare function resumeResearchRun(cwd: string, enabled: boolean): Promise<{
+    runId: string | undefined;
+    reused: boolean;
+    entries: number;
+}>;
 /**
  * Look up a cached result for `key` in the current run. Returns undefined on a miss,
  * a stale-run file (different id ⇒ another run's digest, ignored), or any failure.

package/dist/workers/research-cache.js

@@ -25,11 +25,29 @@
  * a run started with the feature flag OFF (no id in the environment) does not cache
  * at all — the cache is inert unless the orchestrator turned it on for this run.
  *
+ * RESUME REUSE (mx5 run 13, measured from the file's own git history — the cache is
+ * committed with every task, so the whole run is recoverable): a 32-task run built the
+ * cache to 201 entries over 20 tasks under one run id, then three /task-auto-resume
+ * invocations each stamped a fresh id and the first store of each dropped everything —
+ * 201 → 11 → 3 → 5 → 8. The audit read the 8-entry tail and concluded the cache was
+ * near-useless; it was in fact working, and the resume threw the work away. The old
+ * comment called a resume re-fetch "only slightly less reuse", which holds for a
+ * 5-task run and fails badly for a 32-task one.
+ *
+ * So a resume now REUSES the interrupted run's id — but only on POSITIVE evidence that
+ * the digests still describe the same dependency surface. The staleness that matters is
+ * a package version moving under a cached answer (a docs digest summarises the
+ * INSTALLED types of a pinned package), so the file records a fingerprint of the
+ * manifest's dependency block and a resume reuses the id only when that fingerprint is
+ * unchanged. Missing, unparseable, or fingerprint-less file ⇒ fresh id and a re-fetch:
+ * every inconclusive path costs time, never correctness.
+ *
  * Stored under `.pi-tasks/` (sibling of env-notes.md / contracts.md), which the
  * git-state guard and discardEdits both exclude. Best-effort throughout: any I/O or
  * parse failure falls back to a live fetch — the cache only ever saves time, it can
  * never change an answer or block a worker.
  */
+import { createHash } from 'node:crypto';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { tasksDir } from '../task/task-io.js';
@@ -81,6 +99,72 @@ export function configureResearchRun(enabled) {
 export function normalizeQuery(s) {
     return s.replace(/\s+/g, ' ').trim().toLowerCase();
 }
+/**
+ * A stable fingerprint of the project's declared dependency surface — the only input a
+ * cached docs digest actually depends on (a digest summarises a package's INSTALLED
+ * types/README at a pinned version). Built from package.json's dependency blocks with
+ * keys sorted, so formatting churn or an unrelated field edit does not invalidate it,
+ * while any add/remove/version-bump does.
+ *
+ * Returns undefined when the manifest is missing or unparseable — the caller then has
+ * NO positive evidence of freshness and must not reuse. Deliberately NOT the lockfile's
+ * hash or mtime: a lockfile is rewritten by installs that do not change any resolved
+ * version, which would defeat reuse for no correctness gain.
+ */
+export async function depsFingerprint(cwd) {
+    try {
+        const raw = await fsp.readFile(path.join(cwd, 'package.json'), 'utf8');
+        const pkg = JSON.parse(raw);
+        const blocks = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ];
+        const parts = [];
+        for (const block of blocks) {
+            const deps = pkg[block];
+            if (!deps || typeof deps !== 'object')
+                continue;
+            const entries = Object.entries(deps)
+                .filter(([, v]) => typeof v === 'string')
+                .sort(([a], [b]) => a < b ? -1
+                : a > b ? 1
+                    : 0)
+                .map(([k, v]) => `${k}@${String(v)}`);
+            if (entries.length > 0)
+                parts.push(`${block}:${entries.join(',')}`);
+        }
+        // No dependency block at all is a real, stable state (a dependency-free repo) —
+        // fingerprint it as such rather than failing, so reuse still works there.
+        return createHash('sha256').update(parts.join('|')).digest('hex').slice(0, 32);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resume hook: reuse the interrupted run's cache id when — and only when — the file
+ * proves it describes the same dependency surface. Returns the id now stamped into the
+ * environment (reused or fresh), or undefined when caching is off.
+ *
+ * Every uncertain path falls through to a fresh id, which merely re-fetches:
+ * caching disabled, no/corrupt cache file, a file with no fingerprint (written before
+ * this shipped), an unreadable manifest, or a fingerprint that no longer matches.
+ */
+export async function resumeResearchRun(cwd, enabled) {
+    if (!enabled) {
+        delete process.env[RESEARCH_RUN_ID_ENV];
+        return { runId: undefined, reused: false, entries: 0 };
+    }
+    const file = await readCacheFile(cwd);
+    const current = await depsFingerprint(cwd);
+    if (file && file.deps !== undefined && current !== undefined && file.deps === current) {
+        process.env[RESEARCH_RUN_ID_ENV] = file.runId;
+        return { runId: file.runId, reused: true, entries: Object.keys(file.entries).length };
+    }
+    return { runId: configureResearchRun(true), reused: false, entries: 0 };
+}
 async function readCacheFile(cwd) {
     try {
         const raw = await fsp.readFile(researchCacheFile(cwd), 'utf8');
@@ -127,7 +211,16 @@ export async function storeResearch(cwd, runId, key, text, details) {
             for (const k of ordered.slice(0, keys.length - MAX_ENTRIES))
                 delete entries[k];
         }
-        const out = { runId, entries };
+        // Stamp the dependency surface these entries were produced against, so a later
+        // resume can prove they are still fresh. Unreadable manifest ⇒ field omitted,
+        // which reads as "cannot prove freshness" and simply denies reuse.
+        //
+        // FROZEN at the run's first write, deliberately: if a task installs a package
+        // mid-run and we re-fingerprinted here, the new fingerprint would bless digests
+        // taken BEFORE the install as current. Keeping the original means a mid-run
+        // install makes a later resume mismatch and re-fetch — the safe direction.
+        const deps = existing && existing.runId === runId ? existing.deps : await depsFingerprint(cwd);
+        const out = deps === undefined ? { runId, entries } : { runId, entries, deps };
         await fsp.mkdir(tasksDir(cwd), { recursive: true });
         // Atomic-ish write so a concurrent reader never sees a half-written file.
         const tmp = `${researchCacheFile(cwd)}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;

package/package.json

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