billion-context-pi 0.1.57-pr.284.92 → 0.1.57

package/README.md

@@ -133,7 +133,7 @@ Worker runs on Pi's full default toolset - no `--tools` allowlist is applied, so
 
 The full delegate result is saved to a file (`/tmp/acp-delegate/<runId>.out`); the tool result and injected notification carry only the **task title + file path** (no preview) - use `read` for the details. This keeps the parent context lean.
 
-- **Interactive (TUI) & RPC modes**: `async:true` (default) runs the child in the background; a short completion notification is injected into the chat when it finishes.
+- **Interactive (TUI) & RPC modes**: `async:true` (default) runs the child in the background; a short completion notification is injected into the chat when it finishes — **unless the model already read the result file after the run finished** (detected via the `read` tool or a bash command referencing the file), in which case the notification is skipped: the model already has the result, so re-injecting it would only waste context. Set `delegate: { notifyIfRead: "always" }` in `acp.json` to restore the always-inject behavior.
 - **Print / JSON modes** (`pi -p`, SDK): `async:true` auto-downgrades to **synchronous** — the result returns as the tool result in the same turn (the parent exits after one turn, so background injection would be lost).
 - **Failures are loud, never silent.** A run that fails (nonzero exit, spawn error, watchdog timeout) injects a `FAILED ⚠️` notification carrying a short error excerpt, so a failed delegate cannot hide among sibling completions. If a notification cannot be delivered at all, a recovery notice is attached to the next delegate notification or the next `acp_delegate` / `acp_delegate_wait` / `acp_delegate_cancel` tool result — a dispatched run's failure always reaches the model before it wraps up.
 

package/dist/config.d.ts

@@ -1,5 +1,21 @@
 import { type Config, type Prompts } from "acp-kernel";
 import type { ThrottleRetryConfig } from "./throttle-retry.js";
+/** Per-role delegate defaults. Lets long-lived automation pin a cheaper or
+ *  more capable model and a thinking level per delegate role, so the main
+ *  agent doesn't have to fill them in on every `acp_delegate()` call. */
+export interface DelegateRoleConfig {
+    /** Default model for this role, as `"provider/id"`. Resolution priority:
+     *  per-call `model` > this role default > parent agent's current model. A
+     *  value that isn't a valid `"provider/id"` is ignored (treated as unset).
+     *  If the configured model doesn't exist in the live registry, the child
+     *  falls back to the parent model and a warning is logged — it never fails. */
+    model?: string;
+    /** Default thinking level for this role: one of off|minimal|low|medium|
+     *  high|xhigh|max. Resolution priority: per-call `thinkingLevel` > this role
+     *  default > global `delegate.thinkingLevel` > Pi's own default. An invalid
+     *  value is ignored with a warning (never fails). */
+    thinkingLevel?: string;
+}
 /** Delegate sub-agent configuration. */
 export interface DelegateConfig {
     /** Enable acp_delegate tools (delegate/wait/cancel) and their system-prompt
@@ -37,6 +53,21 @@ export interface DelegateConfig {
      *  back to unlimited with a warning. Env `PI_ACP_DELEGATE_MAX_CONCURRENT`
      *  overrides this. See #294. */
     maxConcurrent?: number;
+    /** Global default thinking level applied to every delegate when neither the
+     *  per-call `thinkingLevel` nor the role's own `thinkingLevel` is set. One of
+     *  off|minimal|low|medium|high|xhigh|max. When unset at all levels, no
+     *  `--thinking` flag is passed and each child uses Pi's own default. */
+    thinkingLevel?: string;
+    /** Per-role defaults keyed by role name (reviewer/researcher/worker/planner/
+     *  oracle, or any custom role). See DelegateRoleConfig. Only affects roles
+     *  that are named here; other roles inherit the parent model + Pi defaults. */
+    agents?: Record<string, DelegateRoleConfig>;
+    /** What happens to the completion notification when the model has already
+     *  read the delegate's result file after the run finished.
+     *  "skip" (default) — the notification is not injected; the model already
+     *  saw the result, so re-injecting it would only waste context.
+     *  "always" — always inject the notification (previous behavior). */
+    notifyIfRead?: "skip" | "always";
 }
 /** Resolved delegate policy: what actually takes effect after merging acp.json,
  *  env overrides and defaults. Timeout fields are milliseconds; null means the
@@ -50,6 +81,13 @@ export interface DelegatePolicy {
     asyncTimeoutMs: number | null;
     /** Resolved cap on concurrent background delegates; Infinity = unlimited. */
     maxConcurrent: number;
