@mjasnikovs/pi-task 0.13.25 → 0.13.27

package/README.md

@@ -9,7 +9,7 @@
 [![npm](https://img.shields.io/npm/v/@mjasnikovs/pi-task?color=cb3837&logo=npm)](https://www.npmjs.com/package/@mjasnikovs/pi-task)
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![pi extension](https://img.shields.io/badge/pi-extension-7c3aed)](https://www.npmjs.com/package/@earendil-works/pi-coding-agent)
-[![tests](https://img.shields.io/badge/tests-559%20passing-3fb950)](#development)
+[![tests](https://img.shields.io/badge/tests-731%20passing-3fb950)](#development)
 [![types](https://img.shields.io/badge/TypeScript-strict-3178c6?logo=typescript&logoColor=white)](./tsconfig.json)
 
 </div>
@@ -49,7 +49,8 @@ pi install npm:@mjasnikovs/pi-task
 | `/task-auto <feature>` | Plan a feature into a task list and run each title through `/task` in order (resumable). |
 | `/task-auto-resume` | Resume the active `/task-auto` run at the next unfinished task. |
 | `/task-auto-cancel` | Stop the `/task-auto` loop after the current task (still resumable). |
-| `/remote` | Show the QR code & URLs for the always-on web view (`/remote stop` to stop). Answer grill questions, start tasks, and watch progress from your phone. |
+| `/task-config` | Toggle pi-task settings in an editor dialog: remote server, compress reasoning, and auto-commit. |
+| `/remote` | Show the QR code & URLs for the web view (`/remote stop` to stop). Answer grill questions, start tasks, and watch progress from your phone. |
 
 ## The pipeline
 
@@ -77,10 +78,11 @@ A real feature is usually several tasks, not one. `/task-auto` is a thin planner
 - **Clarify first.** It asks the few clarifying questions whose answers change how the feature splits, then decomposes the answers into an ordered list of task titles written to `.pi-tasks/TASK_AUTO_NNNN.md`.
 - **Sequential, blocking.** Each title runs through `/task` to a spec, the spec is implemented, and the loop waits for that to finish before starting the next title. No overlap.
 - **Crash- and cancel-safe.** Progress is the markdown checkboxes in the AUTO file. `/task-auto-resume` (no id) automatically picks up the active run at the first unchecked title. If a title's `/task` run fails, the loop stops and leaves the run resumable.
+- **One commit per task.** When **auto-commit** is on (the default) and you're in a git repo, the working tree is snapshotted into a single commit after each title passes, so the run produces a clean per-task history. It's best-effort: outside a repo, with nothing to commit, or on any git error, the loop reports the reason and keeps going. Toggle it in `/task-config`.
 
 ## Remote — drive a task from your phone
 
-The remote server is **always on** — it starts automatically with each session, with nothing taking up screen space. Run `/remote` any time to pop a QR code and the connection URLs: a **Tailscale** line and a **LAN** line when both are available (the QR encodes the Tailscale-preferred one). Open the URL on any device that can reach the host and you get a live view of the session: streaming output, tool calls, and the `/task` status block (phase, elapsed, context). It's bidirectional — the browser can:
+The remote server is **on by default** — it starts automatically with each session, with nothing taking up screen space (disable it in `/task-config`). Run `/remote` any time to pop a QR code and the connection URLs: a **Tailscale** line and a **LAN** line when both are available (the QR encodes the Tailscale-preferred one). Open the URL on any device that can reach the host and you get a live view of the session: streaming output, tool calls, and the `/task` status block (phase, elapsed, context). It's bidirectional — the browser can:
 
 - **Answer grill / `/task-auto` clarify questions.** Each question appears as a card with the recommended default pre-filled (Accept), a free-text box (Submit), Skip, or Cancel task.
 - **Start and control tasks.** Type `/task …`, `/task-auto …`, `/task-cancel`, `/task-resume`, etc. — they run on the host.
@@ -136,6 +138,16 @@ Resolves an installed npm package, indexes its `.d.ts` files and README into a l
 - The first call for a `(package, version)` pair pays a one-time ingestion cost; later calls are FTS-only.
 - Cache lives at `${XDG_CACHE_HOME:-~/.cache}/pi-worker/docs.sqlite` — delete it to reset.
 
+## Settings — `/task-config`
+
+Run `/task-config` to toggle pi-task's behavior in an editor dialog. Settings persist to `~/.config/pi-task/config.json` and all default to **on**:
+
+| Setting | What it does |
+| --- | --- |
+| **remote** | The remote UI server (QR code, phone access). Turn off to never start it. |
+| **compress reasoning** | After each message, compresses the model's `<think>` blocks down to the decisions/constraints/facts that matter later — keeping long local-model runs from drowning their own context in self-talk. |
+| **auto-commit** | Snapshots the working tree into one git commit per `/task-auto` sub-task (see above). |
+
 ## Configuration
 
 | Variable | Used by | Notes |
@@ -153,7 +165,7 @@ Tasks are persisted to `<cwd>/.pi-tasks/TASK_NNNN.md`. Add `.pi-tasks/` to your
 
 ```sh
 bun install
-bun test src/      # 559 tests across 46 files
+bun test src/      # 731 tests across 57 files
 bun run lint       # prettier + eslint + tsc --noEmit
 bun run build      # tsc → dist/
 ```

package/dist/task/phases.d.ts

@@ -56,6 +56,14 @@ export interface PhaseResearchDeps extends ExternalContextDeps {
  * mentions; the rest are unchanged or only lightly trimmed.
  */
 export declare function scopedToolingGoal(refined: string): string;
+/**
+ * Build a degraded section body for a runaway worker: a one-line marker naming
+ * the failure (so downstream phases and a human reading the task file know this
+ * section is incomplete) followed by whatever partial answer the worker streamed
+ * before it was killed. The marker is always present even when there is no
+ * partial text, so an empty degrade is never mistaken for a real finding.
+ */
+export declare function degradedSectionBody(name: string, reason: string, partial: string): string;
 export declare function phaseResearch(deps: PhaseDeps, refined: string, researchDeps?: PhaseResearchDeps): Promise<string>;
 export interface PhaseAutoAnswerDeps {
     docsFocused?: typeof docsFocused;

package/dist/task/phases.js

@@ -122,34 +122,67 @@ export function scopedToolingGoal(refined) {
     return firstBullet === -1 ? goal : goal.slice(0, firstBullet).trim();
 }
 /**
- * Throw a descriptive error if a research worker's result is not trustworthy
- * output, so only good output is ever cached and assembled. Precedence mirrors
- * the original inline checks: loop/timeout exhaustion first (a loop-kill is a
- * SIGTERM/exit 143 OR a clean exit 0 with partial text, so exitCode alone is
- * ambiguous — the worker already burned its MAX_LOOP_RESTARTS restarts before
- * setting these), then exit code, empty output, and finally a leaked
- * (never-executed) tool call.
+ * Classify a research worker's result so the phase can react per-worker instead
+ * of treating every failure the same. Two distinct failure shapes:
+ *
+ *   - 'runaway' (loop-kill OR per-worker wall-clock timeout): the worker explored
+ *     too long and was killed *after* burning its MAX_LOOP_RESTARTS restarts. It
+ *     did real work and left partial text; the other three workers are unaffected.
+ *     Failing the whole task here would throw away every already-good worker AND
+ *     abort the entire auto-run over the weakest section — and because the loop is
+ *     deterministic, a resume just re-loops and re-fails. So this DEGRADES: keep
+ *     the partial answer (marked), cache it, move on. A loop-kill is a SIGTERM
+ *     (exit 143) OR a clean exit 0 with truncated text, so loopHit/timedOut — not
+ *     exitCode — are the reliable signal and are checked first.
+ *
+ *   - 'fatal' (non-zero exit that isn't a loop-kill, empty output, or a leaked
+ *     never-executed tool call): the output is untrustworthy in a way partial text
+ *     can't paper over (broken env, model disconnect, wrong tool-call dialect).
+ *     These still throw — degrading them would launder a real breakage into a
+ *     plausible-looking section. Returns null when the result is trustworthy.
  */
-function assertResearchWorkerOk(name, result) {
+function classifyResearchWorker(name, result) {
     if (result.loopHit) {
         const argsStr = JSON.stringify(result.loopHit.call.args);
-        throw new Error(`Research ${name} worker stuck in a loop — called `
-            + `${result.loopHit.call.name}(${argsStr}) ×${result.loopHit.count} in the last `
-            + `${result.loopHit.windowSize} calls and still looped after restarts`);
+        return {
+            kind: 'runaway',
+            reason: `stuck in a loop — called ${result.loopHit.call.name}(${argsStr}) `
+                + `×${result.loopHit.count} in the last ${result.loopHit.windowSize} calls `
+                + `and still looped after restarts`
+        };
     }
     if (result.timedOut) {
-        throw new Error(`Research ${name} worker timed out after restarts`);
+        return { kind: 'runaway', reason: 'timed out after restarts' };
     }
     if (result.exitCode !== 0) {
-        throw new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`);
+        return {
+            kind: 'fatal',
+            error: new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`)
+        };
     }
     if (result.text.trim().length === 0) {
-        throw new Error(`Research ${name} worker produced no output`);
+        return { kind: 'fatal', error: new Error(`Research ${name} worker produced no output`) };
     }
     if (result.leakedToolCall) {
-        throw new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
-            + `(${result.leakedToolCall.trim()}) — it never ran`);
+        return {
+            kind: 'fatal',
+            error: new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
+                + `(${result.leakedToolCall.trim()}) — it never ran`)
+        };
     }
+    return null;
+}
+/**
+ * Build a degraded section body for a runaway worker: a one-line marker naming
+ * the failure (so downstream phases and a human reading the task file know this
+ * section is incomplete) followed by whatever partial answer the worker streamed
+ * before it was killed. The marker is always present even when there is no
+ * partial text, so an empty degrade is never mistaken for a real finding.
+ */
+export function degradedSectionBody(name, reason, partial) {
+    const marker = `(degraded: research ${name} worker ${reason}; this section may be incomplete)`;
+    const body = partial.trim();
+    return body.length > 0 ? `${marker}\n\n${body}` : marker;
 }
 export async function phaseResearch(deps, refined, researchDeps = {}) {
     const fileInventoryFn = researchDeps.getFileInventory ?? getFileInventory;
@@ -265,11 +298,21 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             + (r.stderr ? ` stderr=${r.stderr.slice(0, 300)}` : '')
             + (r.leakedToolCall ? ` leaked=${r.leakedToolCall.trim().slice(0, 80)}` : ''));
         updateProgress();
-        // Throws (failing the phase) on a loop/timeout/exit/empty/leak — so the
-        // workers that already succeeded above stay cached for the resume.
-        assertResearchWorkerOk(spec.section, r);
-        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, r.text);
-        sections.push({ name: spec.section, text: r.text.trim() });
+        // A fatal failure (crash/empty/leak) still throws — the already-cached
+        // workers survive for the resume. A runaway (loop/timeout) degrades to its
+        // partial output instead, so one weak worker can't abort a whole auto-run;
+        // the degraded section is cached too, so a resume doesn't re-loop it.
+        const failure = classifyResearchWorker(spec.section, r);
+        if (failure?.kind === 'fatal')
+            throw failure.error;
+        const sectionText = failure?.kind === 'runaway' ?
+            degradedSectionBody(spec.section, failure.reason, r.text)
+            : r.text.trim();
+        if (failure?.kind === 'runaway') {
+            deps.logDebug?.(`${spec.label}: degraded — ${failure.reason}`);
+        }
+        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, sectionText);
+        sections.push({ name: spec.section, text: sectionText });
     }
     // All workers succeeded — the assembled output below becomes the canonical
     // 'research' section (written by the orchestrator). The per-worker caches

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.25",
+    "version": "0.13.27",
     "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",
@@ -66,6 +66,7 @@
     "pi": {
         "extensions": [
             "dist/index.js"
-        ]
+        ],
+        "image": "https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.png"
     }
 }