@mjasnikovs/pi-task 0.38.28 → 0.38.29

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

@@ -4,10 +4,21 @@
  * the planning and gate children; the single-task widget (TaskRunner) calls it
  * directly, because its state is the whole-run `WidgetState`, not one child's.
  */
-import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 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;
+/**
+ * The parent session's context window, or 0 when the model doesn't expose it.
+ *
+ * The parameter is the STRUCTURAL MINIMUM this reads, not one of pi's context
+ * interfaces. It took `ExtensionCommandContext` and immediately cast it away,
+ * which is a lie that also excluded the plain `ExtensionContext` a TOOL is
+ * handed — the very caller (`workers/pi-worker.ts`) that needs the window to arm
+ * the churn rule. Both pi contexts satisfy this shape.
+ */
+export declare function getParentContextWindow(ctx: {
+    model?: {
+        contextWindow?: number;
+    };
+}): number;
 /**
  * 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

package/dist/task/context-usage.js

@@ -4,9 +4,17 @@
  * the planning and gate children; the single-task widget (TaskRunner) calls it
  * directly, because its state is the whole-run `WidgetState`, not one child's.
  */
-/** The parent session's context window, or 0 when the model doesn't expose it. */
+/**
+ * The parent session's context window, or 0 when the model doesn't expose it.
+ *
+ * The parameter is the STRUCTURAL MINIMUM this reads, not one of pi's context
+ * interfaces. It took `ExtensionCommandContext` and immediately cast it away,
+ * which is a lie that also excluded the plain `ExtensionContext` a TOOL is
+ * handed — the very caller (`workers/pi-worker.ts`) that needs the window to arm
+ * the churn rule. Both pi contexts satisfy this shape.
+ */
 export function getParentContextWindow(ctx) {
-    return (ctx.model?.contextWindow ?? 0);
+    return ctx.model?.contextWindow ?? 0;
 }
 /**
  * Fold a raw context snapshot into a display snapshot: prefer the child's

package/dist/task/gate-child.js

@@ -105,6 +105,7 @@ export function makeGateChild(deps) {
                     // burned two attempts reads exactly like one that ran clean.
                     onRestart: rs => log(`=== ${deps.kind} RESTART (attempt ${rs.attempt} discarded)`
                         + ` reason=${rs.reason} wall=${rs.wallMs}ms`
+                        + ` discarded=${rs.partialChars}ch`
                         + (rs.detail ? ` — ${rs.detail}` : '')
                         + ' ==='),
                     onLine: line => {

package/dist/task/phases.js

@@ -679,6 +679,7 @@ export async function phaseResearch(deps, refined) {
      */
     const drive = (spec, prior) => runResearchWorker(spec, {
         runWorker: runWorkerFn,
+        contextWindow: deps.contextWindow ?? 'unknown',
         cwd: deps.cwd,
         taskId: deps.taskId,
         signal: deps.signal,

package/dist/task/research-worker.d.ts

@@ -65,6 +65,13 @@ export interface ResearchWorkerSpec {
  */
 export interface ResearchWorkerRun {
     runWorker: (label: string, input: RunWorkerInput) => Promise<RunWorkerResult>;
+    /**
+     * The parent session's context window, forwarded to every worker child.
+     * `PhaseDeps.contextWindow` already carried it and this driver dropped it, so
+     * the churn rule was dead for all four workers — see
+     * `RunWorkerInput.contextWindow`.
+     */
+    contextWindow: number | 'unknown';
     cwd: string;
     taskId: string;
     signal: AbortSignal;

package/dist/task/research-worker.js

@@ -247,6 +247,7 @@ export async function runResearchWorker(spec, run, prior = []) {
     const runOnce = (extraPreamble) => run.record(spec.label, run.runWorker(spec.label, {
         prompt: extraPreamble ? `${extraPreamble}\n\n${basePrompt}` : basePrompt,
         cwd: run.cwd,
+        contextWindow: run.contextWindow,
         signal: run.signal,
         spawn: run.spawn,
         // ONE CELL PER WORKER since 2026-08-28. They used to share
@@ -286,6 +287,7 @@ export async function runResearchWorker(spec, run, prior = []) {
         onRestart: rs => {
             run.logDebug?.(`${spec.label}: RESTART (attempt ${rs.attempt} discarded)`
                 + ` reason=${rs.reason} wall=${rs.wallMs}ms`
+                + ` discarded=${rs.partialChars}ch`
                 + ` wait=${rs.waitMs}ms work=${rs.workMs}ms`
                 + (rs.detail ? ` — ${rs.detail}` : ''));
             run.onChildOutput?.(`${spec.label}: restart (${rs.reason})`);

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

@@ -82,12 +82,29 @@ export interface RunWorkerInput {
      */
     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`.
+     * The worker child's context window in tokens, or `'unknown'` when the
+     * caller genuinely has none.
+     *
+     * REQUIRED, and required for the same reason `profile` below is. This was
+     * `contextWindow?: number`, and two of the three production call sites simply
+     * did not write it: `pi-worker.ts` and `research-worker.ts`. pi's event
+     * stream carries no window (issue #16), so `noteContext` only ever saw 0, and
+     * `StallDetector`'s CONTEXT CHURN rule — gated on a positive window
+     * (`stall-detector.ts`) — could never fire for the ad-hoc worker or for any
+     * of the four research workers. Nothing was red. The optional was the whole
+     * defect: a rule that silently does not exist reads exactly like a rule that
+     * exists and did not trip.
+     *
+     * WHY A WORD AND NOT `0` OR `null`. Both of those are what a caller types
+     * when it has not thought about the question, and both disarm the rule
+     * silently — which is the state this replaces. `'unknown'` cannot be typed by
+     * accident, is greppable, and shows up in a diff as a decision.
+     *
+     * Two consumers read it: the churn rule, and the caller's progress bar, which
+     * shows a bare token count without a window. Both degrade exactly as before
+     * on `'unknown'`.
      */
-    contextWindow?: number;
+    contextWindow: number | 'unknown';
     /**
      * WHICH KIND of worker child this is — the whole guard policy, in one word.
      *
@@ -178,6 +195,23 @@ export interface WorkerRestart {
     workMs: number;
     /** Reason-specific diagnosis: the looping call, the hung tool, the error text. */
     detail?: string;
+    /**
+     * Characters of ANSWER TEXT this attempt had produced at the moment it was
+     * thrown away.
+     *
+     * Recorded whatever `carryForward` says, because the DISCARD is the thing a
+     * reader cannot otherwise see. A restart line reported how long an attempt
+     * ran and why it died, and never what died with it — so "the guards worked
+     * and the run still returned 52 characters" and "the guards worked and the
+     * run threw away a finished answer" print identically. Measured on the
+     * ad-hoc `pi-worker` corpus: T024 lost an attempt to a dropped model socket
+     * at 275s and returned 52 chars over 620s; nothing in the run said whether
+     * those 275s held anything.
+     *
+     * It is an OBSERVATION, not a decision: harvesting into `salvage` is still
+     * gated on the profile, and this number changes no behaviour.
+     */
+    partialChars: number;
 }
 export interface RunWorkerResult {
     text: string;

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

@@ -20,6 +20,14 @@ import { applyOverride, WORKER_PROFILES } from './worker-profiles.js';
 // model starts producing — making waitMs the real queue/cold-start cost and
 // workMs the real generation+tool-call cost.
 const DEFAULT_TOOLS = 'read,grep,find,ls';
+/**
+ * The one place `'unknown'` becomes the 0 both consumers already treat as
+ * "no window". Written once so a future reader cannot re-introduce the optional
+ * by handling the union at only one of the two sites that read it.
+ */
+function contextWindowTokens(cw) {
+    return cw === 'unknown' || cw <= 0 ? 0 : cw;
+}
 /**
  * Tool calls that can GROUND an APIS claim — i.e. return content a signature or
  * command could be cited from. `pi-worker-docs` (the primary), `read` and `grep`
@@ -500,7 +508,7 @@ export async function runWorker(input) {
         // Arm the churn rule BEFORE the first tool call. pi's stream carries no
         // context event (issue #16), so waiting for one leaves the rule
         // permanently disarmed. The parent knows the window at spawn time.
-        stallDetector?.noteContext(input.contextWindow ?? 0);
+        stallDetector?.noteContext(contextWindowTokens(input.contextWindow));
         // Capture the hit the detector reports (it also returns it to the unified
         // runner, which kills the child on a hit). Without capturing it here the
         // SIGTERM that kill produces would surface as a bare non-zero exit the
@@ -579,8 +587,8 @@ export async function runWorker(input) {
                     stallDetector?.noteContext(snapshot.contextWindow);
                     input.onContextUsage?.(snapshot);
                 },
-                ...(input.contextWindow && input.contextWindow > 0 ?
-                    { contextWindow: input.contextWindow }
+                ...(contextWindowTokens(input.contextWindow) > 0 ?
+                    { contextWindow: contextWindowTokens(input.contextWindow) }
                     : {})
             }, input.spawn);
         }
@@ -601,6 +609,7 @@ export async function runWorker(input) {
                 wallMs: tEnd - tAttemptStart,
                 waitMs,
                 workMs,
+                partialChars: text.trim().length,
                 ...(detail ? { detail } : {})
             };
             restarts.push(record);

package/dist/workers/pi-worker.js

@@ -11,6 +11,7 @@ import { Type } from '@sinclair/typebox';
 import { getConfig } from '../config/config.js';
 import { groupThinkingArgs } from '../config/reasoning-args.js';
 import { runWorker } from './pi-worker-core.js';
+import { getParentContextWindow } from '../task/context-usage.js';
 import { childFailureReason, formatChildFailure, makeWorkerTool, workerAnswer, workerUnavailable } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
 const WorkerParams = Type.Object({
@@ -54,6 +55,11 @@ export function registerPiWorker(pi) {
                 // not policy for the same reason the gate's two ceilings are: the
                 // number is the user's, the decision to arm it is the profile's.
                 policyInputs: { streamInactivityMs: getConfig().streamInactivityMs },
+                // The session's own window, handed down. The child is spawned
+                // without `-m`, so the parent's model IS the child's model and
+                // its window is the honest one. Without this the churn rule
+                // cannot fire — see RunWorkerInput.contextWindow.
+                contextWindow: getParentContextWindow(ctx) || 'unknown',
                 thinking: groupThinkingArgs('research')
             });
             const details = { exitCode: result.exitCode };

package/package.json

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