@mjasnikovs/pi-task 0.17.0 → 0.17.1

package/dist/task/task-gates.js

@@ -0,0 +1,135 @@
+import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
+import { SessionUI } from '../remote/bridge.js';
+/**
+ * Show the boxed two-choice picker after a verify FAIL and return what the user
+ * decided. The model-recommended card is placed first so the renderer tints it
+ * green; the user ALWAYS makes the final call (there is no auto-pick). Mirrors the
+ * clarify/grill dialog: the same SessionUI.ask races the local boxed picker against
+ * a remote answer, with the two actions also surfaced as remote buttons.
+ */
+export async function askVerifyResolution(ctx, title, failReason, rec) {
+    const options = resolutionOptions(rec.recommend);
+    const question = `Verification FAILED for "${title}".\n\n${failReason}\n\n`
+        + `Recommended: ${rec.recommend.toUpperCase()} — ${rec.rationale}`;
+    const answer = await new SessionUI(ctx).ask({
+        localTitle: 'Verification failed — how should pi proceed?',
+        displayQuestion: question,
+        question,
+        recommended: options[0].label,
+        recommended2: options[1].label,
+        allowSkip: false,
+        options
+    });
+    return classifyResolutionAnswer(answer);
+}
+/**
+ * Run the verify + enforce gates against a task's just-finished implementation.
+ *
+ * Lifted verbatim from /task-auto's per-task loop so the two commands gate
+ * identically. Returns a GateResult; `done` means the caller should proceed (the
+ * work is verified-or-accepted, checked off, committed, and enforced), every other
+ * kind is a terminal stop the caller announces. Never throws for a gate outcome —
+ * only a user cancel inside a gate child propagates (handled by the caller's
+ * USER_CANCELLED path).
+ */
+export async function runGatesForTask(ctxIn, deps, p) {
+    let active = ctxIn;
+    // GATE: actually RUN the task's verification against the just-finished work
+    // BEFORE it is checked off or committed. Whether this produced a GENUINE clean
+    // pass (a real signal ran and the work met it) also decides how the enforce pass
+    // below may behave: only a genuine pass gives a signal to revert against, so only
+    // then may enforce edit in place. A no-op pass (no spec), a disabled gate, or an
+    // accept-override leaves this false → enforce runs flag-only.
+    let verifyCleanPass = false;
+    if (deps.verify) {
+        active.ui.notify(`${p.tag}: verifying "${p.title}"…`, 'info');
+        let verified = await deps.verify(active, p.cwd, p.title, p.taskId);
+        // A FAIL no longer dead-stops: offer the boxed AUTOFIX / ACCEPT / dismiss
+        // picker. The USER always decides; AUTOFIX loops straight back to the gate
+        // as many times as they keep choosing it (no attempt cap).
+        while (!verified.ok) {
+            const failReason = verified.reason ?? 'did not verify';
+            const rec = deps.recommend ?
+                await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
+                : { recommend: 'autofix', rationale: failReason };
+            const choice = await askVerifyResolution(active, p.title, failReason, rec);
+            if (choice.action === 'cancel') {
+                return { kind: 'paused', ctx: active, reason: failReason };
+            }
+            if (choice.action === 'accept') {
+                active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.`, 'warning');
+                break;
+            }
+            // AUTOFIX: re-run the implementation turn with the failure (and any typed
+            // guidance) prepended as a RE-ATTEMPT banner, then re-verify.
+            active.ui.notify(`${p.tag}: autofixing "${p.title}"…`, 'info');
+            const fixInstruction = choice.guidance ? `${failReason}\n\nUser guidance: ${choice.guidance}` : failReason;
+            const fixRes = await deps.runTask(active, p.cwd, p.title, {
+                resumeId: p.taskId,
+                planContext: p.planContext,
+                fixInstruction
+            });
+            active = fixRes.ctx ?? active;
+            if (fixRes.sessionCancelled)
+                return { kind: 'session-cancelled', ctx: active };
+            if (fixRes.interrupted)
+                return { kind: 'interrupted', ctx: active };
+            if (!fixRes.ok)
+                return { kind: 'failed', ctx: active, reason: fixRes.reason };
+            // Resume reuses the same inner task id, so p.taskId is stable.
+            verified = await deps.verify(active, p.cwd, p.title, p.taskId);
+        }
+        // Loop exited because the work verified OR the user accepted the artifact. A
+        // genuine clean pass is ok===true with NO reason; a no-op pass or an
+        // accept-override (verified.ok still false at break) is NOT a guardable signal.
+        verifyCleanPass = verified.ok && !verified.reason;
+    }
+    // Mark the work verified (parent task-list check-off for /task-auto; no-op for
+    // /task) BEFORE committing, so the commit captures the check-off too.
+    await p.onVerified?.();
+    // Commit the task's work as one snapshot FIRST — before guideline enforcement —
+    // so a passing task is durably recorded no matter what enforcement later finds.
+    const commit = await deps.commit(p.cwd, `task: ${p.title} (${p.taskId})`);
+    if (commit.committed) {
+        active.ui.notify(`${p.tag}: committed "${p.title}".`, 'info');
+    }
+    else {
+        active.ui.notify(`${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`, 'warning');
+    }
+    // With the task committed, hold its work to AGENTS.md / CLAUDE.md — but as a step
+    // INSIDE the validation gate, gated by the verify signal (see GateDeps.enforce).
+    // Skipped when nothing was committed this round, when enforce is off, or in tests
+    // with no enforce dep.
+    if (deps.enforce && commit.committed) {
+        const mode = verifyCleanPass ? 'edit' : 'flag';
+        active.ui.notify(mode === 'edit' ?
+            `${p.tag}: enforcing AGENTS.md/CLAUDE.md on "${p.title}"…`
+            : `${p.tag}: reviewing "${p.title}" against AGENTS.md/CLAUDE.md (no verify signal — report only)…`, 'info');
+        const verdict = await deps.enforce(active, p.cwd, p.title, mode);
+        if (!verdict.ok) {
+            active.ui.notify(`${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
+        }
+        if (mode === 'edit') {
+            // Commit whatever the pass fixed as its own snapshot. A no-op when it made
+            // no edits (nothing to commit) — then there is nothing to re-verify/revert.
+            const enforceCommit = await deps.commit(p.cwd, `ENFORCE GUIDELINES: ${p.title} (${p.taskId})`);
+            if (enforceCommit.committed) {
+                // Differential guard: re-run the verify signal against the enforced
+                // tree. A regression ⇒ drop the enforce commit, keep the verified work.
+                const after = deps.verify ?
+                    await deps.verify(active, p.cwd, p.title, p.taskId)
+                    : { ok: true };
+                if (!after.ok) {
+                    if (deps.revert)
+                        await deps.revert(p.cwd);
+                    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 {
+                    active.ui.notify(`${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
+                }
+            }
+        }
+        // 'flag' mode makes no edits — nothing to commit or revert.
+    }
+    return { kind: 'done', ctx: active };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.0",
+    "version": "0.17.1",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",