+    /** Global default thinking level (undefined when unset). */
+    thinkingLevel?: string;
+    /** Per-role defaults keyed by role name (undefined when unset). */
+    agents?: Record<string, DelegateRoleConfig>;
+    /** Whether to suppress the completion notification when the model already
+     *  read the result file after the run finished. Always resolved ("skip" default). */
+    notifyIfRead: "skip" | "always";
 }
 export declare const DEFAULT_DELEGATE_POLICY: DelegatePolicy;
 /** Compression tuning fields, shared by all three levels (global, provider,

package/dist/delegate-tool.d.ts

@@ -1,8 +1,9 @@
 import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import { Type, type Static } from "typebox";
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { type DelegatePolicy } from "./config.js";
+import { type DelegatePolicy, type DelegateRoleConfig } from "./config.js";
 import { type Usage } from "./delegate-events.js";
+export declare const OUT_DIR: string;
 export declare function delegateStdinText(resumeFrom: boolean, task: string | undefined): string;
 export declare function delegateSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): SpawnOptions;
 /** Child process env for a nested delegate: depth increments by one, and the
@@ -54,6 +55,15 @@ interface DelegateRun {
     /** True while the run sits in the coalescing notification queue (scheduled
      *  for the next batched flush, not yet delivered). */
     notifyQueued?: boolean;
+    /** When the model successfully read this run's result file (read tool, or a
+     *  bash command referencing it). A read at/after finishedAt means the model
+     *  already saw the final result — the completion notification is then
+     *  suppressed (notifyIfRead: "skip"). */
+    readAt?: number;
+    /** True when the completion notification was suppressed because the model
+     *  had already read the result file. Treated as delivered (injected=true)
+     *  so wait/recovery never re-surface the result. */
+    readSuppressed?: boolean;
 }
 export declare function addDelegateUsage(u: Usage): void;
 export declare function getDelegateUsage(): Usage | undefined;
@@ -77,6 +87,23 @@ export declare class ConcurrencyGate {
      *  launches FIFO (skipping any cancelled while queued). */
     release(): void;
 }
