@mjasnikovs/pi-task 0.18.21 → 0.18.23

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

@@ -1,3 +1,4 @@
+import { type CrossTaskDeletion } from './task-provenance.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -27,6 +28,12 @@ export interface VerifyOutcome {
      *  AUTOFIX re-run, which cannot provision a missing tool. Only meaningful when
      *  ok === false. */
     unobserved?: boolean;
+    /** The deterministic cross-task deletion findings (see task-provenance.ts) that
+     *  were live when this verdict was produced: sibling tasks' committed
+     *  deliverables this task's diff deletes. Carried on a FAIL so the gate loop
+     *  can record each as a durable debt if the user ACCEPTs anyway — the deletion
+     *  then ships in the next commit and the final gate must re-check it. */
+    crossTaskDeletions?: CrossTaskDeletion[];
 }
 /**
  * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
@@ -61,7 +68,7 @@ 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[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[]): string;
+export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[], crossTaskDeletionFindings?: string[]): string;
 /**
  * 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
@@ -130,6 +137,15 @@ export interface VerificationDeps {
      * underlying requirement is genuinely met rather than trusting the green check.
      * Pure diff-text analysis; ABSENT or empty → no probe block. */
     probeGamingProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC cross-task deletion probe (see task-provenance.ts, mx5 run 12
+     * PROMPT 2): tracked files the task's diff DELETES whose introducing task (git
+     * provenance) differs from the current task — a sibling's committed deliverable
+     * destroyed, typically to green a check. Injected as prompt findings under rule
+     * 4d (MANDATORY + verdict-gating, the A/B-proven shape — buried rules score
+     * 0/5), and carried structurally on a FAIL outcome so an ACCEPT records each as
+     * a durable debt. ABSENT or empty → no block. */
+    crossTaskDeletionProbe?: () => Promise<CrossTaskDeletion[]>;
     /**
      * 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

package/dist/task/verify-work.js

@@ -71,6 +71,7 @@ import { USER_CANCELLED } from './child-runner.js';
 import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from './env-notes.js';
 import { buildContractsVerifyBlock } from './contracts.js';
 import { findSkipEscapes, skipEscapeVerifyFindings } from './skip-escape.js';
+import { crossTaskDeletionVerifyFindings } from './task-provenance.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -139,7 +140,7 @@ 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) {
+export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings, crossTaskDeletionFindings) {
     const probeBlock = probeFindings && probeFindings.length > 0 ?
         [
             'SELF-VERIFICATION NOTICE (deterministic, computed by the orchestrator from the diff):',
@@ -166,6 +167,22 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
             ''
         ]
         : [];
+    const crossTaskDeletionBlock = crossTaskDeletionFindings && crossTaskDeletionFindings.length > 0 ?
+        [
+            'CROSS-TASK DELETION NOTICE (deterministic, computed by the orchestrator from',
+            "git provenance over the task's diff): this task's work DELETED committed",
+            'deliverable(s) that a DIFFERENT, already-completed task introduced:',
+            ...crossTaskDeletionFindings.map(f => `- ${f}`),
+            "A sibling task's verified, committed deliverable is not this task's to remove.",
+            'Deleting the file a checker complains about is the cheapest way to turn a red',
+            'check green — the finding vanishes with the file — and it destroys finished',
+            'work (rule 4d). A green check suite on the shrunken tree is NOT a waiver.',
+            "Unless THIS task's spec explicitly REQUIRES removing exactly that file, the",
+            'verdict is FAIL naming the deleted file and its owning task — even if every',
+            'check passes and the deletion made them pass.',
+            ''
+        ]
+        : [];
     const probeGamingBlock = probeGamingFindings && probeGamingFindings.length > 0 ?
         [
             'CHECK-GAMING NOTICE (deterministic, computed by the orchestrator from the',
@@ -235,6 +252,7 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         ...contractsBlock,
         ...probeBlock,
         ...prohibitionBlock,
+        ...crossTaskDeletionBlock,
         ...probeGamingBlock,
         ...skipEscapeBlock,
         ...testAssemblyBlock,
@@ -359,6 +377,17 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   check, not implementing the behavior). If the requirement is genuinely unmet while',
         '   the check passes, the verdict is FAIL naming the gamed check and the real gap.',
         '',
+        "4d. A SIBLING TASK'S COMMITTED DELIVERABLE IS NOT THIS TASK'S TO DELETE — check the",
+        "   task's own diff (git) for DELETED tracked files. A file that a DIFFERENT completed",
+        "   task introduced and committed, deleted by this task's work, is finished work",
+        '   destroyed — usually to make a red check go green (the file the checker complains',
+        '   about simply disappears; that is quieting the messenger, rule 4c, not fixing the',
+        '   defect). A passing check suite on the shrunken tree is not a waiver. Only two',
+        "   outcomes are not a FAIL: THIS task's spec explicitly requires that removal, or",
+        '   the deletion is a genuine relocation (the same file lives on elsewhere in the',
+        '   tree). Otherwise the verdict is FAIL naming the deleted file and the task that',
+        '   owns it.',
+        '',
         '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',
@@ -531,6 +560,18 @@ export async function runWorkVerification(deps) {
             probeGaming = [];
         }
     }
+    // Cross-task deletion findings feed the prompt (rule 4d) AND ride on a FAIL
+    // outcome (structured) so an ACCEPT can record them as durable debts. A probe
+    // failure must never block verification.
+    let crossDeletions = [];
+    if (deps.crossTaskDeletionProbe) {
+        try {
+            crossDeletions = await deps.crossTaskDeletionProbe();
+        }
+        catch {
+            crossDeletions = [];
+        }
+    }
     // Environment facts from earlier gate children (best-effort; a cache failure
     // must never block verification).
     let envNotes = '';
@@ -566,7 +607,7 @@ 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), deps.signal);
+            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming, crossTaskDeletionVerifyFindings(crossDeletions)), deps.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === USER_CANCELLED)
@@ -603,15 +644,25 @@ export async function runWorkVerification(deps) {
             return { ok: true };
         if (verdict.detail === 'no verdict emitted' && attempt === 1)
             continue;
+        // Structured cross-task deletion findings ride on every FAIL outcome: if the
+        // human ACCEPTs the failing artifact, the deletions ship in the next commit
+        // and the gate loop must record each as a durable debt (see task-gates.ts).
+        const deletions = crossDeletions.length > 0 ? { crossTaskDeletions: crossDeletions } : {};
         // UNOBSERVED (rule 5c): a spec-required behavioral check could not run because
         // its tooling is absent. Block like any FAIL, but flag it so the gate hands it
         // straight to the human — re-running the impl turn cannot install a missing tool.
         if (verdict.unobserved) {
-            return { ok: false, unobserved: true, reason: `work unobserved: ${verdict.detail}` };
+            return {
+                ok: false,
+                unobserved: true,
+                reason: `work unobserved: ${verdict.detail}`,
+                ...deletions
+            };
         }
         return {
             ok: false,
-            reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`
+            reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`,
+            ...deletions
         };
     }
 }

package/dist/task/write-guard.d.ts

@@ -36,6 +36,16 @@ export interface TreeChangeSummary {
  * without a repo.
  */
 export declare function parseTreeChanges(porcelain: string): TreeChangeSummary;
