@mjasnikovs/pi-task 0.18.24 → 0.18.26

package/dist/config/config.d.ts

@@ -42,7 +42,36 @@ export interface PiTaskConfig {
      * /task-config, which enumerates the currently installed extensions.
      */
     extensionWhitelist: string[];
+    /**
+     * Wall-clock ceiling (ms) on a SINGLE tool execution in the MAIN session
+     * before the command watchdog cancels it and reminds the model to set its
+     * own timeout. Local models routinely run a command that never returns
+     * (e.g. `godot --headless` with no timeout, a dev server, a hung test) and
+     * the run wedges until the user manually aborts. pi's bash tool has an
+     * OPTIONAL timeout with NO default (bash.js), so a command the model didn't
+     * bound runs forever; this is the missing default, enforced from the host
+     * side via ctx.abort() (which kills the tool's whole process tree) plus an
+     * auto-reminder turn. Tool-agnostic: it arms on any tool execution, though
+     * in practice only bash runs long enough to trip it. 0 = off.
+     * DEFAULT 15 min: long enough for a real build/test suite, short enough that
+     * a true hang doesn't cost half an hour of dead time.
+     */
+    requestTimeoutMs: number;
 }
+/**
+ * The command-watchdog timeout choices offered by /task-config, newest-first in
+ * the cycle order the picker shows. The stored config value is the ms number;
+ * the label is display-only (mirrors the searchProvider label/value split).
+ */
+export declare const COMMAND_TIMEOUT_OPTIONS: ReadonlyArray<{
+    label: string;
+    ms: number;
+}>;
+/**
+ * A hand-edited or stale config could carry any number (or a string); pin it to
+ * one of the offered choices so the watchdog never arms on a nonsense value.
+ */
+export declare function sanitizeRequestTimeoutMs(value: unknown): number;
 /**
  * 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

@@ -3,6 +3,28 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { isSearchProvider } from '../workers/search-types.js';
+/**
+ * The command-watchdog timeout choices offered by /task-config, newest-first in
+ * the cycle order the picker shows. The stored config value is the ms number;
+ * the label is display-only (mirrors the searchProvider label/value split).
+ */
+export const COMMAND_TIMEOUT_OPTIONS = [
+    { label: '5 min', ms: 5 * 60_000 },
+    { label: '10 min', ms: 10 * 60_000 },
+    { label: '15 min', ms: 15 * 60_000 },
+    { label: '30 min', ms: 30 * 60_000 },
+    { label: 'off', ms: 0 }
+];
+const DEFAULT_REQUEST_TIMEOUT_MS = 15 * 60_000;
+/**
+ * A hand-edited or stale config could carry any number (or a string); pin it to
+ * one of the offered choices so the watchdog never arms on a nonsense value.
+ */
+export function sanitizeRequestTimeoutMs(value) {
+    return COMMAND_TIMEOUT_OPTIONS.some(o => o.ms === value) ?
+        value
+        : DEFAULT_REQUEST_TIMEOUT_MS;
+}
 const DEFAULTS = {
     remote: true,
     compressReasoning: true,
@@ -15,7 +37,8 @@ const DEFAULTS = {
     // 3/3, 0 collisions; ~14.5s of repeated docs lookups collapse to 0ms on a hit).
     researchCache: true,
     searchProvider: 'exa',
-    extensionWhitelist: []
+    extensionWhitelist: [],
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS
 };
 /**
  * A hand-edited config can hold anything; keep only string entries so a stray
@@ -43,6 +66,7 @@ if (!G.loaded) {
         if (!isSearchProvider(parsed.searchProvider))
             delete parsed.searchProvider;
         parsed.extensionWhitelist = sanitizeExtensionWhitelist(parsed.extensionWhitelist);
+        parsed.requestTimeoutMs = sanitizeRequestTimeoutMs(parsed.requestTimeoutMs);
         G.config = { ...DEFAULTS, ...parsed };
     }
     catch {

package/dist/config/register.js

@@ -1,7 +1,7 @@
 import { SettingsList, visibleWidth } from '@earendil-works/pi-tui';
 import { registerBridgeCommand } from '../remote/bridge.js';
 import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
-import { getConfig, saveConfig } from './config.js';
+import { COMMAND_TIMEOUT_OPTIONS, getConfig, saveConfig } from './config.js';
 import { listInstalledExtensions } from './extension-list.js';
 const CONFIG_TITLE = 'pi-task settings';
 /**
@@ -95,12 +95,28 @@ const ITEMS = [
         description: 'Engine behind web search (pi-worker-search + freshness checks). Exa and DuckDuckGo need no API key; Brave needs BRAVE_SEARCH_API_KEY',
         // Display full engine names; the stored config value stays the short id.
         values: SEARCH_PROVIDERS.map(p => SEARCH_PROVIDER_LABELS[p])
+    },
+    {
+        id: 'requestTimeoutMs',
+        label: 'command timeout',
+        description: 'Cancel a single command that runs longer than this and remind the model to set '
+            + 'its own timeout. Catches a local model that runs a command which never returns '
+            + '(hung build, dev server, no-timeout check) so the run stops itself instead of '
+            + 'waiting for a manual abort. off disables it',
+        // Display human labels; the stored config value stays the ms number.
+        values: COMMAND_TIMEOUT_OPTIONS.map(o => o.label)
     }
 ];
+/** 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`;
+}
 /** 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 (isEnum)
         return String(cfg[id]);
     return cfg[id] ? 'on' : 'off';
@@ -173,6 +189,11 @@ async function handleTaskConfig(_args, ctx) {
                 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 {
                 ;
                 cfg[id] = newValue === 'on';
@@ -185,7 +206,7 @@ async function handleTaskConfig(_args, ctx) {
 export function registerConfig(pi) {
     registerBridgeCommand(pi, 'task-config', {
         description: 'Configure pi-task settings (remote, compress reasoning, auto-commit, orientation, '
-            + 'enforce guidelines, extension whitelist for child sessions).',
+            + 'enforce guidelines, command timeout, extension whitelist for child sessions).',
         handler: handleTaskConfig
     });
 }

package/dist/index.js

@@ -4,6 +4,7 @@ import { registerTaskAuto } from './task/auto-orchestrator.js';
 import { registerWorkers } from './workers/index.js';
 import { registerRemote } from './remote/register.js';
 import { registerThinkingCompression } from './thinking/compress.js';
+import { registerCommandWatchdog } from './task/command-watchdog.js';
 export default function (pi) {
     registerConfig(pi);
     registerTask(pi);
@@ -11,4 +12,5 @@ export default function (pi) {
     registerWorkers(pi);
     registerRemote(pi);
     registerThinkingCompression(pi);
+    registerCommandWatchdog(pi);
 }

package/dist/task/artifact-closure.d.ts

@@ -0,0 +1,107 @@
+export interface RuntimeRef {
+    /** Repo-relative normalized path (posix separators, no leading ./). */
+    path: string;
+    /** Where the reference lives: repo-relative file, `package.json scripts.X`, or 'spec'. */
+    referencer: string;
+    /** The construct that matched (Bun.file, readFile, script src, …). */
+    construct: string;
+    /** file = must exist as a file; dir = a static root that must exist as a directory. */
+    kind: 'file' | 'dir';
+}
+export interface DanglingRef extends RuntimeRef {
+    /** Why the producer resolution came up empty (human- and prompt-readable). */
+    reason: string;
+}
+/** Everything the tree/scripts/build POSITIVELY produce. */
+export interface ProducedOutputs {
+    /** Exact output files (tailwind -o, --outfile, redirects, Bun.write, cp dest…). */
+    files: Set<string>;
+    /** Enumerable outdir → output STEMS (basename sans extension) it emits —
+     *  from parsed Bun.build entrypoints, explicit output files, source args. */
+    enumerable: Map<string, Set<string>>;
+    /** Dirs produced by machinery we could not enumerate (vite/tsc/next/unknown
+     *  commands naming them) — everything under them steps aside. */
+    opaque: Set<string>;
+    /** Dirs known to be created (mkdir, outdirs) — satisfies dir-kind refs. */
+    dirs: Set<string>;
+}
+export declare function emptyProducers(): ProducedOutputs;
+/** Normalize a literal path: posix separators, strip ./ prefixes, query/hash
+ *  tails (HTML), trailing slash. Returns null when the literal is not a
+ *  checkable relative path (URL, absolute, template hole, glob — step aside). */
+export declare function normalizeRefPath(raw: string): string | null;
+/** Extract runtime refs from one JS/TS source. */
+export declare function extractJsRefs(source: string, referencer: string): RuntimeRef[];
+/** Extract local-asset refs from one HTML source. */
+export declare function extractHtmlRefs(source: string, referencer: string): RuntimeRef[];
+/** Script entrypoints: `bun x.ts`, `bun run x.ts`, `node x.js`, `tsx x.ts` —
+ *  the first path-shaped source arg of a runner command. */
+export declare function extractScriptEntrypoints(body: string, referencer: string): RuntimeRef[];
+/**
+ * Producer facts from ONE shell command: output flags (`-o x`, `--outfile x`,
+ * `--outdir d`), redirects, `cp`/`mv`/`touch` destinations, `mkdir` dirs, known
+ * opaque bundlers. Leftover path tokens of an UNRECOGNIZED command escalate any
+ * directory they point into to opaque — that command may produce there, and
+ * inconclusive is never evidence. `escalate: false` disables that escalation
+ * for command text embedded in PROSE (a markdown bullet's surrounding words
+ * tokenize as junk "commands" and would opaque half the spec's paths).
+ */
+export declare function collectProducersFromCommand(cmd: string, prod: ProducedOutputs, opts?: {
+    escalate?: boolean;
+}): void;
+/**
+ * Producer facts from JS/TS source: write-side calls (`Bun.write`,
+ * `writeFile(Sync)`, `createWriteStream`, `copyFile` dest, `mkdir(Sync)`),
+ * `Bun.build({entrypoints, outdir})` (enumerable — unless a `naming` option
+ * makes the output names underivable, then opaque), `outfile:`, and `Bun.spawn`
+ * argv arrays re-fed through the shell-command collector (the mx5 build.ts
+ * shape: tailwind's `-o dist/app.css` lives in a spawn array).
+ */
+export declare function collectProducersFromSource(source: string, prod: ProducedOutputs): void;
+/**
+ * Discover everything the project's own machinery produces: package.json script
+ * bodies, build files those scripts run (plus conventional root build files),
+ * tsconfig/vite outDirs.
+ */
+export declare function discoverProducers(cwd: string): ProducedOutputs;
+/**
+ * Resolve refs against existence + producers. DANGLING requires POSITIVE
+ * evidence (see the module doc): the ref sits under an ENUMERATED output dir
+ * and is not among its outputs, or is a missing source-only-extension file
+ * (nothing ever builds a `.ts`/`.tsx`). Everything inconclusive steps aside.
+ */
+export declare function resolveDanglingRefs(refs: RuntimeRef[], prod: ProducedOutputs, exists: (rel: string) => boolean): DanglingRef[];
+/**
+ * FINAL-GATE seam: scan the shipped tree for dangling runtime references.
+ * Deterministic, read-only, best-effort (throws nothing in normal operation;
+ * callers still guard). Producers are discovered first (scripts + build files +
+ * configs), then every authored source contributes refs AND runtime write-side
+ * producers (an app that writes its own cache file satisfies its own read).
+ */
+export declare function findDanglingArtifacts(cwd: string): DanglingRef[];
+/** Ranked-failure text for the final gate (names referencer + missing path). */
+export declare function danglingGateFailureText(d: DanglingRef): string;
+/** Does the spec LIST the file as its own artifact — a file-tree entry or a
+ *  bullet whose first token is (or ends with) the basename? Prose that merely
+ *  mentions the name mid-sentence ("serves the built index.html") does NOT
+ *  count: that is the CONSUMING side, exactly what must not self-satisfy. */
+export declare function specListsFile(spec: string, refPath: string): boolean;
+/** Backticked, asset-extension, path-shaped tokens on consuming-verb lines. */
+export declare function extractSpecProseRefs(spec: string): RuntimeRef[];
+/**
+ * PLAN-TIME seam: runtime refs in the spec's snippets AND consuming prose that
+ * neither the existing scaffold (`fileExists`), the spec's parsed build
+ * outputs, nor its own file tree produce. Each result becomes an UNOWNED
+ * coverage area until some task title claims the artifact.
+ */
+export declare function findSpecDanglingArtifacts(spec: string, fileExists: (rel: string) => boolean): DanglingRef[];
+/** Does some task title claim the artifact (by basename or full path)? Titles
+ *  are the one plan artifact the model cannot fake ownership INTO — mentioning
+ *  the file is the grounded signal a producing task exists. */
+export declare function titlesCoverArtifact(titles: string[], ref: {
+    path: string;
+}): boolean;
+/** Coverage-loop `missing` entry for an unowned dangling artifact. */
+export declare function danglingMissingText(d: DanglingRef): string;
+/** Carried-requirement line when still unowned at coverage exhaustion. */
+export declare function danglingCarryText(d: DanglingRef): string;