@mjasnikovs/pi-task 0.28.1 → 0.28.2

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

@@ -55,6 +55,25 @@ export interface AutoDeps extends GateDeps {
      * handling is skipped entirely (prior behavior).
      */
     pendingChanges?: (cwd: string) => Promise<string[]>;
+    /**
+     * Re-derive the still-open ACCEPT-debt ledger against the tree AS IT IS NOW
+     * (final-gate.ts `deriveOpenDebts`). Needed because the run's "N recorded
+     * verify-FAIL defect(s) are STILL unresolved" report used to be built from the
+     * FIRST gate result and the converged-autofix path then rebuilt the gate
+     * outcome as a bare `{ok, reason}` — so `openDebts` was not merely un-actioned,
+     * it was GONE from the value, and no code path could ever clear, re-check or
+     * act on it (mx5 run 18: four defects reported STILL OPEN at 14:58, one of them
+     * fixed by the autofix that converged at 15:03, and the report never moved).
+     *
+     * `staticOk` is the caller's PROOF about the current statics, never a guess:
+     * pass true only where the gate itself just passed them. Absent (tests) → the
+     * post-autofix re-check is skipped and the pre-autofix report stands, exactly
+     * the prior behavior.
+     */
+    recheckOpenDebts?: (cwd: string, staticOk: boolean) => Promise<{
+        openDebts: AcceptDebt[];
+        debtNote?: string;
+    }>;
 }
 /**
  * Expand any @file references in the feature text by appending each referenced

package/dist/task/auto-orchestrator.js

@@ -33,7 +33,7 @@ import { getParentContextWindow, resolveContextUsage } from './context-usage.js'
 import { buildGateDeps, collectTreeChanges } from './gate-deps.js';
 import { runGatesForTask } from './task-gates.js';
 import { gitUnmergedPaths, gitStashRef } from './auto-commit.js';
-import { runFinalIntegrationGate } from './final-gate.js';
+import { runFinalIntegrationGate, deriveOpenDebts } from './final-gate.js';
 import { describeDebt, recordFinalGateUnobservedDebt } from './accept-debt.js';
 import { applyDemotions, isNonProgress, normalizeFailureDetail, rankedFirstFailure, unobservedDebtReason } from './final-gate-progress.js';
 import { classifyFinalGateAnswer, MAX_FINAL_GATE_AUTOFIX, FINAL_LEAVE_LABEL, FINAL_LEAVE_VALUE, FINAL_ACCEPT_LABEL, FINAL_ACCEPT_VALUE, FINAL_AUTOFIX_LABEL, FINAL_AUTOFIX_VALUE, STRANDED_FIX_COMMIT, strandedFixNote } from './final-gate-fix.js';
@@ -1103,7 +1103,11 @@ function defaultDeps(ctx, cwd, signal, title) {
         pendingChanges: async (cwd2) => {
             const changes = await collectTreeChanges(cwd2, signal);
             return [...changes.modified, ...changes.added, ...changes.deleted].sort();
-        }
+        },
+        // Re-derive the debt ledger against the FINAL tree after a converged
+        // autofix (nexttask 6). Only ever reached from inside the gate's own
+        // resolution loop, so it needs no `verify work` switch of its own.
+        recheckOpenDebts: (cwd2, staticOk) => deriveOpenDebts(cwd2, staticOk)
     };
 }
 // ─── Loop ────────────────────────────────────────────────────────────────────
@@ -1222,12 +1226,79 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     // gate moment — on PASS or FAIL — so a run never completes silently
                     // carrying an accepted defect. Informational: the per-task ACCEPT was
                     // already a human decision, so this reports, it does not re-fail.
-                    if (fin.openDebts && fin.openDebts.length > 0) {
-                        for (const d of fin.openDebts) {
+                    const debtKey = (d) => `${d.taskId}\t${d.reason}`;
+                    const surfaceOpenDebts = async (debts) => {
+                        if (debts.length === 0)
+                            return;
+                        for (const d of debts) {
                             await recGate(`defect STILL OPEN — ${d.taskId || '(unknown task)'}: ${describeDebt(d)}: ${d.reason.slice(0, 240)}${d.conflict ? ` [CONFLICTING CLAIM — ${d.conflict}]` : ''}`);
                         }
-                        active.ui.notify(`${id}: ${fin.openDebts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
-                    }
+                        active.ui.notify(`${id}: ${debts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
+                    };
+                    // What was REPORTED, so a post-autofix re-derivation can be
+                    // compared against it rather than blindly re-printed.
+                    let reportedDebts = fin.openDebts ?? [];
+                    await surfaceOpenDebts(reportedDebts);
+                    /**
+                     * nexttask 6 (mx5 run 18). The lines above are emitted from the
+                     * FIRST gate result; the converged-autofix paths below used to
+                     * rebuild `fin` as `{ok, reason}`, so `openDebts` did not survive
+                     * the fix pass — the run's last word on its own defects was a
+                     * snapshot of a tree that no longer existed, and no code path
+                     * could clear, re-check or act on it. Re-derive here, against the
+                     * tree the run actually ends with, and correct the record.
+                     *
+                     * FP-safe by inheritance: `deriveOpenDebts` auto-closes only what
+                     * a deterministic check can stand behind (a static-class debt when
+                     * the statics provably pass, a cross-task-deletion whose file is
+                     * back). Anything model-judged or behavioral STAYS OPEN —
+                     * `inv-no-false-clear`. `staticOk` is therefore only ever passed
+                     * true where the gate itself just passed the statics.
+                     */
+                    const reconcileDebts = async (staticOk) => {
+                        if (!deps.recheckOpenDebts)
+                            return;
+                        let fresh;
+                        try {
+                            fresh = await deps.recheckOpenDebts(cwd, staticOk);
+                        }
+                        catch {
+                            // A ledger read fault is inconclusive: say nothing rather
+                            // than imply the defects cleared.
+                            return;
+                        }
+                        fin = {
+                            ...fin,
+                            openDebts: fresh.openDebts,
+                            ...(fresh.debtNote ? { debtNote: fresh.debtNote } : {})
+                        };
+                        // Identity is (task, origin, reason), but a RESOLUTION claim
+                        // needs more than a key miss: a ledger entry whose TEXT changed
+                        // is the same defect re-recorded, never a fix. So a debt counts
+                        // as closed only when nothing for that (task, origin) survives.
+                        const slot = (d) => `${d.taskId}\t${d.origin ?? ''}`;
+                        const before = new Set(reportedDebts.map(debtKey));
+                        const after = new Set(fresh.openDebts.map(debtKey));
+                        const beforeSlots = new Set(reportedDebts.map(slot));
+                        const afterSlots = new Set(fresh.openDebts.map(slot));
+                        const closed = reportedDebts.filter(d => !after.has(debtKey(d)) && !afterSlots.has(slot(d)));
+                        const added = fresh.openDebts.filter(d => !before.has(debtKey(d)) && !beforeSlots.has(slot(d)));
+                        if (closed.length === 0 && added.length === 0) {
+                            if (reportedDebts.length > 0) {
+                                await recGate(`defect re-check after autofix: all ${reportedDebts.length} defect(s) `
+                                    + 'above re-derived against the FINAL tree and still open');
+                            }
+                            return;
+                        }
+                        for (const d of closed) {
+                            await recGate(`defect RESOLVED by the final-gate autofix — ${d.taskId || '(unknown task)'}: `
+                                + `${d.reason.slice(0, 240)}`);
+                        }
+                        await surfaceOpenDebts(added);
+                        reportedDebts = fresh.openDebts;
+                        await recGate(`defect re-check after autofix: ${closed.length} resolved, `
+                            + `${fresh.openDebts.length} still open (re-derived against the FINAL tree)`);
+                    };
                     // Resolution loop: Leave-failed (recommended) / Autofix (bounded,
                     // model-driven fix pass + gate re-run — run 7's gap: the picker
                     // had NO automated fix path) / Accept. The user always decides;