+export declare function setDelegateDefaults(d: {
+    thinkingLevel?: string;
+    agents?: Record<string, DelegateRoleConfig>;
+} | undefined): void;
+export declare function resetDelegateDefaults(): void;
+declare const VALID_THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export declare function isValidThinkingLevel(v: unknown): v is (typeof VALID_THINKING_LEVELS)[number];
+export declare function setDelegateNotifyIfRead(mode: "skip" | "always"): void;
+/** Mark the run whose result file the model just read (via the `read` tool).
+ *  Returns true when a run matched. A read of the final result file after the
+ *  run finished means the model already saw the result — the completion
+ *  notification is then suppressed (notifyIfRead: "skip"). */
+export declare function markDelegateResultRead(filePath: string): boolean;
+/** Mark runs referenced by a bash command (e.g. `cat <result file>`).
+ *  Matches runIds appearing anywhere in the command string; only existing
+ *  runs are affected, so task text that merely contains "del_..." is inert. */
+export declare function markDelegateRunReadByCommand(command: string): boolean;
 /** Snapshot of currently-running delegate runs, for the TUI status widget. */
 export declare function runningRunsSnapshot(): {
     runId: string;
@@ -84,6 +111,31 @@ export declare function runningRunsSnapshot(): {
     task: string;
     startedAt: number;
 }[];
+export interface FleetRunView {
+    runId: string;
+    agent: string;
+    task: string;
+    cwd: string;
+    startedAt: number;
+    finishedAt?: number;
+    status: RunStatus;
+    exitLabel: string;
+    timedOut?: string;
+    resumedFrom?: string;
+    /** Streamed reply text (always retained, even for cancelled runs). */
+    replyFile: string;
+    /** Live tool-activity log (async json-stream runs only). */
+    activityFile?: string;
+    sessionFile?: string;
+    usage?: Usage;
+}
+/** Running first (oldest spawn on top), then recently finished (newest first,
+ *  capped) — the order the fleet inspector list shows. */
+export declare function orderRunsForFleet(all: DelegateRun[]): DelegateRun[];
+/** Display-safe snapshot of every delegate run known this session, for the
+ *  fleet inspector (/acp-fleet). In-memory only: runs from previous pi
+ *  processes are not listed (their files remain under OUT_DIR). */
+export declare function fleetRunsSnapshot(): FleetRunView[];
 /** Minimal writable surface accepted by makeEventApplier — real WriteStreams
  *  in production, in-memory collectors in tests. */
 export interface EventApplierWriters {
@@ -125,6 +177,7 @@ declare const DelegateParams: Type.TObject<{
     resumeFrom: Type.TOptional<Type.TString>;
     cwd: Type.TOptional<Type.TString>;
     model: Type.TOptional<Type.TString>;
+    thinkingLevel: Type.TOptional<Type.TString>;
     async: Type.TOptional<Type.TBoolean>;
     showThinking: Type.TOptional<Type.TBoolean>;
 }>;
@@ -187,6 +240,7 @@ export declare function formatBatchRunSection(run: DelegateRun): string;
  *  in which case the caller delivers the full payload via formatRunResult(). */
 export declare function injectedWaitMessage(run: {
     injected?: boolean;
+    readSuppressed?: boolean;
     result?: {
         file: string;
     };
@@ -227,6 +281,22 @@ export declare function asyncWatchdogDescription(): string;
  *  never exited). If a result was delivered (non-empty reply or stderr), the
  *  run counts as completed (0); otherwise it stays null = genuine failure. */
 export declare function effectiveExitCode(code: number | null, output: string, stderr: string): number | null;
+/** Pure read-after-finish predicate: should the completion notification be
+ *  suppressed because the model already read the final result file? Only a
+ *  read at/after finishedAt counts — a read while the run was still in flight
+ *  (readAt < finishedAt) saw partial output, so the notification still goes
+ *  out. Callers additionally gate on run.status === "completed": a FAILED
+ *  run's file holds only partial output with no failure marker, so the model
+ *  cannot tell it failed from the file — failure notifications are never
+ *  suppressed (failures are loud). */
+export declare function shouldSuppressRead(run: {
+    readAt?: number;
+    finishedAt?: number;
+}, mode: "skip" | "always"): boolean;
+/** Suppress the completion notification for a run the model already read:
+ *  mark it delivered (so wait/recovery/flush never re-surface the result),
+ *  account its usage in separate mode, and log the skip. Idempotent. */
+export declare function applyReadSuppression(run: DelegateRun, runId: string): void;
 /** status (set by finalize from the effective exit code) is the authority for
  *  the FAILED/completed decision; the raw code is diagnostic display only
  *  ("exit ?"), so the notification can never disagree with run.status. */

package/dist/fleet-inspector.d.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type FleetRunView } from "./delegate-tool.js";
+export interface InspectorTheme {
+    fg(color: string, text: string): string;
+    bold(text: string): string;
+    bg(color: string, text: string): string;
+    italic?(text: string): string;
+    underline?(text: string): string;
+    strikethrough?(text: string): string;
+}
+export declare function formatDuration(ms: number): string;
+export declare function statusIcon(status: FleetRunView["status"]): string;
+export declare function usageSummary(usage: FleetRunView["usage"]): string | undefined;
+export interface ListRow {
+    run: FleetRunView;
+    label: string;
+    detail: string;
+}
+export declare function buildListRows(runs: FleetRunView[], now: number): ListRow[];
+/** Last maxBytes of a file as utf8; a partial leading line is dropped so the
+ *  tail always starts on a line boundary. Missing/unreadable → "". */
+export declare function readTailSync(file: string | undefined, maxBytes: number): string;
+/** First maxBytes of a file as utf8. Missing/unreadable → "". */
+export declare function readHeadSync(file: string | undefined, maxBytes: number): string;
+export interface TranscriptBlock {
+    kind: "user" | "thinking" | "text" | "toolCall" | "toolResult" | "meta";
+    name?: string;
+    text: string;
+    isError?: boolean;
+    args?: unknown;
+}
+/** Pi-style one-line summary of a tool call (mirrors pi's formatToolCall). */
+export declare function formatToolLabel(name: string, args: unknown): string;
+/** Parse a pi session .jsonl into display blocks (conversation + thinking + tools). */
+export declare function parseSessionJsonl(raw: string): TranscriptBlock[];
+export declare function renderListBody(rows: ListRow[], selIdx: number, theme: InspectorTheme, innerW: number): string[];
+export declare function renderTranscriptBlocks(blocks: TranscriptBlock[], theme: InspectorTheme, innerW: number): string[];
+/** Plain-text snapshot for non-TUI hosts (rpc/print/json). */
+export declare function buildSnapshotText(runs: FleetRunView[], now: number): string;
+/** Open the live fleet inspector: bordered TUI overlay in interactive mode,
+ *  plain-text snapshot notification elsewhere. Resolves when the user closes it. */
+export declare function openFleetInspector(ctx: ExtensionContext): Promise<void>;