@mjasnikovs/pi-task 0.13.30 → 0.13.31

package/dist/task/auto-orchestrator.js

@@ -15,7 +15,7 @@ import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './quest
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath } from './task-io.js';
 import { gitCommitAll } from './auto-commit.js';
-import { runGuidelineEnforcement, ENFORCE_TIMEOUT_MS } from './enforce-guidelines.js';
+import { runGuidelineEnforcement, classifyEnforceChildFailure, ENFORCE_TIMEOUT_MS } from './enforce-guidelines.js';
 import { runWorker } from '../workers/pi-worker-core.js';
 import { runPhaseChild, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
@@ -306,7 +306,7 @@ function defaultDeps(ctx, cwd, signal, title) {
         commit: (cwd2, message) => getConfig().autoCommit ?
             gitCommitAll(cwd2, message, signal)
             : Promise.resolve({ committed: false, reason: 'auto-commit disabled' }),
-        enforce: (cwd2, _taskTitle) => {
+        enforce: (cwd2, taskTitle) => {
             if (!getConfig().enforceGuidelines) {
                 return Promise.resolve({ ok: true, reason: 'disabled' });
             }
@@ -315,30 +315,49 @@ function defaultDeps(ctx, cwd, signal, title) {
                 signal,
                 // Reuse the timeout- and loop-guarded worker child. It runs the
                 // same local model with edit tools so it can fix violations in
-                // place. Any non-clean exit (loop kill, timeout, leaked tool call,
-                // non-zero) throws so the pass becomes a blocking outcome rather
-                // than trusting a partial transcript.
+                // place. classifyEnforceChildFailure turns any non-clean exit
+                // (loop kill, timeout, leaked tool call, non-zero) into a thrown
+                // error so the pass becomes a blocking outcome rather than
+                // trusting a partial transcript.
                 runChild: async (tools, prompt, sig) => {
-                    const r = await runWorker({
-                        prompt,
-                        cwd: cwd2,
-                        signal: sig,
-                        tools,
-                        timeoutMs: ENFORCE_TIMEOUT_MS,
-                        onLine: line => phaseDeps.logDebug?.(`enforce: ${line}`)
-                    });
-                    if (r.aborted && !r.timedOut)
-                        throw new Error(USER_CANCELLED);
-                    if (r.timedOut)
-                        throw new Error('enforcement child timed out');
-                    if (r.loopHit)
-                        throw new Error('enforcement child looped');
-                    if (r.leakedToolCall)
-                        throw new Error('enforcement child leaked a tool call');
-                    if (r.exitCode !== 0) {
-                        throw new Error(`enforcement child exited ${r.exitCode}`);
+                    // The enforcement child is a slow local-model pass with edit
+                    // tools; show the same /task-auto status block as planning so
+                    // it isn't silent — head · enforcing guidelines/elapsed · ↳
+                    // last line. (runWorker surfaces no context usage, so that
+                    // line is just omitted.)
+                    lastLine = undefined;
+                    contextUsage = undefined;
+                    const startedAt = Date.now();
+                    const stopLoader = startAutoLoader(ctx, () => ({
+                        title: taskTitle,
+                        kind: 'enforce',
+                        step: 'guidelines',
+                        stepNum: 1,
+                        stepTotal: 1,
+                        startedAt,
+                        lastLine,
+                        contextUsage
+                    }));
+                    try {
+                        const r = await runWorker({
+                            prompt,
+                            cwd: cwd2,
+                            signal: sig,
+                            tools,
+                            timeoutMs: ENFORCE_TIMEOUT_MS,
+                            onLine: line => {
+                                lastLine = line;
+                                phaseDeps.logDebug?.(`enforce: ${line}`);
+                            }
+                        });
+                        const failure = classifyEnforceChildFailure(r);
+                        if (failure)
+                            throw new Error(failure);
+                        return r.text;
+                    }
+                    finally {
+                        stopLoader();
                     }
-                    return r.text;
                 }
             });
         }

package/dist/task/enforce-guidelines.d.ts

@@ -46,6 +46,26 @@ export declare function parseEnforceVerdict(text: string): {
     clean: boolean;
     detail: string;
 };
+/** The subset of a runWorker result the enforcement-child mapping reads. */
+export interface EnforceChildResult {
+    text: string;
+    exitCode: number;
+    aborted: boolean;
+    timedOut?: boolean;
+    loopHit?: unknown;
+    leakedToolCall?: unknown;
+}
+/**
+ * Map the enforcement child's runWorker result to a fatal error message, or null
+ * when it finished cleanly enough to parse a verdict from its text.
+ *
+ * The order is load-bearing. A loop-kill AND a wall-clock timeout BOTH also set
+ * `aborted` — killProc flips it on every kill path — so the specific causes
+ * (timeout, loop, leaked tool call) must be named BEFORE the generic
+ * `aborted → user-cancel` mapping. Checking `aborted` first (as the original
+ * inline code did) mislabels a loop-killed enforcement child as a user cancel.
+ */
+export declare function classifyEnforceChildFailure(r: EnforceChildResult): string | null;
 /**
  * Capture the work to verify as text: the tracked diff against HEAD plus the
  * names of any new (untracked) files. Non-destructive — it does not touch the

package/dist/task/enforce-guidelines.js

@@ -19,6 +19,7 @@
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { runChildDefault } from '../shared/child-process.js';
+import { USER_CANCELLED } from './child-runner.js';
 /** Filenames discovered in the working directory (cwd only — no tree walk). */
 export const GUIDELINE_FILENAMES = ['AGENTS.md', 'CLAUDE.md'];
 /** Tools the fix pass is allowed: read/search to inspect, edit/write to fix. */
@@ -99,6 +100,29 @@ export function parseEnforceVerdict(text) {
     const clean = last[1].toUpperCase() === 'CLEAN';
     return { clean, detail: clean ? '' : last[2].trim() || 'unspecified violation' };
 }
+/**
+ * Map the enforcement child's runWorker result to a fatal error message, or null
+ * when it finished cleanly enough to parse a verdict from its text.
+ *
+ * The order is load-bearing. A loop-kill AND a wall-clock timeout BOTH also set
+ * `aborted` — killProc flips it on every kill path — so the specific causes
+ * (timeout, loop, leaked tool call) must be named BEFORE the generic
+ * `aborted → user-cancel` mapping. Checking `aborted` first (as the original
+ * inline code did) mislabels a loop-killed enforcement child as a user cancel.
+ */
+export function classifyEnforceChildFailure(r) {
+    if (r.timedOut)
+        return 'enforcement child timed out';
+    if (r.loopHit)
+        return 'enforcement child looped';
+    if (r.leakedToolCall)
+        return 'enforcement child leaked a tool call';
+    if (r.aborted)
+        return USER_CANCELLED;
+    if (r.exitCode !== 0)
+        return `enforcement child exited ${r.exitCode}`;
+    return null;
+}
 /**
  * Capture the work to verify as text: the tracked diff against HEAD plus the
  * names of any new (untracked) files. Non-destructive — it does not touch the

package/dist/task/widget.d.ts

@@ -49,6 +49,10 @@ export interface AutoLoaderState {
     startedAt: number;
     lastLine?: string;
     contextUsage?: ContextSnapshot;
+    /** Which /task-auto stage this loader is for. Defaults to 'planning' (the
+     *  numbered clarify/decompose steps); 'enforce' is the per-task guideline
+     *  pass, which has no step numbering. */
+    kind?: 'planning' | 'enforce';
 }
 export declare function buildAutoLoaderLines(s: AutoLoaderState, theme?: WidgetTheme): string[];
 /**

package/dist/task/widget.js

@@ -121,7 +121,9 @@ export function startWidget(ctx, getState) {
 export function buildAutoLoaderLines(s, theme) {
     const elapsed = formatDuration(Date.now() - s.startedAt);
     const head = `/task-auto · ${s.title}`;
-    let detail = `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
+    let detail = s.kind === 'enforce' ?
+        `enforcing guidelines · ${elapsed}`
+        : `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
     if (s.contextUsage) {
         const ctxDetail = formatContextDetail(s.contextUsage, theme);
         if (ctxDetail)

package/package.json

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