@mjasnikovs/pi-task 0.38.32 → 0.39.1

package/dist/shared/model-resolve.js

@@ -0,0 +1,97 @@
+import { MODEL_INHERIT, splitSpec } from '../config/group-models.js';
+import { CHILD_GROUPS } from '../config/groups.js';
+/** The `provider/id` inverse of {@link splitSpec}. */
+export function specOf(model) {
+    return `${model.provider}/${model.id}`;
+}
+/**
+ * `inherit` is the session's model. That is decision 3 of the model table —
+ * children are NOT switched to follow the host — and the honest value is
+ * settings.json's default, which need not be the session's. Naming the
+ * session's model is still the better of the two: it is the one the user can
+ * see, and on every machine with one provider the two agree.
+ *
+ * `find` is EXACT, deliberately stricter than pi's own CLI, which also
+ * substring-matches. We store a canonical `provider/id`, so exact is the only
+ * match that should ever count.
+ */
+export function resolveModel(ctx, spec) {
+    try {
+        const parts = spec === MODEL_INHERIT ? undefined : splitSpec(spec);
+        const handle = spec === MODEL_INHERIT ?
+            ctx.model
+            : parts && ctx.modelRegistry?.find(parts.provider, parts.id);
+        if (!handle)
+            return undefined;
+        const provider = parts?.provider ?? handle.provider;
+        const extensionProviders = ctx.modelRegistry?.getRegisteredProviderIds?.() ?? [];
+        return {
+            spec: parts ? spec : specOf(handle),
+            name: handle.name || handle.id,
+            reasoning: handle.reasoning,
+            ...(handle.thinkingLevelMap === undefined ?
+                {}
+                : { thinkingLevelMap: handle.thinkingLevelMap }),
+            ...(handle.baseUrl ? { baseUrl: handle.baseUrl } : {}),
+            contextWindow: handle.contextWindow ?? 0,
+            fromExtension: extensionProviders.includes(provider),
+            handle
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Every group's cell in ONE registry walk, so the argv drop, the churn window
+ * and the hint can never disagree about which model a group runs on.
+ *
+ * An `inherit` cell gets NO window. Storing the parent's would freeze a
+ * session_start snapshot in front of the live per-run value: a user who
+ * switches the session model with Ctrl+P to a bigger one would have every
+ * child judged against the old window, and the churn rule then fires early and
+ * kills a healthy child. An unresolved cell gets none for the same reason —
+ * such a child runs on the live default, whichever that is by then.
+ *
+ * A registry that cannot answer condemns NOTHING: every cell stays usable and
+ * carries no window. Claiming every spec unresolved would drop every `--model`
+ * on a session whose runtime merely was not ready.
+ */
+export function resolveGroupModels(ctx, specs) {
+    const registry = readRegistry(ctx);
+    const cell = (spec) => {
+        if (spec === MODEL_INHERIT || registry === undefined)
+            return { spec, usable: true };
+        const found = resolveModel({ modelRegistry: registry }, spec);
+        if (!found)
+            return { spec, usable: false, problem: 'unresolved' };
+        return {
+            spec,
+            usable: true,
+            ...(found.contextWindow > 0 ? { contextWindow: found.contextWindow } : {}),
+            ...(found.fromExtension ? { problem: 'extension' } : {})
+        };
+    };
+    return Object.fromEntries(CHILD_GROUPS.map(g => [g, cell(specs[g])]));
+}
+/**
+ * `spec → baseUrl` for every model this session can use, for the dead-backend
+ * probe (shared/model-endpoint.ts). Empty when the registry cannot answer,
+ * which the probe reads as "cannot see, so never kill".
+ */
+export function resolveModelEndpoints(ctx) {
+    const out = new Map();
+    for (const m of readRegistry(ctx)?.getAvailable?.() ?? []) {
+        if (m.baseUrl)
+            out.set(specOf(m), m.baseUrl);
+    }
+    return out;
+}
+function readRegistry(ctx) {
+    try {
+        return ctx.modelRegistry;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/shared/reasoning-capability.d.ts

@@ -67,6 +67,26 @@ export declare function supportedThinkingLevels(model: ReasoningModelFacts): Lad
  * the model supports it — which is what makes the inequality a mismatch test.
  */
 export declare function clampToModel(model: ReasoningModelFacts, level: LadderLevel): LadderLevel;
+/**
+ * The settings a /task-config row may offer, given the model its group runs on.
+ *
+ * The INTERSECTION with `REASONING_SETTINGS`, not `supportedThinkingLevels`
+ * directly: that returns the whole ladder including `xhigh` and `max`, which
+ * the menu excludes on purpose (see config/reasoning.ts) because pi's own UI
+ * may not offer them. A model declaring `xhigh` must not smuggle it in.
+ */
+export declare function offeredLevels(facts: ReasoningModelFacts | undefined): GroupSetting[];
+/**
+ * The setting a row will really run at, inside the menu's own vocabulary.
+ *
+ * ONE function for the picker's preselect and the writer, because they used to
+ * be two copies of the same clamp and only one re-projected into
+ * {@link offeredLevels}. `clampToModel` walks UP first and knows the whole
+ * ladder, so a model declaring `xhigh` can land on a level the menu excludes;
+ * a writer that stored it would put a value in the table that no row can show.
+ * The highest OFFERED level is the honest neighbour of an excluded one.
+ */
+export declare function effectiveSetting(facts: ReasoningModelFacts | undefined, wanted: GroupSetting): GroupSetting;
 /** One group whose configured setting the model it runs on will not honour. */
 export interface ReasoningMismatch {
     group: ChildGroup;

package/dist/shared/reasoning-capability.js

@@ -30,7 +30,7 @@
  * line-for-line identical to it, ladder included. Nothing here imports pi-ai, so
  * an upstream change will not fail a test — the two have to be re-compared.
  */
-import { CHILD_GROUPS } from '../config/reasoning.js';
+import { CHILD_GROUPS, REASONING_SETTINGS } from '../config/reasoning.js';
 /**
  * pi's own level ladder, in order — the same seven names, in the same sequence,
  * as `EXTENDED_THINKING_LEVELS` in pi-ai's models.js. The order IS the algorithm:
@@ -86,6 +86,37 @@ export function clampToModel(model, level) {
     }
     return available[0] ?? 'off';
 }
+/**
+ * The settings a /task-config row may offer, given the model its group runs on.
+ *
+ * The INTERSECTION with `REASONING_SETTINGS`, not `supportedThinkingLevels`
+ * directly: that returns the whole ladder including `xhigh` and `max`, which
+ * the menu excludes on purpose (see config/reasoning.ts) because pi's own UI
+ * may not offer them. A model declaring `xhigh` must not smuggle it in.
+ */
+export function offeredLevels(facts) {
+    if (facts === undefined)
+        return [...REASONING_SETTINGS];
+    const supported = supportedThinkingLevels(facts);
+    return REASONING_SETTINGS.filter(s => s === 'inherit' || supported.includes(s));
+}
+/**
+ * The setting a row will really run at, inside the menu's own vocabulary.
+ *
+ * ONE function for the picker's preselect and the writer, because they used to
+ * be two copies of the same clamp and only one re-projected into
+ * {@link offeredLevels}. `clampToModel` walks UP first and knows the whole
+ * ladder, so a model declaring `xhigh` can land on a level the menu excludes;
+ * a writer that stored it would put a value in the table that no row can show.
+ * The highest OFFERED level is the honest neighbour of an excluded one.
+ */
+export function effectiveSetting(facts, wanted) {
+    if (facts === undefined || wanted === 'inherit')
+        return wanted;
+    const offered = offeredLevels(facts);
+    const clamped = clampToModel(facts, wanted);
+    return offered.includes(clamped) ? clamped : (offered.at(-1) ?? 'inherit');
+}
 /**
  * Every group whose setting the model IT RUNS ON will silently change.
  *

package/dist/shared/stall-probe.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Dead-backend stall probe — the third child guard machine, beside the stream and
+ * command watchdogs.
+ *
+ * The failure it serves: the model server dies mid-child and the child hangs
+ * MUTE. pi's own connection handling runs from a catch, so a request that never
+ * answers never reaches it. Silence alone is not evidence — prompt processing
+ * legitimately emits nothing for minutes — so only "no output for `afterMs` AND
+ * the endpoint does not answer a probe" counts as a dead backend.
+ *
+ * Liveness is OUTPUT PROGRESS: any chunk resets the window. A reachable probe
+ * also resets it, so the next probe is a full window away rather than every
+ * tick, and a probe that itself throws proves nothing and is treated as
+ * reachable. The machine takes its clock and scheduler as deps for the same
+ * reason the two watchdogs do: so it can be driven by a fake in a unit test
+ * instead of only through a real spawn.
+ */
+import type { TimerHandle } from './command-watchdog.js';
+export interface StallProbeDeps {
+    /** Silence that triggers a probe, in ms. */
+    afterMs: number;
+    /** true → the model endpoint answered; false → it did not. */
+    probe: () => Promise<boolean>;
+    now: () => number;
+    schedule: (fn: () => void, ms: number) => TimerHandle;
+    cancel: (handle: TimerHandle) => void;
+    /** Fires ONCE, when the window elapsed and the probe found nobody home. */
+    onDead: () => void;
+}
+/**
+ * Half the window, clamped. Never tighter than 50ms, never looser than 15s: a
+ * probe is one network call, so it must not be re-issued every tick, and a
+ * window of minutes must still be noticed within seconds of elapsing.
+ */
+export declare function stallPollIntervalMs(afterMs: number): number;
+export declare class StallProbe {
+    private readonly deps;
+    private timer;
+    private lastActivity;
+    private probing;
+    private dead;
+    constructor(deps: StallProbeDeps);
+    start(): void;
+    /** Any output from the child: the window starts over. */
+    note(): void;
+    stop(): void;
+    /** @internal Exposed for the poll callback and tests. */
+    check(): Promise<void>;
+}
+/** Real-clock poll deps. REF'd for the reason stream-watchdog.ts records. */
+export declare const realStallTimerDeps: Pick<StallProbeDeps, 'now' | 'schedule' | 'cancel'>;

package/dist/shared/stall-probe.js

@@ -0,0 +1,79 @@
+/**
+ * Dead-backend stall probe — the third child guard machine, beside the stream and
+ * command watchdogs.
+ *
+ * The failure it serves: the model server dies mid-child and the child hangs
+ * MUTE. pi's own connection handling runs from a catch, so a request that never
+ * answers never reaches it. Silence alone is not evidence — prompt processing
+ * legitimately emits nothing for minutes — so only "no output for `afterMs` AND
+ * the endpoint does not answer a probe" counts as a dead backend.
+ *
+ * Liveness is OUTPUT PROGRESS: any chunk resets the window. A reachable probe
+ * also resets it, so the next probe is a full window away rather than every
+ * tick, and a probe that itself throws proves nothing and is treated as
+ * reachable. The machine takes its clock and scheduler as deps for the same
+ * reason the two watchdogs do: so it can be driven by a fake in a unit test
+ * instead of only through a real spawn.
+ */
+/**
+ * Half the window, clamped. Never tighter than 50ms, never looser than 15s: a
+ * probe is one network call, so it must not be re-issued every tick, and a
+ * window of minutes must still be noticed within seconds of elapsing.
+ */
+export function stallPollIntervalMs(afterMs) {
+    return Math.max(50, Math.min(afterMs / 2, 15_000));
+}
+export class StallProbe {
+    deps;
+    timer;
+    lastActivity = 0;
+    probing = false;
+    dead = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    start() {
+        if (this.timer !== undefined)
+            return;
+        this.lastActivity = this.deps.now();
+        this.timer = this.deps.schedule(() => void this.check(), stallPollIntervalMs(this.deps.afterMs));
+    }
+    /** Any output from the child: the window starts over. */
+    note() {
+        this.lastActivity = this.deps.now();
+    }
+    stop() {
+        if (this.timer !== undefined)
+            this.deps.cancel(this.timer);
+        this.timer = undefined;
+    }
+    /** @internal Exposed for the poll callback and tests. */
+    async check() {
+        if (this.probing || this.dead)
+            return;
+        if (this.deps.now() - this.lastActivity < this.deps.afterMs)
+            return;
+        this.probing = true;
+        let reachable;
+        try {
+            reachable = await this.deps.probe();
+        }
+        catch {
+            reachable = true;
+        }
+        this.probing = false;
+        if (reachable) {
+            this.lastActivity = this.deps.now();
+            return;
+        }
+        this.dead = true;
+        this.stop();
+        this.deps.onDead();
+    }
+}
+/** Real-clock poll deps. REF'd for the reason stream-watchdog.ts records. */
+export const realStallTimerDeps = {
+    now: () => Date.now(),
+    schedule: (fn, ms) => setInterval(fn, ms),
+    cancel: handle => clearInterval(handle)
+};