@mjasnikovs/pi-task 0.38.12 → 0.38.14

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-AGPL--3.0-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-3797%20passing-3fb950)](#development)
+[![tests](https://img.shields.io/badge/tests-3771%20passing-3fb950)](#development)
 [![types](https://img.shields.io/badge/TypeScript-strict-3178c6?logo=typescript&logoColor=white)](./tsconfig.json)
 
 </div>
@@ -72,7 +72,7 @@ A whole plan — `/task-auto` splits it into an ordered task list and runs each
 | `/task-auto <feature>` | Plan a feature into a task list and run each title through `/task` in order (resumable). |
 | `/task-auto-resume [--unattended]` | Resume the active `/task-auto` run at the next unfinished task. `--unattended` is the boot-hook form: in-flight runs only. |
 | `/task-auto-cancel` | Stop the `/task-auto` loop after the current task (still resumable). |
-| `/task-config` | Toggle pi-task settings in an editor dialog: remote control, compress thinking, auto-commit, verify work, enforce guidelines, project tour, parallel research, research cache, search engine, command timeout, stuck reply retry, yolo mode, debug logs, one `watch:` toggle per live tool, and one `ext:` toggle per installed host extension. |
+| `/task-config` | Toggle pi-task settings in an editor dialog: remote control, auto-commit, verify work, enforce guidelines, project tour, parallel research, research cache, search engine, command timeout, stuck reply retry, yolo mode, debug logs, one `watch:` toggle per live tool, and one `ext:` toggle per installed host extension. |
 | `/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
@@ -204,7 +204,6 @@ Run `/task-config` to toggle pi-task's behavior in an editor dialog. Settings pe
 | Setting | Default | What it does |
 | --- | --- | --- |
 | **remote control** | on | The remote UI server (QR code, phone access). Turn off to never start it. |
-| **compress thinking** | on | 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** | on | Snapshots the working tree into one git commit per `/task-auto` sub-task (see above). |
 | **verify work** | on | After each `/task` (and `/task-auto` task) implements — but **before** it's checked off or committed — actually **runs** the spec's own `VERIFY` block in the real workspace. pi-task otherwise only _authors_ a VERIFY block and never executes it, so a task that doesn't build is indistinguishable from one that works. A fresh `read` + `bash` child of the same local model runs the declared check, observes the real output, and reports **PASS/FAIL** (a legitimately no-op VERIFY is a PASS). On FAIL the run doesn't dead-stop: you get a boxed picker — **Autofix** (re-run the implementation turn against the failure, then re-verify; no attempt cap) or **Accept** (override a misjudged artifact) — and dismissing it pauses the run, resumable. A genuine clean pass is also the behavioral signal that lets **enforce guidelines** fix in place (see below). |
 | **enforce guidelines** | on | After each `/task` (and `/task-auto` task) is committed, re-checks that commit's work against the project's `AGENTS.md` / `CLAUDE.md` (in the working directory). A bare fix-in-place pass trashes working code (A/B-proven), so enforcement is gated on the **verify work** signal. **With** a genuine verify pass: a fresh `read` + `edit` child of the same local model reads the **last commit's** diff and fixes violations in place; its fixes are committed **separately** as an `ENFORCE GUIDELINES` commit, then the verify signal is re-run against the enforced tree — a regression **reverts** the enforce commit and keeps the verified work. **Without** that signal (verify off, no spec, or an accept-override): the pass runs read-only and only **reports** violations, never rewrites logic. Either way a violation it can't clear (or a pass that can't run) only **warns** — the task commit already landed, so the run continues. Skipped when nothing was committed for the task. |
@@ -243,7 +242,7 @@ them checked in.
 
 ```sh
 bun install
-bun run test       # 3800 tests across 214 files
+bun run test       # 3772 tests across 212 files
 bun run lint       # prettier + eslint + tsc --noEmit
 bun run build      # tsc → dist/
 ```

package/dist/config/config.d.ts

@@ -1,7 +1,6 @@
 import { type SearchProvider } from '../workers/search-types.js';
 export interface PiTaskConfig {
     remote: boolean;
-    compressReasoning: boolean;
     autoCommit: boolean;
     orientation: boolean;
     enforceGuidelines: boolean;

package/dist/config/config.js

@@ -87,7 +87,6 @@ export function sanitizeStreamInactivityMs(value) {
  */
 export const DEFAULT_CONFIG = {
     remote: true,
-    compressReasoning: true,
     autoCommit: true,
     orientation: true,
     enforceGuidelines: true,

package/dist/config/register.js

@@ -94,8 +94,6 @@ function booleanItem(id, label, description) {
 export const ITEMS = [
     booleanItem('remote', 'remote control', 'Serve the task UI on your local network so you can follow and steer a run from '
         + 'your phone. Prints a QR code to scan when it starts'),
-    booleanItem('compressReasoning', 'compress thinking', "Shrink the model's thinking blocks once it has moved on, so a long run keeps more "
-        + 'room for the work itself'),
     booleanItem('autoCommit', 'auto-commit', 'Make a git commit before and after every sub-task, so each step is a checkpoint '
         + 'you can read back or roll back to'),
     booleanItem('verifyWork', 'verify work', 'When a task says it is done, actually run the checks its spec asks for and report '

package/dist/index.js

@@ -4,7 +4,6 @@ import { registerTaskAuto } from './task/auto-orchestrator.js';
 import { registerTaskPlan } from './task/plan-orchestrator.js';
 import { registerWorkers } from './workers/index.js';
 import { registerRemote } from './remote/register.js';
-import { registerThinkingCompression } from './thinking/compress.js';
 import { registerCommandWatchdog } from './task/command-watchdog.js';
 import { registerStreamWatchdog } from './task/stream-watchdog.js';
 export default function (pi) {
@@ -14,7 +13,6 @@ export default function (pi) {
     registerTaskPlan(pi);
     registerWorkers(pi);
     registerRemote(pi);
-    registerThinkingCompression(pi);
     registerCommandWatchdog(pi);
     registerStreamWatchdog(pi);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.38.12",
+    "version": "0.38.14",
     "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",
@@ -12,7 +12,7 @@
         "LICENSE"
     ],
     "scripts": {
-        "build": "tsc -p tsconfig.build.json",
+        "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
         "lint": "prettier --log-level warn --write 'src/**/*.ts' && eslint --fix . && tsc --noEmit && tsc -p scripts/tsconfig.json --noEmit",
         "test": "cross-env AGENT=1 bun test --isolate src/ scripts/",
         "prepublishOnly": "bun run build"

package/dist/remote/state.d.ts

@@ -1,2 +0,0 @@
-export declare function isAgentIdle(): boolean;
-export declare function setAgentIdle(idle: boolean): void;

package/dist/remote/state.js

@@ -1,7 +0,0 @@
-let _isAgentIdle = true;
-export function isAgentIdle() {
-    return _isAgentIdle;
-}
-export function setAgentIdle(idle) {
-    _isAgentIdle = idle;
-}

package/dist/thinking/compress.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-export declare function registerThinkingCompression(pi: ExtensionAPI): void;

package/dist/thinking/compress.js

@@ -1,118 +0,0 @@
-import { getConfig } from '../config/config.js';
-import { collectCompressible, MIN_THINKING_CHARS, rebuildWithCompressed } from './rewrite.js';
-/** Hard cap so a stuck model request can never wedge a turn. */
-const REQUEST_TIMEOUT_MS = 120_000;
-const STATUS_KEY = 'pi-task-thinking';
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const PROMPT = 'Compress this reasoning. Keep every decision/conclusion/constraint/fact relied on later. '
-    + 'Drop restated questions, false starts, self-talk. Output only the compressed reasoning. /no_think';
-async function compressOne(text, model, auth) {
-    const headers = { 'Content-Type': 'application/json', ...auth.headers };
-    if (auth.apiKey)
-        headers.Authorization = `Bearer ${auth.apiKey}`;
-    const res = await fetch(`${model.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-            model: model.id,
-            messages: [{ role: 'user', content: `${PROMPT}\n\n---\n\n${text}` }],
-            temperature: 0,
-            stream: false
-        }),
-        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    });
-    if (!res.ok)
-        throw new Error(`compress HTTP ${res.status}`);
-    const data = (await res.json());
-    const raw = data.choices?.[0]?.message?.content ?? '';
-    return raw.replaceAll('<think>', '').replaceAll('</think>', '').trim();
-}
-/** Animated footer loader. Safe in any mode — `setStatus` is a no-op outside the
- *  TUI. Each tick reports which block is compressing and its size. */
-class Loader {
-    ui;
-    timer = null;
-    frame = 0;
-    constructor(ui) {
-        this.ui = ui;
-    }
-    start(label) {
-        this.stop();
-        const tick = () => {
-            this.ui.setStatus(STATUS_KEY, `${SPINNER[this.frame % SPINNER.length]} ${label()}`);
-            this.frame++;
-        };
-        tick();
-        this.timer = setInterval(tick, 120);
-    }
-    /** Show a final, non-animated line, then clear it after a short beat. */
-    finish(text) {
-        this.stop();
-        this.ui.setStatus(STATUS_KEY, text);
-        if (text !== undefined) {
-            setTimeout(() => this.ui.setStatus(STATUS_KEY, undefined), 4000);
-        }
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-}
-async function resolveAuth(ctx, model) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- ctx.model is Model<any>; the registry wants Model<Api>
-        const r = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-        return r.ok ? { apiKey: r.apiKey, headers: r.headers } : {};
-    }
-    catch {
-        return {};
-    }
-}
-const pct = (from, to) => Math.round((100 * (from - to)) / from);
-export function registerThinkingCompression(pi) {
-    pi.on('message_end', async (event, ctx) => {
-        if (!getConfig().compressReasoning)
-            return;
-        const message = event.message;
-        const targets = collectCompressible(message, MIN_THINKING_CHARS);
-        if (targets.length === 0)
-            return;
-        const model = ctx.model;
-        if (!model)
-            return;
-        const loader = new Loader(ctx.ui);
-        const auth = await resolveAuth(ctx, model);
-        const modelRef = { id: model.id, baseUrl: model.baseUrl };
-        const replacements = new Map();
-        let origTotal = 0;
-        let newTotal = 0;
-        for (let i = 0; i < targets.length; i++) {
-            const t = targets[i];
-            const n = i + 1;
-            loader.start(() => targets.length > 1 ?
-                `compressing reasoning ${n}/${targets.length} (${t.text.length}c)…`
-                : `compressing reasoning (${t.text.length}c)…`);
-            try {
-                const compressed = await compressOne(t.text, modelRef, auth);
-                if (compressed.length > 0 && compressed.length < t.text.length) {
-                    replacements.set(t.index, compressed);
-                    origTotal += t.text.length;
-                    newTotal += compressed.length;
-                }
-            }
-            catch {
-                // Leave this block verbatim; move on to the next.
-            }
-        }
-        if (replacements.size === 0) {
-            loader.finish(undefined);
-            return;
-        }
-        loader.finish(`✓ reasoning ${origTotal}→${newTotal}c (−${pct(origTotal, newTotal)}%)`);
-        // Cast back to the concrete AgentMessage type: the helpers work on a
-        // structural view, but the rewrite only swaps thinking-block text.
-        return { message: rebuildWithCompressed(message, replacements) };
-    });
-}

