@mjasnikovs/pi-task 0.37.6 → 0.38.0

package/dist/task/task-gates.js

@@ -3,6 +3,11 @@ import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
 import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
 import { attributeEnforceFailure } from './enforce-attribution.js';
+// The debt ledger is reached through the injected `recordDebt` dep (so it stays
+// absent-in-tests); only the origin TYPE and the cross-task-deletion reason SHAPE
+// come from accept-debt.ts directly — the latter because its writer and its
+// re-check-side parser (extractDeletedDebtPath) have to move together.
+import { crossTaskDeletionReason } from './accept-debt.js';
 /**
  * How many times a verify FAIL may be auto-fixed UNATTENDED (the research
  * recommended AUTOFIX, so pi re-runs the impl turn without prompting) before the
@@ -115,7 +120,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
             });
             if (!candidate)
                 return null;
-            await deps.recordRootCauseDebt?.(p.cwd, p.taskId, `${failReason} — ROOT CAUSE: \`${candidate.file}\` (introduced by ${candidate.owner}, not touched by this task)`);
+            await deps.recordDebt?.(p.cwd, p.taskId, `${failReason} — ROOT CAUSE: \`${candidate.file}\` (introduced by ${candidate.owner}, not touched by this task)`, 'root-cause');
             await deps.recordRepairCandidate?.(p.cwd, candidate);
             await rec(`root-cause: FAIL attributed to \`${candidate.file}\` — a pre-existing defect in ${candidate.owner}'s file that this task never touched; `
                 + 'recorded as durable debt and a scoped repair task queued');
@@ -223,7 +228,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 // final gate must surface it at run end (static-class: it auto-closes
                 // iff the run-end static check passes).
                 try {
-                    await deps.recordFrozenBlockedDebt?.(p.cwd, p.taskId, `${failReason} — ${frozenContradiction}`);
+                    await deps.recordDebt?.(p.cwd, p.taskId, `${failReason} — ${frozenContradiction}`, 'frozen-blocked');
                 }
                 catch {
                     // recording must never break the gate sequence
@@ -310,12 +315,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                         // Provenance splits here, mandatorily: an auto-pick writes the
                         // 'yolo-accepted' origin, never the plain 'accepted' one that
                         // asserts a human weighed the failing artifact.
-                        if (byYolo) {
-                            await deps.recordYoloAcceptDebt?.(p.cwd, p.taskId, failReason);
-                        }
-                        else {
-                            await deps.recordAcceptDebt?.(p.cwd, p.taskId, failReason);
-                        }
+                        await deps.recordDebt?.(p.cwd, p.taskId, failReason, byYolo ? 'yolo-accepted' : 'accepted');
                     }
                     catch {
                         // recording must never break the gate sequence
@@ -331,7 +331,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 // the final gate re-checks them (mx5 run 12 PROMPT 2). Best-effort.
                 for (const del of verified.crossTaskDeletions ?? []) {
                     try {
-                        await deps.recordCrossTaskDeletionDebt?.(p.cwd, p.taskId, del);
+                        await deps.recordDebt?.(p.cwd, p.taskId, crossTaskDeletionReason(del), 'cross-task-deletion');
                         await rec(`accept-debt: cross-task deletion recorded — ${del.path} (${del.owner}'s deliverable)`);
                     }
                     catch {
@@ -581,7 +581,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                     // Keeping the edits must NOT lose the finding — that was mx5 run
                     // 5's mistake. Same durability as the revert path; only the
                     // disposition of the edits differs.
-                    await deps.recordEnforceKeptDebt?.(p.cwd, p.taskId, afterReason);
+                    await deps.recordDebt?.(p.cwd, p.taskId, afterReason, 'enforce-kept');
                     // …and, when the named file is somebody else's committed work,
                     // queue the scoped repair so something actually FIXES it.
                     if (attribution.file && deps.introducedBy && deps.recordRepairCandidate) {
@@ -622,7 +622,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                     // erasing it with the enforce edits buried the terminal fault 8.5h
                     // before run end. The final gate re-checks/surfaces it (static-class
                     // auto-closes if a later task fixed the statics; else stays open).
-                    await deps.recordEnforceRevertDebt?.(p.cwd, p.taskId, after.reason ?? 'enforce re-verify failed');
+                    await deps.recordDebt?.(p.cwd, p.taskId, after.reason ?? 'enforce re-verify failed', 'enforce-revert');
                     active.ui.notify(`${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
                 }
                 else {

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

@@ -44,43 +44,51 @@ export interface VerifyOutcome {
  */
 export declare function extractSpecForVerification(taskBody: string): string | null;
 /**
- * Build the verification child's prompt. Kept pure so the wording is unit-tested
- * without spawning pi. The contract: run the spec's own verification in the real
- * workspace, judge against ACCEPTANCE, and end on exactly one verdict line.
+ * ─────────────────────────── THE PROBE TABLE ───────────────────────────
+ *
+ * Every deterministic probe that sharpens this prompt used to cost the same
+ * ritual in four places: a `let x = []` + try/catch in runWorkVerification, a
+ * positional parameter on buildVerifyPrompt, a `const xBlock =` ternary, and a
+ * spread into the assembled prompt — plus its hand-numbered rule. Adding one
+ * meant editing all of them and hoping none was missed; the ninth would not
+ * even fit the signature (hence the `projectSurface` bag that used to group
+ * three of them).
  *
- * `probeFindings` are the deterministic self-verification probe results (see
- * substitution-probe.ts): the TEST-THE-COPY class is caught 5/5 only when the
- * prompt carries both the rule (3b) AND a concrete finding naming the suspect
- * file — the rule alone got 2/5 attention on the local model. The findings are
- * pure git shape (test files the task itself changed), so the mandate is
- * language- and framework-agnostic.
+ * Each probe is now an ADAPTER: one row carrying only what is specific to it —
+ * the dep field it reads, the empty value it degrades to, how its raw result
+ * becomes finding lines, the notice block those lines produce, and the numbered
+ * rule the notice routes the child to. The loop owns the ritual. (Same shape as
+ * LOCKFILE_CHECKS in final-gate.ts, where a whole package ecosystem is one row.)
  *
- * `prohibitionFindings` are the deterministic prohibition probe results (see
- * prohibition-probe.ts): spec-forbidden paths the task's diff modified anyway.
- * Same probe+rule design, same reason: the VIOLATION-EXCUSAL class (mx5 run 7:
- * child saw "Do NOT modify server-side code" violated, waived it as "additive,
- * tests pass", PASSed) needs both the no-waiver rule (4b) AND the concrete diff
- * fact — the baseline child usually never runs `git diff` at all, so without the
- * finding it cannot even SEE the violation. A/B on the live local model
- * (violated-but-working fixture, everything green, forbidden file modified
- * additively): old prompt 5/5 false-PASS (several runs affirmatively claimed the
- * forbidden file was untouched); rule+finding 5/5 FAIL naming the constraint.
- * 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).
+ * THIS PROMPT IS A MEASURED ARTIFACT — its wording is A/B-tested on the live
+ * local model and the verdicts are recorded in VALIDATION-DEBT.md, so the table
+ * must emit BYTE-IDENTICAL text for the same findings. Two orders are
+ * load-bearing and they are NOT the same order:
+ *   - NOTICE BLOCKS are emitted in TABLE order (the order the rows appear below).
+ *   - RULES are emitted sorted by `ruleId`, because the 4b…4g band was
+ *     hand-numbered long before this table existed and its numbering is what the
+ *     notices cite ("rule 4b applies").
+ * A row whose rule is woven into the numbered narrative elsewhere (3b inside the
+ * substitution rules, 3f, 5c) carries `ruleId` for the reader and no `rule` text.
  */
