@mjasnikovs/pi-task 0.38.18 → 0.38.20

package/dist/workers/index.js

@@ -3,10 +3,12 @@ import { registerPiWorkerSearch } from './pi-worker-search.js';
 import { registerPiWorkerFetch } from './pi-worker-fetch.js';
 import { registerPiWorkerDocs } from './pi-worker-docs.js';
 import { registerBraveKeyWarning } from './brave-warning.js';
+import { registerReasoningWarning } from './reasoning-warning.js';
 export function registerWorkers(pi) {
     registerPiWorker(pi);
     registerPiWorkerSearch(pi);
     registerPiWorkerFetch(pi);
     registerPiWorkerDocs(pi);
     registerBraveKeyWarning(pi);
+    registerReasoningWarning(pi);
 }

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

@@ -33,6 +33,18 @@ export { isGroundingRetrieval } from './worker-channels.js';
  * at no particular column and does not repeat that shape.
  */
 export declare function hasAnswerContent(text: string): boolean;
+/**
+ * Is ONE line an entry — a name, a gap, then a description — rather than prose?
+ *
+ * Split out of `hasAnswerContent` so the same rule can decide what a line IS,
+ * not just how many of them there are. A FILES section's paths are read back
+ * with it, and a scorer that used its own idea of an entry counted a preamble
+ * sentence and a leaked `</tool_call>` as invented paths.
+ *
+ * Prose wraps at no particular column, so it carries no two-space gap and no
+ * spaced dash; when it does, it ends in `.` or `:` and an entry does not.
+ */
+export declare function isEntryLine(raw: string): boolean;
 /**
  * Frame a discarded attempt's output as work already done.
  *
@@ -62,12 +74,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
@@ -170,6 +189,16 @@ export interface RunWorkerInput {
         chars: number;
         promptCharsBefore: number;
     }) => void;
+    /**
+     * An already-resolved `['--thinking', level]` fragment, or `[]`/omitted to
+     * inherit the session default exactly as before.
+     *
+     * Resolved by the CALLER because runWorker serves three different reasoning
+     * groups — the research workers, the post-implementation gates, and the
+     * ad-hoc `pi-worker` tool — and has nothing in its input that tells them
+     * apart. Guessing here would give a verify gate the research workers' level.
+     */
+    thinking?: readonly string[];
     /**
      * Called once per DISCARDED attempt, at the moment the worker decides to
      * re-spawn — the only window in which a restart is observable at all.

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

@@ -114,11 +114,22 @@ const CARRY_FORWARD_REASONS = new Set([
  * at no particular column and does not repeat that shape.
  */
 export function hasAnswerContent(text) {
-    const entryish = text
-        .split('\n')
-        .map(l => l.replace(/^\s*(?:[-*•]|\d+[.)])\s+/, '').trim())
-        .filter(l => /^\S.*?(?:\s{2,}|\s+[—–-]\s+)\S/.test(l) && !/[.:]$/.test(l));
-    return entryish.length >= 2;
+    return text.split('\n').filter(isEntryLine).length >= 2;
+}
+/**
+ * Is ONE line an entry — a name, a gap, then a description — rather than prose?
+ *
+ * Split out of `hasAnswerContent` so the same rule can decide what a line IS,
+ * not just how many of them there are. A FILES section's paths are read back
+ * with it, and a scorer that used its own idea of an entry counted a preamble
+ * sentence and a leaked `</tool_call>` as invented paths.
+ *
+ * Prose wraps at no particular column, so it carries no two-space gap and no
+ * spaced dash; when it does, it ends in `.` or `:` and an entry does not.
+ */
+export function isEntryLine(raw) {
+    const l = raw.replace(/^\s*(?:[-*•]|\d+[.)])\s+/, '').trim();
+    return /^\S.*?(?:\s{2,}|\s+[—–-]\s+)\S/.test(l) && !/[.:]$/.test(l);
 }
 /**
  * Frame a discarded attempt's output as work already done.
@@ -420,7 +431,14 @@ function commandWatch(timeoutMs) {
 }
 export async function runWorker(input) {
     const tools = input.tools ?? DEFAULT_TOOLS;
-    const baseArgs = [...childBaseArgs(input.extensions ?? []), '--mode', 'json', '--tools', tools];
+    const baseArgs = [
+        ...childBaseArgs(input.extensions ?? []),
+        ...(input.thinking ?? []),
+        '--mode',
+        'json',
+        '--tools',
+        tools
+    ];
     const timeoutMs = input.timeoutMs ?? RESEARCH_WORKER_TIMEOUT_MS;
     let hint = null;
     // Loop-kill and timeout share one restart budget, mirroring
@@ -549,7 +567,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/dist/workers/pi-worker-docs.js

@@ -14,6 +14,7 @@ import { normalizeQuery } from './research-cache.js';
 import { projectDocsRaw, buildProjectPrompt } from './docs-project.js';
 import { projectDocsBudget, projectDocsBudgetExhausted } from '../task/research-fanout-budget.js';
 import { isAbstention } from './abstention.js';
+import { groupThinkingArgs } from '../config/reasoning-args.js';
 const RENDER_QUERY_MAX = 100;
 const Params = Type.Object({
     module: Type.String({
@@ -137,6 +138,9 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 cwd: ctx.cwd,
                 signal,
                 spawn,
+                // The `extraction` group's level. Resolved at the call site so the
+                // extractor itself never reads ambient config.
+                thinking: groupThinkingArgs('extraction'),
                 abortedMessage
             });
             // ── Project source lookup ───────────────────────────────────────

package/dist/workers/pi-worker.js

@@ -8,6 +8,7 @@
  */
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
+import { groupThinkingArgs } from '../config/reasoning-args.js';
 import { runWorker } from './pi-worker-core.js';
 import { childFailureReason, formatChildFailure, makeWorkerTool, workerAnswer, workerUnavailable } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
