@mjasnikovs/pi-task 0.38.2 → 0.38.4

package/dist/config/config.d.ts

@@ -178,6 +178,13 @@ export declare const STREAM_INACTIVITY_OPTIONS: ReadonlyArray<{
 /** Same pinning as {@link sanitizeRequestTimeoutMs}: a hand-edited value that is
  *  not one of the offered choices falls back to the default. */
 export declare function sanitizeStreamInactivityMs(value: unknown): number;
+/**
+ * The shipped defaults. Exported so tests can start from a KNOWN config instead
+ * of `getConfig()`, which reads whatever this machine happens to have on disk —
+ * a test that passes or fails depending on the developer's own settings is not
+ * testing the code.
+ */
+export declare const DEFAULT_CONFIG: PiTaskConfig;
 /**
  * A hand-edited config can hold anything; keep only string entries so a stray
  * object/number can't reach the child argv as `-e [object Object]`.

package/dist/config/config.js

@@ -79,7 +79,13 @@ export function sanitizeStreamInactivityMs(value) {
         value
         : DEFAULT_STREAM_INACTIVITY_MS;
 }
-const DEFAULTS = {
+/**
+ * The shipped defaults. Exported so tests can start from a KNOWN config instead
+ * of `getConfig()`, which reads whatever this machine happens to have on disk —
+ * a test that passes or fails depending on the developer's own settings is not
+ * testing the code.
+ */
+export const DEFAULT_CONFIG = {
     remote: true,
     compressReasoning: true,
     autoCommit: true,
@@ -113,7 +119,7 @@ export function sanitizeExtensionWhitelist(value) {
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;
 if (!_g.__piTaskConfig) {
-    _g.__piTaskConfig = { config: { ...DEFAULTS }, loaded: false };
+    _g.__piTaskConfig = { config: { ...DEFAULT_CONFIG }, loaded: false };
 }
 const G = _g.__piTaskConfig;
 // Load synchronously on module evaluation so getConfig() is always ready
@@ -136,10 +142,10 @@ if (!G.loaded) {
         if (typeof parsed.yoloMode !== 'boolean')
             delete parsed.yoloMode;
         parsed.debugLogs = sanitizeDebugLogs(parsed.debugLogs);
-        G.config = { ...DEFAULTS, ...parsed };
+        G.config = { ...DEFAULT_CONFIG, ...parsed };
     }
     catch {
-        G.config = { ...DEFAULTS };
+        G.config = { ...DEFAULT_CONFIG };
     }
     G.loaded = true;
 }

package/dist/config/register.d.ts

@@ -38,6 +38,43 @@ declare class BorderedBox implements Component {
     invalidate(): void;
     handleInput(data: string): void;
 }
+/**
+ * One /task-config setting, and BOTH directions of its value.
+ *
+ * `format` renders the stored value for the panel; `apply` parses the chosen
+ * label back into it. They are per-row because the two used to be hand-written
+ * ladders — a `displayValue` arm to format, a matching `onChange` arm to parse,
+ * and three different idioms for the same parse across the four enum settings.
+ * Adding one enum setting meant four coordinated edits (row, format arm, parse
+ * arm, sanitizer) and NONE of them failed to compile if you forgot it: a missed
+ * format arm rendered `String(cfg[id])`, and a missed parse arm let the generic
+ * `else` write the boolean `newValue === 'on'` into an enum field. The comment
+ * that used to sit in that `else` — explaining why `debugLogs` must not fall
+ * into it — was the interface saying it was too shallow.
+ *
+ * With both directions on the row, `format(apply(cfg, v)) === v` is a property
+ * over the whole table, and the panel and the non-TUI listing cannot disagree
+ * because both read `format`.
+ */
+export interface ConfigItem {
+    id: keyof PiTaskConfig;
+    label: string;
+    description: string;
+    /** Offered values. Omitted for a boolean, which is always on/off. */
+    values?: string[];
+    /** What the panel shows for the current value. */
+    format: (cfg: PiTaskConfig) => string;
+    /** Write the chosen label back. A value it does not recognise is ignored. */
+    apply: (cfg: PiTaskConfig, chosen: string) => void;
+}
+/**
+ * Every setting rendered by /task-config, in display order.
+ *
+ * Exported so the round-trip property below can be asserted over the WHOLE table
+ * rather than per setting — the check that would have caught a forgotten arm in
+ * either of the two ladders this replaced.
+ */
+export declare const ITEMS: ConfigItem[];
 export declare function extensionItems(extensions: InstalledExtension[], whitelist: readonly string[]): {
     id: string;
     label: string;

package/dist/config/register.js

@@ -68,70 +68,64 @@ class BorderedBox {
     }
 }
 /**
- * Every setting rendered by /task-config. Boolean settings omit `values` and
- * toggle on/off; enum settings list their values and cycle through them.
+ * The shared pair for a boolean setting: shown as on/off, stored as a boolean.
+ * Every non-enum row uses this, so a boolean cannot be given a bespoke parser by
+ * accident.
  */
-const ITEMS = [
-    {
-        id: 'remote',
-        label: 'remote control',
-        description: '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'
-    },
-    {
-        id: 'compressReasoning',
-        label: 'compress thinking',
-        description: "Shrink the model's thinking blocks once it has moved on, so a long run keeps more "
-            + 'room for the work itself'
-    },
-    {
-        id: 'autoCommit',
-        label: 'auto-commit',
-        description: 'Make a git commit before and after every sub-task, so each step is a checkpoint '
-            + 'you can read back or roll back to'
-    },
-    {
-        id: 'verifyWork',
-        label: 'verify work',
-        description: 'When a task says it is done, actually run the checks its spec asks for and report '
-            + "PASS or FAIL instead of taking the model's word for it. This is also what lets "
-            + '"enforce guidelines" fix things safely. /task waits for the work to finish'
-    },
-    {
-        id: 'enforceGuidelines',
-        label: 'enforce guidelines',
-        description: 'Check what each task committed against your AGENTS.md / CLAUDE.md rules. With '
-            + '"verify work" on it also fixes what it finds, undoing any fix that breaks the '
-            + 'checks; on its own it only reports. /task waits for the work to finish'
-    },
-    {
-        id: 'orientation',
-        label: 'project tour',
-        description: 'Show the research workers the shape of the project first — package manifest, '
-            + 'types, schema — so they spend their steps on the question instead of on finding '
-            + 'their way around'
-    },
-    {
-        id: 'parallelResearchWorkers',
-        label: 'parallel research',
-        description: 'Run the 4 research workers at once instead of one after another. Only faster if '
-            + 'your model backend can answer several requests at the same time — on a single '
-            + 'local GPU it is measurably slower, so leave it off there'
-    },
-    {
-        id: 'researchCache',
-        label: 'research cache',
-        description: 'Remember docs and web pages for the length of one run, so later tasks reuse what '
-            + 'the first one already fetched instead of downloading it again. Only external '
-            + 'sources, only successful fetches, and it is dropped when the run ends'
-    },
+function booleanItem(id, label, description) {
+    return {
+        id,
+        label,
+        description,
+        format: cfg => (cfg[id] ? 'on' : 'off'),
+        apply: (cfg, chosen) => {
+            ;
+            cfg[id] = chosen === 'on';
+        }
+    };
+}
+/**
+ * Every setting rendered by /task-config, in display order.
+ *
+ * Exported so the round-trip property below can be asserted over the WHOLE table
+ * rather than per setting — the check that would have caught a forgotten arm in
+ * either of the two ladders this replaced.
+ */
+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 '
+        + "PASS or FAIL instead of taking the model's word for it. This is also what lets "
+        + '"enforce guidelines" fix things safely. /task waits for the work to finish'),
+    booleanItem('enforceGuidelines', 'enforce guidelines', 'Check what each task committed against your AGENTS.md / CLAUDE.md rules. With '
+        + '"verify work" on it also fixes what it finds, undoing any fix that breaks the '
+        + 'checks; on its own it only reports. /task waits for the work to finish'),
+    booleanItem('orientation', 'project tour', 'Show the research workers the shape of the project first — package manifest, '
+        + 'types, schema — so they spend their steps on the question instead of on finding '
+        + 'their way around'),
+    booleanItem('parallelResearchWorkers', 'parallel research', 'Run the 4 research workers at once instead of one after another. Only faster if '
+        + 'your model backend can answer several requests at the same time — on a single '
+        + 'local GPU it is measurably slower, so leave it off there'),
+    booleanItem('researchCache', 'research cache', 'Remember docs and web pages for the length of one run, so later tasks reuse what '
+        + 'the first one already fetched instead of downloading it again. Only external '
+        + 'sources, only successful fetches, and it is dropped when the run ends'),
     {
         id: 'searchProvider',
         label: 'search engine',
         description: 'Which engine backs web search. Exa and DuckDuckGo work with no setup; Brave needs '
             + 'a BRAVE_SEARCH_API_KEY in your environment',
         // Display full engine names; the stored config value stays the short id.
-        values: SEARCH_PROVIDERS.map(p => SEARCH_PROVIDER_LABELS[p])
+        values: SEARCH_PROVIDERS.map(p => SEARCH_PROVIDER_LABELS[p]),
+        format: cfg => SEARCH_PROVIDER_LABELS[cfg.searchProvider],
+        apply: (cfg, chosen) => {
+            const provider = providerForLabel(chosen);
+            if (provider)
+                cfg.searchProvider = provider;
+        }
     },
     {
         id: 'requestTimeoutMs',
@@ -141,7 +135,14 @@ const ITEMS = [
             + 'hung build. Covers the main session and the checking steps; "off" lets a stuck '
             + 'command hang the run until you notice',
         // Display human labels; the stored config value stays the ms number.
-        values: COMMAND_TIMEOUT_OPTIONS.map(o => o.label)
+        values: COMMAND_TIMEOUT_OPTIONS.map(o => o.label),
+        format: cfg => COMMAND_TIMEOUT_OPTIONS.find(o => o.ms === cfg.requestTimeoutMs)?.label
+            ?? `${cfg.requestTimeoutMs}ms`,
+        apply: (cfg, chosen) => {
+            const opt = COMMAND_TIMEOUT_OPTIONS.find(o => o.label === chosen);
+            if (opt)
+                cfg.requestTimeoutMs = opt.ms;
+        }
     },
     {
         id: 'streamInactivityMs',
@@ -152,16 +153,19 @@ const ITEMS = [
             + 'pauses while a command runs — local models go quiet for minutes on long prompts, '
             + 'so leave room',
         // Display human labels; the stored config value stays the ms number.
-        values: STREAM_INACTIVITY_OPTIONS.map(o => o.label)
-    },
-    {
-        id: 'yoloMode',
-        label: 'yolo mode',
-        description: 'Stop asking you anything: every question takes the option pi recommends, a failed '
-            + 'check is accepted and written down as debt, and a failed final check is retried '
-            + 'until the budget runs out. Each auto-answer is marked (YOLO) in the task file. '
-            + 'For throwaway projects you are not watching'
+        values: STREAM_INACTIVITY_OPTIONS.map(o => o.label),
+        format: cfg => STREAM_INACTIVITY_OPTIONS.find(o => o.ms === cfg.streamInactivityMs)?.label
+            ?? `${cfg.streamInactivityMs}ms`,
+        apply: (cfg, chosen) => {
+            const opt = STREAM_INACTIVITY_OPTIONS.find(o => o.label === chosen);
+            if (opt)
+                cfg.streamInactivityMs = opt.ms;
+        }
     },
+    booleanItem('yoloMode', 'yolo mode', 'Stop asking you anything: every question takes the option pi recommends, a failed '
+        + 'check is accepted and written down as debt, and a failed final check is retried '
+        + 'until the budget runs out. Each auto-answer is marked (YOLO) in the task file. '
+        + 'For throwaway projects you are not watching'),
     {
         id: 'debugLogs',
         label: 'debug logs',
@@ -170,29 +174,15 @@ const ITEMS = [
             + 'failed — a few lines per task. "full" adds everything the model said and every '
             + 'command it ran, which is most of the size and only useful while you are digging '
             + 'into a problem. "off" writes nothing, and nothing can be reconstructed later',
-        values: [...DEBUG_LOG_OPTIONS]
+        values: [...DEBUG_LOG_OPTIONS],
+        // The stored value IS the label here, but it still goes through the
+        // sanitizer rather than being written raw.
+        format: cfg => String(cfg.debugLogs),
+        apply: (cfg, chosen) => {
+            cfg.debugLogs = sanitizeDebugLogs(chosen);
+        }
     }
 ];
-/** Human label for the stored command-timeout ms (falls back to the raw ms). */
-function timeoutLabel(ms) {
-    return COMMAND_TIMEOUT_OPTIONS.find(o => o.ms === ms)?.label ?? `${ms}ms`;
-}
-/** Human label for the stored stream-inactivity ms (falls back to the raw ms). */
-function streamTimeoutLabel(ms) {
-    return STREAM_INACTIVITY_OPTIONS.find(o => o.ms === ms)?.label ?? `${ms}ms`;
-}
-/** What /task-config shows for a setting's current value. */
-function displayValue(cfg, id, isEnum) {
-    if (id === 'searchProvider')
-        return SEARCH_PROVIDER_LABELS[cfg.searchProvider];
-    if (id === 'requestTimeoutMs')
-        return timeoutLabel(cfg.requestTimeoutMs);
-    if (id === 'streamInactivityMs')
-        return streamTimeoutLabel(cfg.streamInactivityMs);
-    if (isEnum)
-        return String(cfg[id]);
-    return cfg[id] ? 'on' : 'off';
-}
 /**
  * One /task-config toggle per installed host extension (GitHub issue #4).
  * The id carries the entry path behind a prefix so the shared onChange handler
@@ -291,11 +281,11 @@ export function createSettingsPanel(items, theme, onChange, onCancel) {
 /** The full settings row list for the current config, in menu order. */
 export function panelItems(cfg, installed, tools = []) {
     return [
-        ...ITEMS.map(({ id, label, description, values }) => ({
+        ...ITEMS.map(({ id, label, description, values, format }) => ({
             id: id,
             label,
             description,
-            currentValue: displayValue(cfg, id, Boolean(values)),
+            currentValue: format(cfg),
             values: values ?? ['on', 'off']
         })),
         ...toolItems(tools, cfg.commandTimeoutExemptTools),
@@ -317,7 +307,9 @@ async function handleTaskConfig(_args, ctx, getTools = () => []) {
     // it can only be read here, when the menu opens, never at registration.
     const tools = getTools();
     if (ctx.mode !== 'tui') {
-        const lines = ITEMS.map(({ id, label, values }) => `${label.padEnd(22)} ${displayValue(cfg, id, Boolean(values))}`);
+        // Reads the SAME `format` the panel does, so the two renderings cannot
+        // disagree about what a setting currently says.
+        const lines = ITEMS.map(({ label, format }) => `${label.padEnd(22)} ${format(cfg)}`);
         for (const t of tools) {
             const state = cfg.commandTimeoutExemptTools.includes(t.name) ? 'off' : 'on';
             lines.push(`${('watch: ' + t.name).padEnd(22)} ${state}`);
@@ -336,30 +328,13 @@ async function handleTaskConfig(_args, ctx, getTools = () => []) {
         else if (id.startsWith(TOOL_ID_PREFIX)) {
             cfg.commandTimeoutExemptTools = applyToolToggle(cfg.commandTimeoutExemptTools, id.slice(TOOL_ID_PREFIX.length), newValue === 'on');
         }
-        else if (id === 'searchProvider') {
-            const provider = providerForLabel(newValue);
-            if (provider)
-                cfg.searchProvider = provider;
-        }
-        else if (id === 'requestTimeoutMs') {
-            const opt = COMMAND_TIMEOUT_OPTIONS.find(o => o.label === newValue);
-            if (opt)
-                cfg.requestTimeoutMs = opt.ms;
-        }
-        else if (id === 'streamInactivityMs') {
-            const opt = STREAM_INACTIVITY_OPTIONS.find(o => o.label === newValue);
-            if (opt)
-                cfg.streamInactivityMs = opt.ms;
-        }
-        else if (id === 'debugLogs') {
-            // The stored value IS the label here, but it must still go
-            // through the sanitizer — the generic `else` below would
-            // write the boolean `newValue === 'on'` into an enum field.
-            cfg.debugLogs = sanitizeDebugLogs(newValue);
-        }
         else {
-            ;
-            cfg[id] = newValue === 'on';
+            // Every setting parses its own value. There is no generic
+            // fallback: the ladder this replaces ended in one that
+            // wrote `newValue === 'on'` into whatever field it was
+            // handed, so a new enum setting silently became a boolean
+            // until someone noticed.
+            ITEMS.find(item => item.id === id)?.apply(cfg, newValue);
         }
         saveConfig(cfg).catch(() => { });
     }, () => done(undefined)), { overlay: true, overlayOptions: { width: OVERLAY_WIDTH } });

package/dist/remote/events.js

@@ -1,11 +1,9 @@
-import { setAgentIdle } from './state.js';
 import { publishNotify } from './bridge.js';
 import { agentStart, appendText, textEnd, appendThinking, thinkingEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
 /** Mirror pi agent events into the authoritative SessionState. Each handler
  *  drives a mutator, which updates the snapshot AND broadcasts the live delta. */
 export function setupEvents(pi) {
     pi.on('agent_start', (_event, ctx) => {
-        setAgentIdle(false);
         agentStart(ctx.model?.name);
     });
     pi.on('message_update', (event, _ctx) => {
@@ -48,7 +46,6 @@ export function setupEvents(pi) {
         endTool(event.toolCallId, event.toolName, event.result, event.isError);
     });
     pi.on('agent_end', (_event, ctx) => {
-        setAgentIdle(true);
         agentEnd(ctx.getContextUsage(), ctx.model?.name);
         // Deliberately no push: agent_end fires on EVERY host turn — every chat
         // reply, every internal phase turn inside /task, and every internal /task

package/dist/remote/register.js

@@ -1,12 +1,11 @@
 import { getConfig } from '../config/config.js';
 import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx, interruptAgent, registerBridgeCommand, registerRemoteOnlyCommand, publishNotify } from './bridge.js';
 import { setupEvents } from './events.js';
-import { reset, addUserTurn, setHeld } from './session-state.js';
+import { reset, addUserTurn, setHeld, getState } from './session-state.js';
 import { html } from './ui.js';
 import { qrLines } from './qr.js';
 import { startServer, formatAddresses } from './server.js';
 import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls, hostFromResult } from './tailscale.js';
-import { isAgentIdle } from './state.js';
 import { holdInput, isRunActive, clearHeldInput, heldInput, setHeldInputListener } from '../task/mid-run-input.js';
 const _g = globalThis;
 if (!_g.__piRemote)
@@ -19,7 +18,17 @@ const S = _g.__piRemote;
  */
 export function routePlainLine(plain, send) {
     addUserTurn(plain);
-    if (!isAgentIdle()) {
+    // Read the run flag from SessionState, which is the only thing that owns it.
+    // There used to be a mirror of it here (remote/state.ts: a module-level `let`
+    // plus a getter/setter, set alongside agentStart/agentEnd in events.ts). Two
+    // sources of truth for one boolean, and they disagreed twice over: SessionState
+    // also clears agentRunning in addError and reset, neither of which touched the
+    // mirror — so an errored turn or a /new left this branch steering into a turn
+    // SessionState already considered finished. And the mirror was a plain module
+    // `let` while every other piece of remote state deliberately lives on
+    // globalThis to survive jiti re-evaluation, so it silently reset on session
+    // switch. Deleting it removed complexity rather than moving it.
+    if (getState().agentRunning) {
         // A live turn: steer it (inject into the current generation) so the
         // nudge lands immediately.
         send(plain, { deliverAs: 'steer' });