@mjasnikovs/pi-task 0.38.17 → 0.38.19

package/dist/config/config.d.ts

@@ -215,5 +215,16 @@ export declare const CONFIG_LOADERS: {
  * into the config object.
  */
 export declare function loadConfig(raw: unknown): PiTaskConfig;
+/**
+ * Where the saved config lives. `PI_TASK_CONFIG_PATH` overrides it.
+ *
+ * The override exists because this module loads the real file at import time,
+ * which made every test that reads a config value depend on the developer's own
+ * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` failed
+ * 12 tests here while CI (no config file at all) stayed green. The test preload
+ * points this at a path under the tmp dir that never exists, so tests always see
+ * DEFAULT_CONFIG. Read once at module eval: the preload runs before any import.
+ */
+export declare const CONFIG_PATH_ENV = "PI_TASK_CONFIG_PATH";
 export declare function getConfig(): PiTaskConfig;
 export declare function saveConfig(config: PiTaskConfig): Promise<void>;

package/dist/config/config.js

@@ -182,7 +182,19 @@ export function loadConfig(raw) {
     }
     return out;
 }
-const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
+/**
+ * Where the saved config lives. `PI_TASK_CONFIG_PATH` overrides it.
+ *
+ * The override exists because this module loads the real file at import time,
+ * which made every test that reads a config value depend on the developer's own
+ * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` failed
+ * 12 tests here while CI (no config file at all) stayed green. The test preload
+ * points this at a path under the tmp dir that never exists, so tests always see
+ * DEFAULT_CONFIG. Read once at module eval: the preload runs before any import.
+ */
+export const CONFIG_PATH_ENV = 'PI_TASK_CONFIG_PATH';
+const CONFIG_PATH = process.env[CONFIG_PATH_ENV]?.trim()
+    || path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;
 if (!_g.__piTaskConfig) {
     _g.__piTaskConfig = { config: { ...DEFAULT_CONFIG }, loaded: false };

package/dist/shared/child-process.d.ts

@@ -115,6 +115,25 @@ export interface RunChildJsonEventsOptions {
     mode: 'json-events';
     onLine?: (line: string) => void;
     onContextUsage?: (snapshot: ContextSnapshot) => void;
+    /**
+     * The child's context window in tokens, supplied BY THE CALLER — pi's event
+     * stream does not carry one (GitHub issue #16).
+     *
+     * Verified against the published tarballs of @earendil-works/pi-coding-agent
+     * and @earendil-works/pi-agent-core at 0.80.2 and 0.84.2, and against pi's
+     * own docs/json.md: the wire union is session / agent_* / turn_* / message_*
+     * / tool_execution_* / queue_update / compaction_* / auto_retry_*, the
+     * session header is {type,version,id,timestamp,cwd,parentSession}, and no
+     * member of either carries a window or even a model id. `contextUsage`
+     * exists ONLY as the in-process `ctx.getContextUsage()` extension API, which
+     * a `--mode json` child never speaks back to its parent.
+     *
+     * The parent therefore has to say. Children are spawned without `-m`
+     * (CHILD_BASE_ARGS), so they resolve the same default model the parent runs
+     * and the parent session's window is the honest answer. 0 / omitted keeps
+     * the old behaviour: report the token count with no window.
+     */
+    contextWindow?: number;
     onToolCall?: (call: ToolCall) => LoopHit | null;
     /**
      * Fires when a tool call finishes, carrying its RESULT (mx5 run 10 item 6: the

package/dist/shared/child-process.js

@@ -88,15 +88,12 @@ export class JsonEventSink {
     handleEvent(evt) {
         const opts = this.opts;
         const t = typeof evt.type === 'string' ? evt.type : '';
-        if (t === 'context_usage' && opts.onContextUsage) {
-            const tokens = Number(evt.tokens ?? 0);
-            const contextWindow = Number(evt.contextWindow ?? 0);
-            const percent = Number(evt.percent ?? 0);
-            if (tokens > 0 || contextWindow > 0) {
-                opts.onContextUsage({ tokens, contextWindow, percent });
-            }
-            return;
-        }
+        // `message_end` is the ONLY context readout pi gives a `--mode json`
+        // child's parent. There used to be a `context_usage` branch above this
+        // one that was preferred over it; no released pi has ever emitted such
+        // an event (see `contextWindow` on RunChildJsonEventsOptions), so it was
+        // unreachable, and its presence is what made the zero window below look
+        // like a harmless fallback rather than the only path. Issue #16.
         if (t === 'message_end' && opts.onContextUsage) {
             const msg = evt.message;
             if (msg?.role === 'assistant') {
@@ -107,7 +104,9 @@ export class JsonEventSink {
                         + Number(usage.cacheWrite ?? 0)
                         + Number(usage.output ?? 0);
                     if (tokens > 0) {
-                        opts.onContextUsage({ tokens, contextWindow: 0, percent: 0 });
+                        const cw = Math.max(0, Number(opts.contextWindow ?? 0));
+                        const percent = cw > 0 ? Math.min(100, (tokens / cw) * 100) : 0;
+                        opts.onContextUsage({ tokens, contextWindow: cw, percent });
                     }
                 }
             }

package/dist/task/child-runner.d.ts

@@ -82,13 +82,30 @@ extensions?: readonly string[],
  * needs the size of what actually entered the child's context, which the
  * CALL alone does not carry (task/stall-detector.ts).
  */
-onToolResult?: (text: string, isError: boolean) => void): Promise<PhaseRunResult>;
+onToolResult?: (text: string, isError: boolean) => void, 
+/**
+ * The child's context window in tokens. Nothing in pi's event stream reports
+ * one (issue #16), so the parent hands its own down — children carry no `-m`
+ * and resolve the same default model. 0 / omitted = unknown, as before.
+ */
+contextWindow?: number): Promise<PhaseRunResult>;
 interface PhaseDeps {
     cwd: string;
     taskId: string;
     signal: AbortSignal;
     onChildOutput?: (line: string) => void;
     onContextUsage?: (snapshot: ContextSnapshot) => void;
+    /**
+     * The parent session's context window in tokens, handed down to every child.
+     *
+     * pi's `--mode json` stream reports token counts but no window (issue #16),
+     * so without this the gauge shows a bare number and — worse — the
+     * StallDetector's CONTEXT CHURN rule, which is gated on a positive window,
+     * can never fire. Children are spawned without `-m` (CHILD_BASE_ARGS) and so
+     * run the parent's own default model; its window is the honest value.
+     * Absent = unknown, and both consumers degrade exactly as they did before.
+     */
+    contextWindow?: number;
     /**
      * Record a sub-step duration under the currently running top-level phase.
      * The orchestrator rebinds this between phases so each call lands in the

package/dist/task/child-runner.js

@@ -172,7 +172,13 @@ extensions,
  * needs the size of what actually entered the child's context, which the
  * CALL alone does not carry (task/stall-detector.ts).
  */
-onToolResult) {
+onToolResult, 
+/**
+ * The child's context window in tokens. Nothing in pi's event stream reports
+ * one (issue #16), so the parent hands its own down — children carry no `-m`
+ * and resolve the same default model. 0 / omitted = unknown, as before.
+ */
+contextWindow) {
     const invocation = getPiInvocation(childArgs(tools, extensions), prompt);
     let loopHit;
     const result = await runChildUnified(spawnFn ?? spawn, invocation, cwd, signal, {
@@ -184,6 +190,7 @@ onToolResult) {
         streamInactivityMs: getConfig().streamInactivityMs,
         onLine,
         onContextUsage,
+        ...(contextWindow && contextWindow > 0 ? { contextWindow } : {}),
         onToolResult: onToolResult ? r => onToolResult(r.text, r.isError) : undefined,
         onToolCall: call => {
             if (!onToolCall)
@@ -316,13 +323,21 @@ export async function runPhaseChild(deps, name, tools, prompt, opts = {}) {
             throw new Error(USER_CANCELLED);
         const detector = new LoopDetector(LOOP_WINDOW, LOOP_THRESHOLD);
         const stall = new StallDetector();
+        // Arm the churn rule BEFORE the first tool call. The window used to reach
+        // the detector only through a context snapshot, and pi's stream never
+        // carries one, so it was always 0 and rule 2 never fired (issue #16). The
+        // parent knows the value at spawn time — say it then, not later.
+        stall.noteContext(deps.contextWindow ?? 0);
         const clock = phaseTimeout(deps.signal, budgetMs);
         let r;
         try {
             r = await runChild(deps.cwd, tools, prependHint(hint, prompt), clock.signal, deps.onChildOutput, snapshot => {
+                // Real window or nothing: noteContext ignores 0, and until
+                // deps.contextWindow existed 0 was all it ever saw, which
+                // left the churn rule permanently disarmed (issue #16).
                 stall.noteContext(snapshot.contextWindow);
                 deps.onContextUsage?.(snapshot);
-            }, call => detector.record(call) ?? stall.record(call), deps.spawn, deps.childExtensions, (text, isError) => stall.noteResult(text, isError));
+            }, call => detector.record(call) ?? stall.record(call), deps.spawn, deps.childExtensions, (text, isError) => stall.noteResult(text, isError), deps.contextWindow);
         }
         finally {
             clock.cleanup();
@@ -430,7 +445,7 @@ async function appendLoopEvent(cwd, taskId, phase, hit, strike, outcome) {
 async function runDegradedFinalAttempt(deps, name, prompt, hit, loopHistory) {
     deps.logDebug?.(`${name}: loop budget exhausted — degrading to a no-tools final attempt`);
     const r = await runChild(deps.cwd, '', // --no-tools: the model cannot read/grep/list, only answer
-    prependHint(formatDegradeHint(hit), prompt), deps.signal, deps.onChildOutput, deps.onContextUsage, undefined, deps.spawn);
+    prependHint(formatDegradeHint(hit), prompt), deps.signal, deps.onChildOutput, deps.onContextUsage, undefined, deps.spawn, undefined, undefined, deps.contextWindow);
     if (r.exitCode !== 0 || r.modelError || r.text.trim().length === 0) {
         throw new LoopExhaustedError(name, loopHistory);
     }

package/dist/task/child-status.d.ts

@@ -34,10 +34,15 @@ export declare class ChildStatus {
     private readonly _parentContextWindow;
     private readonly _startLoader;
     constructor(deps: ChildStatusDeps);
+    /**
+     * The parent session's window — the value handed DOWN to each child so its
+     * own readout carries one, and the last fallback when a child reports none.
+     */
+    get parentContextWindow(): number;
     /** The child's latest stream line. Bind as `onChildOutput` / `onLine`. */
     onLine(line: string): void;
     /**
-     * Fold a raw context_usage snapshot into the gauge: the child's own window,
+     * Fold a raw context snapshot into the gauge: the child's own window,
      * else the last known one, else the parent's (`resolveContextUsage`).
      */
     onContextUsage(snapshot: ContextSnapshot): void;
@@ -91,5 +96,8 @@ export declare function runPlanningChild(opts: {
     prompt: string;
     loader: PlanningChildLoader;
 }): Promise<string>;
-/** Wire a `ChildStatus` as a phase child's stream callbacks. */
-export declare function statusCallbacks(status: ChildStatus): Pick<PhaseDeps, 'onChildOutput' | 'onContextUsage'>;
+/**
+ * Wire a `ChildStatus` as a phase child's stream callbacks — plus the window the
+ * child must be TOLD, since pi's event stream never reports one (issue #16).
+ */
+export declare function statusCallbacks(status: ChildStatus): Pick<PhaseDeps, 'onChildOutput' | 'onContextUsage' | 'contextWindow'>;

package/dist/task/child-status.js

@@ -30,12 +30,19 @@ export class ChildStatus {
         this._parentContextWindow = deps.parentContextWindow;
         this._startLoader = deps.startLoader ?? startAutoLoader;
     }
+    /**
+     * The parent session's window — the value handed DOWN to each child so its
+     * own readout carries one, and the last fallback when a child reports none.
+     */
+    get parentContextWindow() {
+        return this._parentContextWindow;
+    }
     /** The child's latest stream line. Bind as `onChildOutput` / `onLine`. */
     onLine(line) {
         this._lastLine = line;
     }
     /**
-     * Fold a raw context_usage snapshot into the gauge: the child's own window,
+     * Fold a raw context snapshot into the gauge: the child's own window,
      * else the last known one, else the parent's (`resolveContextUsage`).
      */
     onContextUsage(snapshot) {
@@ -90,10 +97,14 @@ export async function runPlanningChild(opts) {
         startedAt
     }), () => runPhaseChild(phaseDeps, name, tools, prompt));
 }
-/** Wire a `ChildStatus` as a phase child's stream callbacks. */
+/**
+ * Wire a `ChildStatus` as a phase child's stream callbacks — plus the window the
+ * child must be TOLD, since pi's event stream never reports one (issue #16).
+ */
 export function statusCallbacks(status) {
     return {
         onChildOutput: line => status.onLine(line),
-        onContextUsage: snapshot => status.onContextUsage(snapshot)
+        onContextUsage: snapshot => status.onContextUsage(snapshot),
+        contextWindow: status.parentContextWindow
     };
 }

package/dist/task/context-usage.d.ts

@@ -9,7 +9,7 @@ import type { ContextSnapshot } from '../shared/child-process.js';
 /** The parent session's context window, or 0 when the model doesn't expose it. */
 export declare function getParentContextWindow(ctx: ExtensionCommandContext): number;
 /**
- * Fold a raw context_usage snapshot into a display snapshot: prefer the child's
+ * Fold a raw context snapshot into a display snapshot: prefer the child's
  * own contextWindow, else the last known one, else the parent session's; then
  * derive percent against it — falling back to the child's reported percent when
  * no window is known at all.

package/dist/task/context-usage.js

@@ -9,7 +9,7 @@ export function getParentContextWindow(ctx) {
     return (ctx.model?.contextWindow ?? 0);
 }
 /**
- * Fold a raw context_usage snapshot into a display snapshot: prefer the child's
+ * Fold a raw context snapshot into a display snapshot: prefer the child's
  * own contextWindow, else the last known one, else the parent session's; then
  * derive percent against it — falling back to the child's reported percent when
  * no window is known at all.

package/dist/task/gate-child.js

@@ -119,7 +119,10 @@ export function makeGateChild(deps) {
                                 + deps.truncateToolResult(text), 'stream')
                         }
                         : {}),
-                    onContextUsage: snapshot => deps.status.onContextUsage(snapshot)
+                    onContextUsage: snapshot => deps.status.onContextUsage(snapshot),
+                    // The gate child has to be TOLD its window: nothing in pi's
+                    // event stream reports one (issue #16).
+                    contextWindow: deps.status.parentContextWindow
                 });
             }
             finally {

package/dist/task/orchestrator.js

@@ -122,6 +122,10 @@ export class TaskRunner {
             onChildOutput: (line) => {
                 this._widgetState.lastLine = line;
             },
+            // Handed DOWN so the child's own snapshot carries a window and the
+            // StallDetector's churn rule can arm; resolveContextUsage below stays
+            // as the fallback for a child that still reports none (issue #16).
+            contextWindow: parentContextWindow,
             onContextUsage: snapshot => {
                 this._widgetState.contextUsage = resolveContextUsage(snapshot, this._widgetState.contextUsage, parentContextWindow);
             },

package/dist/task/stall-detector.d.ts

@@ -38,6 +38,11 @@
  *      rule 1 alone would not have caught it. The bound scales with the model's
  *      OWN window, so a 1M-context model gets a 1M-context allowance.
  *
+ *      The window is supplied by the PARENT at spawn (`PhaseDeps.contextWindow`),
+ *      not read off the child's event stream: pi emits no context event at all,
+ *      which is why this rule sat disarmed from the day it was written until
+ *      GitHub issue #16.
+ *
  * Neither rule can fire on a child that is thinking rather than calling tools:
  * that case is bounded by the model's max tokens (server-enforced) and by the
  * stream watchdog if the stream goes silent. Between the three there is no

package/dist/task/stall-detector.js

@@ -38,6 +38,11 @@
  *      rule 1 alone would not have caught it. The bound scales with the model's
  *      OWN window, so a 1M-context model gets a 1M-context allowance.
  *
+ *      The window is supplied by the PARENT at spawn (`PhaseDeps.contextWindow`),
+ *      not read off the child's event stream: pi emits no context event at all,
+ *      which is why this rule sat disarmed from the day it was written until
+ *      GitHub issue #16.
+ *
  * Neither rule can fire on a child that is thinking rather than calling tools:
  * that case is bounded by the model's max tokens (server-enforced) and by the
  * stream watchdog if the stream goes silent. Between the three there is no

package/dist/task/widget.js

@@ -115,21 +115,35 @@ export function buildWidgetData(s) {
 export function startWidget(ctx, getState) {
     if (!ctx.hasUI)
         return () => { };
+    // `ctx.ui` THROWS once the ctx goes stale (/reload, session replacement), so
+    // the theme read belongs INSIDE the guard, not one line above it. render()
+    // runs from a timer, where an unguarded throw is an uncaughtException that
+    // kills the whole pi process — and a swallowed one would throw again on
+    // every tick, so a stale ctx latches and stops the timer. Issue #15.
+    let stale = false;
     const render = () => {
+        if (stale)
+            return;
         const s = getState();
-        const lines = s ? buildWidgetLines(s, ctx.ui.theme) : undefined;
-        const plain = s ? buildWidgetLines(s, undefined) : undefined; // un-themed for the wire
+        const plain = s ? buildWidgetLines(s, undefined) : undefined; // un-themed for the wire; needs no ctx
         try {
+            const lines = s ? buildWidgetLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(WIDGET_KEY, lines);
         }
         catch {
-            /* stale ctx */
+            stale = true;
+            clearInterval(timer);
+            return;
         }
         setTaskWidget(plain, s ? buildWidgetData(s) : null);
     };
-    render();
+    // The timer is created BEFORE the first render so `timer` is always bound
+    // when render's catch reaches for it: a ctx already stale on the very first
+    // paint now stops the loop there, instead of arming an interval that wakes
+    // up and returns early forever.
     const timer = setInterval(render, WIDGET_REFRESH_MS);
     timer.unref?.();
+    render();
     return () => {
         clearInterval(timer);
         try {
@@ -192,21 +206,32 @@ export function buildAutoLoaderData(s) {
 export function startAutoLoader(ctx, getState) {
     if (!ctx.hasUI)
         return () => { };
+    // Same staleness hazard as startWidget: the theme read must sit inside the
+    // guard, and a stale ctx stops the timer rather than throwing every tick.
+    let stale = false;
     const render = () => {
+        if (stale)
+            return;
         const s = getState();
-        const lines = s ? buildAutoLoaderLines(s, ctx.ui.theme) : undefined;
-        const plain = s ? buildAutoLoaderLines(s, undefined) : undefined;
+        const plain = s ? buildAutoLoaderLines(s, undefined) : undefined; // needs no ctx
         try {
+            const lines = s ? buildAutoLoaderLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(AUTO_WIDGET_KEY, lines);
         }
         catch {
-            /* stale ctx */
+            stale = true;
+            clearInterval(timer);
+            return;
         }
         setTaskWidget(plain, s ? buildAutoLoaderData(s) : null);
     };
-    render();
+    // The timer is created BEFORE the first render so `timer` is always bound
+    // when render's catch reaches for it: a ctx already stale on the very first
+    // paint now stops the loop there, instead of arming an interval that wakes
+    // up and returns early forever.
     const timer = setInterval(render, WIDGET_REFRESH_MS);
     timer.unref?.();
+    render();
     return () => {
         clearInterval(timer);
         try {
@@ -249,7 +274,14 @@ export function buildImplData(s) {
 export function flashTerminalWidget(ctx, state, taskId, reason) {
     if (!ctx.hasUI)
         return;
-    const theme = ctx.ui.theme;
+    // Same staleness hazard as the render timers: bail rather than throw.
+    let theme;
+    try {
+        theme = ctx.ui.theme;
+    }
+    catch {
+        return;
+    }
     let line;
     let clearMs;
     if (state === 'cancelled') {

package/dist/workers/pi-worker-core.d.ts

@@ -62,12 +62,19 @@ export interface RunWorkerInput {
         toolCallId?: string;
     }) => void;
     /**
-     * Called for each context_usage snapshot the child emits (same `--mode json`
-     * stream the phase children parse). Lets a caller's status widget show the
-     * tokens/window progress bar for the worker exactly like the phase widget,
-     * instead of omitting it.
+     * Called for each context snapshot derived from the child's `message_end`
+     * events (same `--mode json` stream the phase children parse). Lets a
+     * caller's status widget show the tokens/window progress bar for the worker
+     * exactly like the phase widget, instead of omitting it.
      */
     onContextUsage?: (snapshot: ContextSnapshot) => void;
+    /**
+     * The worker child's context window in tokens. pi's event stream carries no
+     * window (issue #16), so a caller that wants a progress bar rather than a
+     * bare token count has to supply the parent session's — which is the child's
+     * too, since workers are spawned without `-m`.
+     */
+    contextWindow?: number;
     /**
      * Per-worker wall-clock timeout in ms. Defaults to RESEARCH_WORKER_TIMEOUT_MS.
      * Pass 0 to disable the timeout entirely (run until the child exits on its

package/dist/workers/pi-worker-core.js

@@ -549,7 +549,10 @@ export async function runWorker(input) {
                     cmdWatch?.onEnd(r.toolCallId);
                     input.onToolResult?.(r);
                 },
-                onContextUsage: input.onContextUsage
+                onContextUsage: input.onContextUsage,
+                ...(input.contextWindow && input.contextWindow > 0 ?
+                    { contextWindow: input.contextWindow }
+                    : {})
             }, input.spawn);
         }
         finally {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.38.17",
+    "version": "0.38.19",
     "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",
@@ -32,9 +32,9 @@
         "ws": "8.21.0"
     },
     "devDependencies": {
-        "@earendil-works/pi-agent-core": "0.80.2",
-        "@earendil-works/pi-coding-agent": "0.80.2",
-        "@earendil-works/pi-tui": "0.80.2",
+        "@earendil-works/pi-agent-core": "0.84.2",
+        "@earendil-works/pi-coding-agent": "0.84.2",
+        "@earendil-works/pi-tui": "0.84.2",
         "@eslint/js": "10.0.1",
         "@types/bun": "1.3.12",
         "@types/qrcode": "1.5.6",