package/dist/thinking/rewrite.d.ts

@@ -1,29 +0,0 @@
-/** Minimal structural view of a thinking content block. Kept structural (rather
- *  than importing pi-ai's `ThinkingContent`) so these helpers stay pure and are
- *  trivially unit-testable with plain objects. */
-export interface ThinkingBlock {
-    type: 'thinking';
-    thinking: string;
-    thinkingSignature?: string;
-    redacted?: boolean;
-}
-export interface AssistantMessageLike {
-    role?: string;
-    content?: unknown;
-}
-export interface CompressTarget {
-    index: number;
-    text: string;
-}
-/** Thinking blocks shorter than this aren't worth a model round-trip. */
-export declare const MIN_THINKING_CHARS = 120;
-export declare function isThinkingBlock(b: unknown): b is ThinkingBlock;
-export declare function isCompressible(b: ThinkingBlock, minChars: number): boolean;
-/** Compressible thinking blocks of an assistant message, with their positions. */
-export declare function collectCompressible(message: AssistantMessageLike, minChars: number): CompressTarget[];
-/** Rebuild an assistant message with compressed text swapped into the given
- *  block indices. The block `type` and `thinkingSignature` are preserved so the
- *  local provider still replays the (now shorter) reasoning, and a replacement is
- *  only applied when it actually shrinks the block. Returns the same object when
- *  nothing changed. */
-export declare function rebuildWithCompressed<T extends AssistantMessageLike>(message: T, byIndex: ReadonlyMap<number, string>): T;

