billion-context-pi 0.1.55-pr.266.59 → 0.1.55

package/README.md

@@ -120,7 +120,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 — **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.
+- **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.
 - **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

@@ -12,12 +12,6 @@ export interface DelegateConfig {
      *  "merged" — delegate token usage folded into the tool-result usage field,
      *  counted as part of the main session totals. */
     displayUsage?: "merged" | "separate";
-    /** 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";
 }
 /** Compression tuning fields, shared by all three levels (global, provider,
  *  model). Percentage fields accept a ratio (0.75) or percent string ("75%").
@@ -127,7 +121,6 @@ export declare const DEFAULT_TOOL_OUTPUT_MAX_BYTES = 200000;
 export declare function resolveDelegate(adapter: AdapterConfig): {
     enabled: boolean;
     displayUsage: "merged" | "separate";
-    notifyIfRead: "skip" | "always";
 };
 /** Per-field deepest-wins merge of the three compression levels (global →
  *  provider → model). An undefined field at a deeper level does NOT clear a

package/dist/delegate-tool.d.ts

@@ -49,30 +49,11 @@ 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;
 export declare function resetDelegateUsage(): void;
 export declare function setDelegateDisplayUsage(mode: "merged" | "separate"): void;
-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;
@@ -183,7 +164,6 @@ 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;
     };
@@ -220,18 +200,6 @@ export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, c
  *  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;
-/** 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. */
-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/index.js

@@ -3610,14 +3610,12 @@ function resolveDelegate(adapter) {
   if (typeof d === "object" && d !== null) {
     return {
       enabled: d.enabled !== false,
-      displayUsage: d.displayUsage ?? adapter.displayUsage ?? "separate",
-      notifyIfRead: d.notifyIfRead ?? "skip"
+      displayUsage: d.displayUsage ?? adapter.displayUsage ?? "separate"
     };
   }
   return {
     enabled: d !== false,
-    displayUsage: adapter.displayUsage ?? "separate",
-    notifyIfRead: "skip"
+    displayUsage: adapter.displayUsage ?? "separate"
   };
 }
 function mergeCompress(global, provider, model) {
@@ -10438,39 +10436,6 @@ var delegateDisplayUsage = "separate";
 function setDelegateDisplayUsage(mode) {
   delegateDisplayUsage = mode;
 }
-var delegateNotifyIfRead = "skip";
-function setDelegateNotifyIfRead(mode) {
-  delegateNotifyIfRead = mode;
-}
-function markDelegateResultRead(filePath) {
-  if (!filePath) return false;
-  const abs = resolvePath(filePath);
-  let matched = false;
-  for (const run of runs.values()) {
-    if (join6(OUT_DIR, `${run.runId}.out`) === abs) {
-      run.readAt = Date.now();
-      suppressIfReadNow(run);
-      matched = true;
-    }
-  }
-  return matched;
-}
-function markDelegateRunReadByCommand(command) {
-  if (!command) return false;
-  const ids = command.match(/del_[a-z0-9]+_[a-z0-9]+/g);
-  if (!ids) return false;
-  let matched = false;
-  const now = Date.now();
-  for (const id of new Set(ids)) {
-    const run = runs.get(id);
-    if (run) {
-      run.readAt = now;
-      suppressIfReadNow(run);
-      matched = true;
-    }
-  }
-  return matched;
-}
 function runningRunsSnapshot() {
   const out = [];
   for (const r of runs.values()) {
@@ -10652,7 +10617,7 @@ Agents (pick by name):
 ${AGENT_NAMES.map(agentListLine).join("\n")}
 
 Behavior:
-\u2022 async=true (default): returns immediately with a runId. The delegate runs in the background. Call acp_delegate_wait({ runId }) to block for its result (up to a timeout); if you let the timeout lapse, or never call wait, a short completion notification (status + file path) is still injected into this chat when it finishes \u2014 unless you already read the result file after it finished, in which case the notification is skipped (you have the result). In one-shot sessions (print/json) async auto-downgrades to sync so the result is returned inline within the same turn. Call acp_delegate again to launch more runs in parallel.
+\u2022 async=true (default): returns immediately with a runId. The delegate runs in the background. Call acp_delegate_wait({ runId }) to block for its result (up to a timeout); if you let the timeout lapse, or never call wait, a short completion notification (status + file path) is still injected into this chat when it finishes. In one-shot sessions (print/json) async auto-downgrades to sync so the result is returned inline within the same turn. Call acp_delegate again to launch more runs in parallel.
 \u2022 async=false: blocks until the delegate finishes. The full output is saved to a file; the tool result contains the path. Use the \`read\` tool to open the file for the complete content.
 
 There is NO non-blocking status tool. To get a delegate's result, call acp_delegate_wait with the runId \u2014 it blocks until the run finishes or the timeout elapses. Use acp_delegate_cancel only to stop a run you no longer want.
@@ -10862,11 +10827,6 @@ ${first.text}`;
   return result;
 }
 function injectedWaitMessage(run, runId, remainingLine) {
-  if (run.readSuppressed) {
-    const file2 = run.result?.file;
-    const fileLine2 = file2 ? ` The result file is: \`${file2}\`.` : "";
-    return `Delegate \`${runId}\` already finished and you read its result file \u2014 no completion notification was injected.${remainingLine}${fileLine2}`;
-  }
   if (!run.injected) return null;
   const file = run.result?.file;
   const fileLine = file ? ` If you need details, read the result file: \`${file}\`.` : "";
@@ -11203,13 +11163,6 @@ ${output}`);
             delegateStatusWidget.poke();
             return;
           }
-          if (shouldSuppressRead(run, delegateNotifyIfRead)) {
-            applyReadSuppression(run, runId);
-            debug.event("delegate-done", { runId, code, status: run.status, injected: false, suppressed: true, outLen: output.length, file: file2 });
-            logInfo("delegate", { event: "done", runId, agent: args.agent, code, status: run.status, injected: false, suppressed: true, outLen: output.length, file: file2 });
-            delegateStatusWidget.poke();
-            return;
-          }
           scheduleRunNotification(pi, run);
           debug.event("delegate-done", { runId, code, status: run.status, injected: false, queued: true, outLen: output.length, file: file2 });
           logInfo("delegate", { event: "done", runId, agent: args.agent, code, status: run.status, injected: false, queued: true, outLen: output.length, file: file2 });
@@ -11255,7 +11208,7 @@ ${output}`);
       useJsonStream ? `Live activity is streaming to \`${activityFile}\` \u2014 read it anytime to watch the delegate work (tool calls and their output${args.showThinking ? ", plus thinking" : ""}).` : `The reply is streaming to \`${replyFile}\` \u2014 read it anytime to see partial output (this host has no json event mode, so tool activity is not visible).`,
       `A watchdog force-finishes a hung run: no output for ${IDLE_GRACE_MS / 6e4}m, 10s after output ends, or a ${ASYNC_TIMEOUT_MS / 6e4}m hard limit \u2014 the result reflects whatever was produced.`,
       ``,
-      `Call acp_delegate_wait({ runId: "${runId}" }) to block for the result (default 10s timeout). If the wait times out, or you skip it, a completion notification (with the result file path) is still injected here automatically when the delegate finishes \u2014 so you may also just continue other work now and let the result find you. (If you already read the result file after it finishes, that notification is skipped \u2014 you have the result.)`
+      `Call acp_delegate_wait({ runId: "${runId}" }) to block for the result (default 10s timeout). If the wait times out, or you skip it, a completion notification (with the result file path) is still injected here automatically when the delegate finishes \u2014 so you may also just continue other work now and let the result find you.`
     ].join("\n");
   }
   const result = await waitForChild(child, signal);
@@ -11340,24 +11293,6 @@ function formatSyncResult(agent, runId, task, r, file) {
 function effectiveExitCode(code, output, stderr) {
   return code ?? (output || stderr ? 0 : null);
 }
-function shouldSuppressRead(run, mode) {
-  if (mode !== "skip") return false;
-  if (run.readAt === void 0 || run.finishedAt === void 0) return false;
-  return run.readAt >= run.finishedAt;
-}
-function applyReadSuppression(run, runId) {
-  run.readSuppressed = true;
-  run.injected = true;
-  if (run.usage && !run.usageReported && delegateDisplayUsage === "separate") {
-    addDelegateUsage(run.usage);
-    run.usageReported = true;
-  }
-  debug.event("delegate-inject-suppressed", { runId, reason: "result-file-read", readAt: run.readAt, finishedAt: run.finishedAt });
-  logInfo("delegate", { event: "inject-suppressed", runId, reason: "result-file-read", readAt: run.readAt, finishedAt: run.finishedAt });
-}
-function suppressIfReadNow(run) {
-  if (shouldSuppressRead(run, delegateNotifyIfRead)) applyReadSuppression(run, run.runId);
-}
 function injectResult(pi, agent, runId, task, status, code, file, timedOut, usage, mode = "separate", usageAlreadyReported, body, activityFile, signal) {
   const send = pi.sendUserMessage;
   if (typeof send !== "function") {
@@ -11420,10 +11355,6 @@ function notifyTerminalFailure(pi, run) {
   const hadWaiter = run.waiter !== void 0;
   run.waiter?.();
   if (hadWaiter || run.consumed) return;
-  if (shouldSuppressRead(run, delegateNotifyIfRead)) {
-    applyReadSuppression(run, run.runId);
-    return;
-  }
   scheduleRunNotification(pi, run);
 }
 function formatPayload(header, file, task, body, activityFile) {
@@ -12516,7 +12447,6 @@ function createAcpExtension(adapter = {}) {
     }
     const runtime = createRuntime(adapter);
     wireCompactionDisable(pi, runtime);
-    wireDelegateReadTracking(pi);
     wireSessionLifecycle(pi, runtime);
     wireContextTransform(pi, runtime);
     wireSystemPrompt(pi, runtime);
@@ -12553,18 +12483,6 @@ function wireCompactionDisable(pi, runtime) {
     return { cancel: true };
   });
 }
-function wireDelegateReadTracking(pi) {
-  pi.on("tool_result", (event) => {
-    if (event.isError) return;
-    if (event.toolName === "read") {
-      const p = event.input.path;
-      if (typeof p === "string") markDelegateResultRead(p);
-    } else if (event.toolName === "bash") {
-      const cmd = event.input.command;
-      if (typeof cmd === "string") markDelegateRunReadByCommand(cmd);
-    }
-  });
-}
 function wireSessionLifecycle(pi, runtime) {
   let ompWarned = false;
   pi.on("session_start", async (_event, ctx) => {
@@ -12590,9 +12508,7 @@ function wireSessionLifecycle(pi, runtime) {
     logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.55" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
     try {
       await runtime.reloadConfig(ctx.cwd);
-      const delegateCfg = resolveDelegate(runtime.adapter);
-      setDelegateDisplayUsage(delegateCfg.displayUsage);
-      setDelegateNotifyIfRead(delegateCfg.notifyIfRead);
+      setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);
     } catch (e) {
       logThrow("config", e, { sid, phase: "session_start" });
     }