@@ -38,7 +39,16 @@ export function registerPiWorker(pi) {
             + '- The task needs the web — use `pi-worker-search` / `pi-worker-fetch`',
         parameters: WorkerParams,
         async run(params, signal, ctx) {
-            const result = await runWorker({ prompt: params.prompt, cwd: ctx.cwd, signal });
+            // Grouped with `research`: this is the same read-only exploration
+            // loop the four research workers run, just dispatched by a model
+            // rather than by the pipeline. Left ungrouped it would be the one
+            // child that never honoured a profile.
+            const result = await runWorker({
+                prompt: params.prompt,
+                cwd: ctx.cwd,
+                signal,
+                thinking: groupThinkingArgs('research')
+            });
             const details = { exitCode: result.exitCode };
             const failure = formatChildFailure(result, 'Worker aborted.');
             if (failure !== null) {

package/dist/workers/reasoning-warning.d.ts

@@ -0,0 +1,64 @@
+/**
+ * One-line startup hint shown when /task-config asks for a thinking level the
+ * connected model will not honour.
+ *
+ * WHY IT HAS TO EXIST. pi never says it ignored or downgraded a level. Measured
+ * live with a proxy on the request body: a model with `reasoning: false` given
+ * `--thinking medium` sends no reasoning field at all, and a model whose
+ * `thinkingLevelMap` nulls `off` given `--thinking off` is clamped UP to
+ * `medium` — thinking stays on. Both are silent. A reasoning profile the user
+ * set and the model erased is worse than no profile feature, because it looks
+ * like it worked.
+ *
+ * ANTI-NAG. This warns once per session and clears on the first keystroke, and
+ * that is the whole mechanism — deliberately no "already warned about model X"
+ * file. Such a record goes stale the moment models.json is edited, and would
+ * suppress the warning at exactly the moment a `/model` switch made it true.
+ * brave-warning.ts nags every session for a standing misconfiguration and that
+ * is correct; this is the same class. The real anti-nag is `inherit`: with the
+ * shipped all-`inherit` table, `reasoningMismatches` returns empty for every
+ * model and nothing renders at all.
+ */
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { type PiTaskConfig } from '../config/config.js';
+import { REASONING_GROUPS, resolveReasoning } from '../config/reasoning.js';
+import { type ReasoningMismatch } from '../shared/reasoning-capability.js';
+/** Every group's current setting, in the shape `reasoningMismatches` wants. */
+export type GroupSettings = Array<{
+    group: (typeof REASONING_GROUPS)[number];
+    setting: ReturnType<typeof resolveReasoning>;
+}>;
+/**
+ * Read every group's effective setting from a config.
+ *
+ * Takes the config rather than calling `getConfig()` so the caller decides where
+ * it comes from. A test that has to mutate the live singleton to drive this is a
+ * test whose result depends on whatever the developer had saved before it ran.
+ */
+export declare function settingsFrom(cfg: PiTaskConfig): GroupSettings;
+/**
+ * The warning line for a set of mismatches.
+ *
+ * Names the MODEL it checked, because children carry no `-m` and resolve pi's
+ * default model, which need not be the host session's — a warning that does not
+ * say what it looked at cannot be acted on. Names at most two groups; the count
+ * carries the rest, since a line long enough to list seven is a line nobody
+ * reads.
+ */
+export declare function formatReasoningWarning(modelName: string, mismatches: readonly ReasoningMismatch[]): string | null;
+/**
+ * The extra cause line, when the SERVER disagrees with models.json.
+ *
+ * This is the `/login llama.cpp` case and the only thing the host-side clamp
+ * cannot see: pi's built-in llama.cpp provider hardcodes `reasoning: false`, so
+ * a perfectly capable server is described to pi as having no reasoning at all.
+ * Returns null whenever the two agree, or when there was nothing to compare.
+ */
+export declare function formatCapabilityConflict(serverSupportsEffort: boolean | null, modelDeclaresReasoning: boolean): string | null;
+export declare function registerReasoningWarning(pi: ExtensionAPI, 
+/**
+ * Where the group settings come from. Defaults to the live config, read at
+ * `session_start` so a /task-config change since the last session counts.
+ * Injected by tests, which must not depend on the developer's saved config.
+ */
+readSettings?: () => GroupSettings): void;

package/dist/workers/reasoning-warning.js

@@ -0,0 +1,142 @@
+/**
+ * One-line startup hint shown when /task-config asks for a thinking level the
+ * connected model will not honour.
+ *
+ * WHY IT HAS TO EXIST. pi never says it ignored or downgraded a level. Measured
+ * live with a proxy on the request body: a model with `reasoning: false` given
+ * `--thinking medium` sends no reasoning field at all, and a model whose
+ * `thinkingLevelMap` nulls `off` given `--thinking off` is clamped UP to
+ * `medium` — thinking stays on. Both are silent. A reasoning profile the user
+ * set and the model erased is worse than no profile feature, because it looks
+ * like it worked.
+ *
+ * ANTI-NAG. This warns once per session and clears on the first keystroke, and
+ * that is the whole mechanism — deliberately no "already warned about model X"
+ * file. Such a record goes stale the moment models.json is edited, and would
+ * suppress the warning at exactly the moment a `/model` switch made it true.
+ * brave-warning.ts nags every session for a standing misconfiguration and that
+ * is correct; this is the same class. The real anti-nag is `inherit`: with the
+ * shipped all-`inherit` table, `reasoningMismatches` returns empty for every
+ * model and nothing renders at all.
+ */
+import { getConfig } from '../config/config.js';
+import { REASONING_GROUPS, resolveReasoning } from '../config/reasoning.js';
+import { reasoningMismatches } from '../shared/reasoning-capability.js';
+import { probeChatTemplateCaps } from '../shared/model-endpoint.js';
+const WIDGET_KEY = 'pi-task-reasoning-warning';
+/**
+ * Read every group's effective setting from a config.
+ *
+ * Takes the config rather than calling `getConfig()` so the caller decides where
+ * it comes from. A test that has to mutate the live singleton to drive this is a
+ * test whose result depends on whatever the developer had saved before it ran.
+ */
+export function settingsFrom(cfg) {
+    return REASONING_GROUPS.map(group => ({ group, setting: resolveReasoning(group, cfg) }));
+}
+/**
+ * The warning line for a set of mismatches.
+ *
+ * Names the MODEL it checked, because children carry no `-m` and resolve pi's
+ * default model, which need not be the host session's — a warning that does not
+ * say what it looked at cannot be acted on. Names at most two groups; the count
+ * carries the rest, since a line long enough to list seven is a line nobody
+ * reads.
+ */
+export function formatReasoningWarning(modelName, mismatches) {
+    if (mismatches.length === 0)
+        return null;
+    const shown = mismatches
+        .slice(0, 2)
+        .map(m => `${m.group} ${m.wanted}→${m.actual}`)
+        .join(', ');
+    const rest = mismatches.length > 2 ? ` (+${mismatches.length - 2} more)` : '';
+    return (`⚠ pi-task: model "${modelName}" will not run the reasoning levels /task-config asks `
+        + `for — ${shown}${rest}. pi clamps to what the model declares. Fix "reasoning" / `
+        + '"thinkingLevelMap" for it in ~/.pi/agent/models.json, or set those steps back to '
+        + '"inherit" in /task-config');
+}
+/**
+ * The extra cause line, when the SERVER disagrees with models.json.
+ *
+ * This is the `/login llama.cpp` case and the only thing the host-side clamp
+ * cannot see: pi's built-in llama.cpp provider hardcodes `reasoning: false`, so
+ * a perfectly capable server is described to pi as having no reasoning at all.
+ * Returns null whenever the two agree, or when there was nothing to compare.
+ */
+export function formatCapabilityConflict(serverSupportsEffort, modelDeclaresReasoning) {
+    if (serverSupportsEffort === null)
+        return null;
+    if (serverSupportsEffort && !modelDeclaresReasoning) {
+        return (" — the server's chat template DOES support reasoning; it is the model entry pi is "
+            + 'using that says reasoning:false. `/login llama.cpp` hardcodes that, so a '
+            + 'hand-written models.json provider entry is the fix');
+    }
+    if (!serverSupportsEffort && modelDeclaresReasoning) {
+        return " — the server's chat template does not read reasoning_effort, so only on/off takes effect";
+    }
+    return null;
+}
+export function registerReasoningWarning(pi, 
+/**
+ * Where the group settings come from. Defaults to the live config, read at
+ * `session_start` so a /task-config change since the last session counts.
+ * Injected by tests, which must not depend on the developer's saved config.
+ */
+readSettings = () => settingsFrom(getConfig())) {
+    pi.on('session_start', (_event, ctx) => {
+        // Terminal-only hint: needs an interactive TUI to render and to catch the
+        // keystroke that dismisses it.
+        if (ctx.mode !== 'tui')
+            return;
+        const model = ctx.model;
+        const mismatches = reasoningMismatches(model, readSettings());
+        if (mismatches.length === 0)
+            return;
+        const base = formatReasoningWarning(model?.name ?? model?.id ?? 'unknown', mismatches);
+        if (base === null)
+            return;
+        let unsubscribe = null;
+        let cleared = false;
+        const clear = () => {
+            cleared = true;
+            try {
+                ctx.ui.setWidget(WIDGET_KEY, undefined);
+            }
+            catch {
+                /* stale ctx after a session switch — nothing to clear */
+            }
+            unsubscribe?.();
+            unsubscribe = null;
+        };
+        const render = (text) => {
+            try {
+                ctx.ui.setWidget(WIDGET_KEY, [ctx.ui.theme.fg('warning', text)]);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (!render(base))
+            return;
+        unsubscribe = ctx.ui.onTerminalInput(() => {
+            clear();
+            return undefined;
+        });
+        // Fire-and-forget: the server probe only ever REFINES the cause line, so
+        // it must not delay the warning or be able to prevent it. A 2s budget and
+        // a swallowed failure mean a non-llama.cpp backend costs nothing.
+        if (model?.baseUrl) {
+            void probeChatTemplateCaps(model.baseUrl)
+                .then(caps => {
+                if (cleared || caps === null)
+                    return;
+                const extra = formatCapabilityConflict(caps.supportsReasoningEffort, model.reasoning);
+                if (extra)
+                    render(base + extra);
+            })
+                .catch(() => { });
+        }
+    });
+}

package/package.json

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