package/dist/thinking/rewrite.js

@@ -1,53 +0,0 @@
-/** Thinking blocks shorter than this aren't worth a model round-trip. */
-export const MIN_THINKING_CHARS = 120;
-/** In `openai-completions` (llama.cpp/local) the "signature" is a field *name*
- *  (`reasoning_content`) the reasoning is replayed under — not a crypto
- *  signature — so rewriting the text is safe. A long, non-sentinel signature is
- *  Anthropic-style extended thinking, where the signature cryptographically
- *  signs the original text and the block feeds the next turn's continuation;
- *  rewriting it would break that, so those blocks are skipped. */
-const SENTINEL_SIGNATURES = new Set(['', 'reasoning_content', 'reasoning', 'reasoning_text']);
-export function isThinkingBlock(b) {
-    return (typeof b === 'object'
-        && b !== null
-        && b.type === 'thinking'
-        && typeof b.thinking === 'string');
-}
-export function isCompressible(b, minChars) {
-    if (b.redacted)
-        return false;
-    if (!SENTINEL_SIGNATURES.has(b.thinkingSignature ?? ''))
-        return false;
-    return b.thinking.trim().length >= minChars;
-}
-/** Compressible thinking blocks of an assistant message, with their positions. */
-export function collectCompressible(message, minChars) {
-    if (message.role !== 'assistant' || !Array.isArray(message.content))
-        return [];
-    const out = [];
-    message.content.forEach((b, index) => {
-        if (isThinkingBlock(b) && isCompressible(b, minChars))
-            out.push({ index, text: b.thinking });
-    });
-    return out;
-}
-/** Rebuild an assistant message with compressed text swapped into the given
- *  block indices. The block `type` and `thinkingSignature` are preserved so the
- *  local provider still replays the (now shorter) reasoning, and a replacement is
- *  only applied when it actually shrinks the block. Returns the same object when
- *  nothing changed. */
-export function rebuildWithCompressed(message, byIndex) {
-    if (byIndex.size === 0 || !Array.isArray(message.content))
-        return message;
-    let changed = false;
-    const content = message.content.map((b, index) => {
-        const compressed = byIndex.get(index);
-        if (compressed === undefined || !isThinkingBlock(b))
-            return b;
-        if (compressed.length >= b.thinking.length)
-            return b;
-        changed = true;
-        return { ...b, thinking: compressed };
-    });
-    return changed ? { ...message, content } : message;
-}