+/**
+ * Parse `git diff --name-status` output (tab-separated: `M\tpath`, `A\tpath`,
+ * `D\tpath`, `R100\told\tnew`, `C75\told\tnew`) into the same change summary. Used
+ * where the working tree is already clean and the last COMMIT's diff is the record
+ * of the task's changes (the post-enforce re-verify fallback). A rename entry
+ * contributes its source to `deleted` and its target to `added`, matching
+ * parseTreeChanges so the relocation allowance below reads both shapes identically;
+ * a copy's source still exists, so only its target counts (as added).
+ */
+export declare function parseNameStatusChanges(nameStatus: string): TreeChangeSummary;
 /**
  * The deletions a fix pass may NOT make: every deleted tracked file whose name does
  * not reappear among the added files (a relocation keeps the file, under the same

package/dist/task/write-guard.js

@@ -75,6 +75,46 @@ export function parseTreeChanges(porcelain) {
     }
     return { modified: [...modified], deleted: [...deleted], added: [...added] };
 }
+/**
+ * Parse `git diff --name-status` output (tab-separated: `M\tpath`, `A\tpath`,
+ * `D\tpath`, `R100\told\tnew`, `C75\told\tnew`) into the same change summary. Used
+ * where the working tree is already clean and the last COMMIT's diff is the record
+ * of the task's changes (the post-enforce re-verify fallback). A rename entry
+ * contributes its source to `deleted` and its target to `added`, matching
+ * parseTreeChanges so the relocation allowance below reads both shapes identically;
+ * a copy's source still exists, so only its target counts (as added).
+ */
+export function parseNameStatusChanges(nameStatus) {
+    const modified = new Set();
+    const deleted = new Set();
+    const added = new Set();
+    for (const raw of nameStatus.split('\n')) {
+        const parts = raw.split('\t').map(s => s.trim());
+        const code = parts[0] ?? '';
+        if (code.length === 0 || !parts[1])
+            continue;
+        if (code.startsWith('R')) {
+            deleted.add(parts[1]);
+            if (parts[2])
+                added.add(parts[2]);
+            continue;
+        }
+        if (code.startsWith('C')) {
+            added.add(parts[2] ?? parts[1]);
+            continue;
+        }
+        if (code.startsWith('D')) {
+            deleted.add(parts[1]);
+            continue;
+        }
+        if (code.startsWith('A')) {
+            added.add(parts[1]);
+            continue;
+        }
+        modified.add(parts[1]);
+    }
+    return { modified: [...modified], deleted: [...deleted], added: [...added] };
+}
 const basename = (p) => {
     const i = p.lastIndexOf('/');
     return i === -1 ? p : p.slice(i + 1);

package/package.json

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