@@ -1371,6 +1442,9 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                                 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 };
+                                // The gate itself just passed, statics included, so
+                                // `staticOk` here is proof rather than assumption.
+                                await reconcileDebts(true);
                                 break;
                             }
                             await recGate(`final-gate: autofix attempt ${fixAttempts} failed — ${fix.reason.slice(0, 200)}`);
@@ -1434,6 +1508,12 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                                     await recGate(`final-gate: ${converged}`);
                                     active.ui.notify(`${id}: final integration gate converged — ${converged}.`, 'warning');
                                     fin = { ok: true, reason: converged };
+                                    // Converged on the REMAINING checks only: one or
+                                    // more were DEMOTED as unfalsifiable here, and the
+                                    // statics may be among them. No proof ⇒ pass false,
+                                    // so nothing static-class can auto-close on this
+                                    // door (inv-no-false-clear).
+                                    await reconcileDebts(false);
                                     break;
                                 }
                             }

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

@@ -446,6 +446,30 @@ export declare function bootSkipVerdict(args: {
     expectServer: boolean;
 }): string | null;
 export { taskThatIntroduced };
+/**
+ * ACCEPT-debt re-check (mx5 run 4 B3 / run 8 TASK_0012): read the ledger of tasks
+ * the user accepted despite a verify-FAIL and re-check each against the CURRENT
+ * tree. A static-class debt whose statics now pass is provably RESOLVED (a later
+ * task fixed it) and pruned from the ledger; every other debt cannot be proven
+ * resolved deterministically, so it stays OPEN and is surfaced — a run may not
+ * complete silently carrying an accepted defect. FP-safe by construction (see
+ * accept-debt.ts). Best-effort: a ledger read/write failure must never break the
+ * caller.
+ *
+ * FACTORED OUT of runFinalIntegrationGate (nexttask 6): the derivation has to be
+ * runnable at a SECOND moment — after a converged final-gate autofix, where the
+ * orchestrator used to rebuild its gate outcome as a bare `{ok, reason}` and drop
+ * `openDebts` entirely. The report a run ends on has to be derived from the tree
+ * the run ends with, not from the tree as it was before the fix pass.
+ *
+ * `staticOk` is the caller's claim about the CURRENT statics, and it is the only
+ * thing that can auto-close a static-class debt — so a caller that does not know
+ * must pass `false` (unprovable ⇒ stays open), never a guess.
+ */
+export declare function deriveOpenDebts(cwd: string, staticOk: boolean): Promise<{
+    openDebts: AcceptDebt[];
+    debtNote?: string;
+}>;
 /**
  * Run the final gate: static analysis first, then the lockfile consistency
  * checks, then the discovered integration commands, then one boot exercise of

package/dist/task/final-gate.js

@@ -1132,6 +1132,44 @@ async function recoverOrphanPort(cwd, boot, first, bootGraceMs, deps, expectServ
 // PROMPT 2 extracted it for the cross-task deletion guards); re-exported so
 // existing importers keep working.
 export { taskThatIntroduced };
+/**
+ * ACCEPT-debt re-check (mx5 run 4 B3 / run 8 TASK_0012): read the ledger of tasks
+ * the user accepted despite a verify-FAIL and re-check each against the CURRENT
+ * tree. A static-class debt whose statics now pass is provably RESOLVED (a later
+ * task fixed it) and pruned from the ledger; every other debt cannot be proven
+ * resolved deterministically, so it stays OPEN and is surfaced — a run may not
+ * complete silently carrying an accepted defect. FP-safe by construction (see
+ * accept-debt.ts). Best-effort: a ledger read/write failure must never break the
+ * caller.
+ *
+ * FACTORED OUT of runFinalIntegrationGate (nexttask 6): the derivation has to be
+ * runnable at a SECOND moment — after a converged final-gate autofix, where the
+ * orchestrator used to rebuild its gate outcome as a bare `{ok, reason}` and drop
+ * `openDebts` entirely. The report a run ends on has to be derived from the tree
+ * the run ends with, not from the tree as it was before the fix pass.
+ *
+ * `staticOk` is the caller's claim about the CURRENT statics, and it is the only
+ * thing that can auto-close a static-class debt — so a caller that does not know
+ * must pass `false` (unprovable ⇒ stays open), never a guess.
+ */
+export async function deriveOpenDebts(cwd, staticOk) {
+    const { open: openRaw, resolved } = recheckAcceptDebts(await readAcceptDebts(cwd), {
+        staticOk,
+        // Cross-task-deletion debts auto-close iff the deleted file is back in the
+        // tree — a deterministic existence check, corroborating the per-file
+        // provenance the record already carries.
+        fileExists: rel => existsSync(path.join(cwd, rel))
+    });
+    if (resolved.length > 0)
+        await writeAcceptDebts(cwd, openRaw);
+    // Conflicting-claim annotation (mx5 run 11): an existence-as-failure debt whose
+    // named file is another task's committed deliverable is a plan defect — surface
+    // the contradiction with the debt so nobody (human or child) treats the claim as
+    // a deletion instruction. Pure git-history lookup; degrades to no annotation.
+    const openDebts = annotateDebtConflicts(openRaw, p => taskThatIntroduced(cwd, p));
+    const debtNote = buildAcceptDebtNote(openDebts);
+    return { openDebts, ...(debtNote ? { debtNote } : {}) };
+}
 /**
  * Run the final gate: static analysis first, then the lockfile consistency
  * checks, then the discovered integration commands, then one boot exercise of
@@ -1150,29 +1188,7 @@ export { taskThatIntroduced };
  */
 export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGraceMs = 10_000, bootDeps = {}, planText) {
     const stat = runRepoHealthCheck(cwd);
-    // ACCEPT-debt re-check (mx5 run 4 B3 / run 8 TASK_0012): read the ledger of tasks
-    // the user accepted despite a verify-FAIL and re-check each against the current
-    // tree. A static-class debt whose statics now pass is provably RESOLVED (a later
-    // task fixed it) and pruned; every other debt cannot be proven resolved
-    // deterministically, so it stays OPEN and is surfaced in this gate's report — a
-    // run may not complete silently carrying an accepted defect. FP-safe by
-    // construction (see accept-debt.ts). Best-effort: a ledger read/write failure
-    // must never break the gate.
-    const { open: openRaw, resolved } = recheckAcceptDebts(await readAcceptDebts(cwd), {
-        staticOk: stat.ok,
-        // Cross-task-deletion debts auto-close iff the deleted file is back in the
-        // tree — a deterministic existence check, corroborating the per-file
-        // provenance the record already carries.
-        fileExists: rel => existsSync(path.join(cwd, rel))
-    });
-    if (resolved.length > 0)
-        await writeAcceptDebts(cwd, openRaw);
-    // Conflicting-claim annotation (mx5 run 11): an existence-as-failure debt whose
-    // named file is another task's committed deliverable is a plan defect — surface
-    // the contradiction with the debt so nobody (human or child) treats the claim as
-    // a deletion instruction. Pure git-history lookup; degrades to no annotation.
-    const openDebts = annotateDebtConflicts(openRaw, p => taskThatIntroduced(cwd, p));
-    const debtNote = buildAcceptDebtNote(openDebts);
+    const { openDebts, debtNote } = await deriveOpenDebts(cwd, stat.ok);
     // The debt note rides in its OWN field: `reason` stays the mechanical failure
     // because it seeds the autofix child's prompt (see FinalGateOutcome.reason —
     // run 11's fix child executed a recorded claim as an instruction).

package/package.json

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