-export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[], crossTaskDeletionFindings?: string[], 
+/** Stable identity of one probe channel: table row ↔ findings-bag key. */
+export type ProbeKey = 'substitution' | 'prohibition' | 'crossTaskDeletion' | 'probeGaming' | 'skipEscape' | 'foreignPath' | 'scriptEscape' | 'runnerGlob' | 'testAssembly';
+/** The finding lines each probe channel contributed. Absent/empty ⇒ no block. */
+export type ProbeFindings = Partial<Record<ProbeKey, string[]>>;
 /**
- * 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.
+ * Build the verification child's prompt. Kept pure so the wording is unit-tested
+ * without spawning pi. The contract: run the spec's own verification in the real
+ * workspace, judge against ACCEPTANCE, and end on exactly one verdict line.
+ *
+ * `findings` is the probe bag: one key per PROBE_ADAPTERS row (see the table
+ * above for what each channel means and the A/B evidence behind it). A key that
+ * is absent or empty emits no block — the probes are independently optional.
  */
-projectSurface?: {
-    /** Sandbox-leaked absolute paths (rule 4e) — see foreign-path.ts. */
-    foreignPaths?: string[];
-    /** Check scripts that cannot fail (rule 4f) — see script-escape.ts. */
-    scriptEscapes?: string[];
-    /** Colliding test-runner globs (rule 4g) — see runner-globs.ts. */
-    runnerGlobs?: string[];
+export declare function buildVerifyPrompt(spec: string, findings?: ProbeFindings, context?: {
+    /** Environment facts earlier gate children discovered — see env-notes.ts. */
+    envNotes?: string;
+    /** Cross-slice interface facts the design pins — see contracts.ts. */
+    contracts?: string;
 }): string;
 /**
  * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL|UNOBSERVED`