billion-context-pi 0.1.56-pr.287.77 → 0.1.56

package/dist/config.d.ts

@@ -12,37 +12,7 @@ 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";
-    /** Maximum acp_delegate nesting depth. Default: 2 (main → child → grandchild;
-     *  the grandchild cannot delegate further). Set 1 to forbid nested delegation
-     *  (orchestrator → leaf workers only). The resolved value is propagated to
-     *  child processes via PI_ACP_DELEGATE_MAX_DEPTH so the cap follows the whole
-     *  delegation tree, even when a child loads a different project acp.json. */
-    maxDepth?: number;
-    /** Hard timeout for synchronous delegates (async=false, or async auto-downgraded
-     *  on one-shot hosts), in minutes. Default: 5. 0 or null disables the timeout
-     *  (the run blocks until the child exits or the tool call is cancelled). */
-    syncTimeoutMinutes?: number | null;
-    /** Idle watchdog for async delegates: kill when no output arrives for this many
-     *  minutes. Default: 5. This is the main defense against a stuck child holding
-     *  its stdout fd open, so disabling it (0/null) logs a warning — use
-     *  acp_delegate_cancel as the manual escape hatch. */
-    idleTimeoutMinutes?: number | null;
-    /** Hard time limit for async delegates, in minutes. Default: 30. 0 or null
-     *  disables the limit. */
-    asyncTimeoutMinutes?: number | null;
 }
-/** Resolved delegate policy: what actually takes effect after merging acp.json,
- *  env overrides and defaults. Timeout fields are milliseconds; null means the
- *  corresponding timeout/watchdog is disabled. */
-export interface DelegatePolicy {
-    enabled: boolean;
-    displayUsage: "merged" | "separate";
-    maxDepth: number;
-    syncTimeoutMs: number | null;
-    idleMs: number | null;
-    asyncTimeoutMs: number | null;
-}
-export declare const DEFAULT_DELEGATE_POLICY: DelegatePolicy;
 /** Compression tuning fields, shared by all three levels (global, provider,
  *  model). Percentage fields accept a ratio (0.75) or percent string ("75%").
  *  Resolution is per-field, deepest-wins (model > provider > global); an
@@ -147,10 +117,11 @@ export interface AdapterConfig {
 export declare const DEFAULT_TOOL_BASH_TIMEOUT = 60;
 export declare const DEFAULT_TOOL_OUTPUT_MAX_BYTES = 200000;
 /** Resolve delegate config from the adapter, handling the boolean shorthand
- *  and the legacy flat `displayUsage` alias. Precedence: env > acp.json >
- *  default (same convention as ACP_MODEL_CONTEXT_LIMIT). Invalid values fall
- *  back to the default with a logged warning — they never fail the session. */
-export declare function resolveDelegate(adapter: AdapterConfig): DelegatePolicy;
+ *  and the legacy flat `displayUsage` alias. */
+export declare function resolveDelegate(adapter: AdapterConfig): {
+    enabled: boolean;
+    displayUsage: "merged" | "separate";
+};
 /** Per-field deepest-wins merge of the three compression levels (global →
  *  provider → model). An undefined field at a deeper level does NOT clear a
  *  value set at a shallower level — only a defined value overrides. */

package/dist/delegate-tool.d.ts

@@ -1,14 +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 Usage } from "./delegate-events.js";
 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
- *  resolved maxDepth rides along so the cap binds the whole delegation tree
- *  even when the child loads a different project acp.json. */
-export declare function delegateChildEnv(parentDepth: number, maxDepth: number): NodeJS.ProcessEnv;
 /** Resolve the pi CLI entry for delegate child processes.
  *  argv[1] is only the pi CLI under a CLI host; embedded hosts (e.g. pi-web)
  *  run the SDK inside another node process, so probe instead. Non-pi hosts
@@ -59,7 +54,6 @@ 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 setDelegatePolicy(policy: DelegatePolicy): void;
 /** Snapshot of currently-running delegate runs, for the TUI status widget. */
 export declare function runningRunsSnapshot(): {
     runId: string;
@@ -202,10 +196,6 @@ export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, c
     useJsonStream: boolean;
     sessionFile: string | null;
 }>;
-/** Model-facing summary of the ACTIVE async watchdog limits — built from the
- *  resolved policy so it stays truthful when timeouts are customized or
- *  disabled via acp.json/env. */
-export declare function asyncWatchdogDescription(): string;
 /** Watchdog/EOF finalize arrives with code === null (the child was killed or
  *  never exited). If a result was delivered (non-empty reply or stderr), the
  *  run counts as completed (0); otherwise it stays null = genuine failure. */

package/dist/delegate-watchdog.d.ts

@@ -1,10 +1,8 @@
 import type { Readable } from "node:stream";
 export interface WatchdogOptions {
     eofGraceMs: number;
-    /** Kill when no output for this long. 0/null disables the idle timer. */
-    idleMs?: number | null;
-    /** Hard time limit. 0/null disables the limit timer. */
-    timeoutMs?: number | null;
+    idleMs: number;
+    timeoutMs: number;
     killGraceMs: number;
 }
 export interface WatchdogHooks {

package/dist/index.js

@@ -3552,144 +3552,21 @@ function makePreview(text, query, len) {
   return prefix + text.slice(start, end).trim() + suffix;
 }
 
-// src/log.ts
-import { appendFileSync, mkdirSync, statSync, renameSync, existsSync } from "fs";
-import * as path from "path";
-import { homedir } from "os";
-import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
-var MAX_BYTES = 10 * 1024 * 1024;
-var ENV_DEBUG = process.env.ACP_DEBUG === "1" || process.env.ACP_DEBUG === "true";
-function resolveLogFile() {
-  return process.env.ACP_LOG_FILE ?? path.join(homedir(), CONFIG_DIR_NAME, "acp.log");
-}
-var runtimeDebug = null;
-function setDebugEnabled(enabled) {
-  runtimeDebug = enabled;
-}
-function debugOn() {
-  return runtimeDebug ?? ENV_DEBUG;
-}
-function fmt(v) {
-  if (typeof v === "string") return v;
-  if (v instanceof Error) return v.stack || String(v);
-  try {
-    return JSON.stringify(v);
-  } catch {
-    return String(v);
-  }
-}
-function ts() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function writeLine(level, scope, fields) {
-  const file = resolveLogFile();
-  try {
-    if (existsSync(file) && statSync(file).size >= MAX_BYTES) {
-      renameSync(file, file + ".old");
-    }
-  } catch {
-  }
-  const body = Object.keys(fields).map((k) => `${k}=${fmt(fields[k])}`).join(" ");
-  const line = `${ts()} [${level}] [${scope}] ${body}
-`;
-  try {
-    mkdirSync(path.dirname(file), { recursive: true });
-    appendFileSync(file, line);
-  } catch {
-  }
-}
-function closeLogStream() {
-}
-function logError(scope, fields) {
-  writeLine("error", scope, fields);
-}
-function logWarn(scope, fields) {
-  writeLine("warn", scope, fields);
-}
-function logInfo(scope, fields) {
-  writeLine("info", scope, fields);
-}
-function logThrow(scope, err, extra = {}) {
-  const fields = { ...extra };
-  if (err instanceof Error) {
-    fields.error = err.message;
-    fields.stack = err.stack ?? "";
-  } else {
-    fields.error = String(err);
-  }
-  writeLine("error", scope, fields);
-}
-var debug = {
-  get enabled() {
-    return debugOn();
-  },
-  get logFile() {
-    return resolveLogFile();
-  },
-  event(scope, fields) {
-    if (debugOn()) writeLine("debug", scope, fields);
-  }
-};
-
 // src/config.ts
-var DEFAULT_DELEGATE_POLICY = {
-  enabled: true,
-  displayUsage: "separate",
-  maxDepth: 2,
-  syncTimeoutMs: 5 * 6e4,
-  idleMs: 5 * 6e4,
-  asyncTimeoutMs: 30 * 6e4
-};
 var DEFAULT_TOOL_BASH_TIMEOUT = 60;
 var DEFAULT_TOOL_OUTPUT_MAX_BYTES = 2e5;
 function resolveDelegate(adapter) {
   const d = adapter.delegate;
-  const cfg = typeof d === "object" && d !== null ? d : {};
-  const enabled = typeof d === "object" && d !== null ? d.enabled !== false : d !== false;
-  const displayUsage = cfg.displayUsage ?? adapter.displayUsage ?? "separate";
-  const maxDepth = resolveMaxDepth(process.env.PI_ACP_DELEGATE_MAX_DEPTH ?? cfg.maxDepth);
-  const syncTimeoutMs = resolveTimeoutMinutes(
-    process.env.PI_ACP_DELEGATE_SYNC_TIMEOUT_MINUTES ?? cfg.syncTimeoutMinutes,
-    "syncTimeoutMinutes",
-    DEFAULT_DELEGATE_POLICY.syncTimeoutMs
-  );
-  const idleMs = resolveTimeoutMinutes(
-    process.env.PI_ACP_DELEGATE_IDLE_TIMEOUT_MINUTES ?? cfg.idleTimeoutMinutes,
-    "idleTimeoutMinutes",
-    DEFAULT_DELEGATE_POLICY.idleMs
-  );
-  const asyncTimeoutMs = resolveTimeoutMinutes(
-    process.env.PI_ACP_DELEGATE_ASYNC_TIMEOUT_MINUTES ?? cfg.asyncTimeoutMinutes,
-    "asyncTimeoutMinutes",
-    DEFAULT_DELEGATE_POLICY.asyncTimeoutMs
-  );
-  if (idleMs === null) {
-    logWarn("config", {
-      event: "delegate-idle-watchdog-disabled",
-      hint: "no-output watchdog is off; hung async runs must be cancelled manually via acp_delegate_cancel"
-    });
-  }
-  return { enabled, displayUsage, maxDepth, syncTimeoutMs, idleMs, asyncTimeoutMs };
-}
-function resolveMaxDepth(value) {
-  if (value === void 0) return DEFAULT_DELEGATE_POLICY.maxDepth;
-  const n = Number(value);
-  if (!Number.isInteger(n) || n < 1) {
-    logWarn("config", { event: "delegate-config-invalid", field: "maxDepth", value, fallback: DEFAULT_DELEGATE_POLICY.maxDepth });
-    return DEFAULT_DELEGATE_POLICY.maxDepth;
-  }
-  return n;
-}
-function resolveTimeoutMinutes(value, field, defaultMs) {
-  if (value === void 0) return defaultMs;
-  if (value === null) return null;
-  const n = Number(value);
-  if (n === 0) return null;
-  if (!Number.isFinite(n) || n < 0) {
-    logWarn("config", { event: "delegate-config-invalid", field, value, fallback: `${defaultMs / 6e4}m` });
-    return defaultMs;
+  if (typeof d === "object" && d !== null) {
+    return {
+      enabled: d.enabled !== false,
+      displayUsage: d.displayUsage ?? adapter.displayUsage ?? "separate"
+    };
   }
-  return n * 6e4;
+  return {
+    enabled: d !== false,
+    displayUsage: adapter.displayUsage ?? "separate"
+  };
 }
 function mergeCompress(global, provider, model) {
   return {
@@ -4055,6 +3932,87 @@ function peelRefTagBlocks(blocks) {
 // src/state.ts
 import { promises as fs } from "fs";
 import * as path2 from "path";
+
+// src/log.ts
+import { appendFileSync, mkdirSync, statSync, renameSync, existsSync } from "fs";
+import * as path from "path";
+import { homedir } from "os";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+var MAX_BYTES = 10 * 1024 * 1024;
+var ENV_DEBUG = process.env.ACP_DEBUG === "1" || process.env.ACP_DEBUG === "true";
+function resolveLogFile() {
+  return process.env.ACP_LOG_FILE ?? path.join(homedir(), CONFIG_DIR_NAME, "acp.log");
+}
+var runtimeDebug = null;
+function setDebugEnabled(enabled) {
+  runtimeDebug = enabled;
+}
+function debugOn() {
+  return runtimeDebug ?? ENV_DEBUG;
+}
+function fmt(v) {
+  if (typeof v === "string") return v;
+  if (v instanceof Error) return v.stack || String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function writeLine(level, scope, fields) {
+  const file = resolveLogFile();
+  try {
+    if (existsSync(file) && statSync(file).size >= MAX_BYTES) {
+      renameSync(file, file + ".old");
+    }
+  } catch {
+  }
+  const body = Object.keys(fields).map((k) => `${k}=${fmt(fields[k])}`).join(" ");
+  const line = `${ts()} [${level}] [${scope}] ${body}
+`;
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    appendFileSync(file, line);
+  } catch {
+  }
+}
+function closeLogStream() {
+}
+function logError(scope, fields) {
+  writeLine("error", scope, fields);
+}
+function logWarn(scope, fields) {
+  writeLine("warn", scope, fields);
+}
+function logInfo(scope, fields) {
+  writeLine("info", scope, fields);
+}
+function logThrow(scope, err, extra = {}) {
+  const fields = { ...extra };
+  if (err instanceof Error) {
+    fields.error = err.message;
+    fields.stack = err.stack ?? "";
+  } else {
+    fields.error = String(err);
+  }
+  writeLine("error", scope, fields);
+}
+var debug = {
+  get enabled() {
+    return debugOn();
+  },
+  get logFile() {
+    return resolveLogFile();
+  },
+  event(scope, fields) {
+    if (debugOn()) writeLine("debug", scope, fields);
+  }
+};
+
+// src/state.ts
 var STATE_SUFFIX = ".acp.json";
 function stateFileFor(sessionFile) {
   if (sessionFile) return sessionFile + STATE_SUFFIX;
@@ -10084,19 +10042,14 @@ function attachWatchdogs(child, hooks, opts) {
     }, graceMs);
     settledGraceTimer.unref?.();
   };
-  const idleMs = opts.idleMs ?? 0;
-  const timeoutMs = opts.timeoutMs ?? 0;
   const poke = () => {
-    if (idleMs <= 0) return;
     if (idleTimer) clearTimeout(idleTimer);
-    idleTimer = setTimeout(() => killByWatchdog(`no output for ${idleMs / 6e4}m`), idleMs);
+    idleTimer = setTimeout(() => killByWatchdog(`no output for ${opts.idleMs / 6e4}m`), opts.idleMs);
     idleTimer.unref?.();
   };
   poke();
-  if (timeoutMs > 0) {
-    timeoutTimer = setTimeout(() => killByWatchdog(`${timeoutMs / 6e4}m limit`), timeoutMs);
-    timeoutTimer.unref?.();
-  }
+  timeoutTimer = setTimeout(() => killByWatchdog(`${opts.timeoutMs / 6e4}m limit`), opts.timeoutMs);
+  timeoutTimer.unref?.();
   const onStdoutEnd = () => {
     if (hooks.isSettled()) return;
     eofTimer = setTimeout(() => {
@@ -10312,8 +10265,12 @@ function newPortion(text, prev) {
 }
 
 // src/delegate-tool.ts
+var MAX_DEPTH = 2;
+var SYNC_TIMEOUT_MS = 5 * 6e4;
 var EOF_GRACE_MS = 1e4;
 var SETTLED_GRACE_MS = 1e4;
+var IDLE_GRACE_MS = 5 * 6e4;
+var ASYNC_TIMEOUT_MS = 30 * 6e4;
 var KILL_GRACE_MS = 1e4;
 var RESULT_SUMMARY_CHARS = 500;
 var OUT_DIR = join6(tmpdir2(), "acp-delegate");
@@ -10338,13 +10295,6 @@ function delegateSpawnOptions(cwd, env) {
     shell: false
   };
 }
-function delegateChildEnv(parentDepth, maxDepth) {
-  return {
-    ...process.env,
-    PI_ACP_DELEGATE_DEPTH: String(parentDepth + 1),
-    PI_ACP_DELEGATE_MAX_DEPTH: String(maxDepth)
-  };
-}
 var PI_CLI_ENTRY_RE = /[\\/]pi-coding-agent[\\/]dist[\\/]cli\.js$/;
 var PI_PACKAGE_REL = join6("@earendil-works", "pi-coding-agent", "dist", "cli.js");
 function probeUpFromArgv(argv1) {
@@ -10436,10 +10386,6 @@ var delegateDisplayUsage = "separate";
 function setDelegateDisplayUsage(mode) {
   delegateDisplayUsage = mode;
 }
-var delegatePolicy = DEFAULT_DELEGATE_POLICY;
-function setDelegatePolicy(policy) {
-  delegatePolicy = policy;
-}
 function runningRunsSnapshot() {
   const out = [];
   for (const r of runs.values()) {
@@ -10982,9 +10928,8 @@ async function runDelegate(pi, args, ctx, signal) {
     return `Unknown agent "${args.agent}". Choose one of: ${AGENT_NAMES.join(", ")}.`;
   }
   const parentDepth = Number(process.env.PI_ACP_DELEGATE_DEPTH ?? "0");
-  const maxDepth = delegatePolicy.maxDepth;
-  if (Number.isNaN(parentDepth) || parentDepth >= maxDepth) {
-    return `Delegate nesting limit reached (depth ${parentDepth}, max ${maxDepth}). The delegate cannot spawn further delegates.`;
+  if (Number.isNaN(parentDepth) || parentDepth >= MAX_DEPTH) {
+    return `Delegate nesting limit reached (depth ${parentDepth}, max ${MAX_DEPTH}). The delegate cannot spawn further delegates.`;
   }
   if (!args.task || !args.task.trim()) {
     if (!args.resumeFrom) {
@@ -11007,7 +10952,10 @@ async function runDelegate(pi, args, ctx, signal) {
   }
   const taskText = args.task?.trim() || (args.resumeFrom ? "(resumed \u2014 the original task is in the session history)" : "");
   const cwd = args.cwd && args.cwd.trim() ? args.cwd : ctx.cwd;
-  const childEnv = delegateChildEnv(parentDepth, maxDepth);
+  const childEnv = {
+    ...process.env,
+    PI_ACP_DELEGATE_DEPTH: String(parentDepth + 1)
+  };
   const runId = `del_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
   const { cliArgs, tmpDir, isAsync, useJsonStream, sessionFile } = await buildChildArgs(args, agent.prompt, ctx, runId);
   const requestedAsync = args.async !== false;
@@ -11048,7 +10996,7 @@ async function runDelegate(pi, args, ctx, signal) {
           debug.event("delegate-eof-grace", { runId, ms: EOF_GRACE_MS });
         }
       },
-      { eofGraceMs: EOF_GRACE_MS, idleMs: delegatePolicy.idleMs, timeoutMs: delegatePolicy.asyncTimeoutMs, killGraceMs: KILL_GRACE_MS }
+      { eofGraceMs: EOF_GRACE_MS, idleMs: IDLE_GRACE_MS, timeoutMs: ASYNC_TIMEOUT_MS, killGraceMs: KILL_GRACE_MS }
     );
     const replyFile = join6(OUT_DIR, `${runId}.out`);
     const activityFile = join6(OUT_DIR, `${runId}.activity`);
@@ -11208,12 +11156,12 @@ ${output}`);
       `Task: ${truncate2(taskText, 160)}`,
       `Running in the background at \`${cwd}\`.`,
       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).`,
-      asyncWatchdogDescription(),
+      `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.`
     ].join("\n");
   }
-  const result = await waitForChild(child, signal, delegatePolicy.syncTimeoutMs);
+  const result = await waitForChild(child, signal);
   void cleanupTmp(tmpDir);
   const body = result.timedOut || result.code !== 0 ? result.stderr.trim() || "(no stderr)" : result.stdout || "(no output)";
   const file = await persistResult(runId, body);
@@ -11247,7 +11195,7 @@ Complete the task below.`, "utf8");
   }
   return { cliArgs, tmpDir, isAsync, useJsonStream, sessionFile };
 }
-function waitForChild(child, signal, timeoutMs) {
+function waitForChild(child, signal) {
   return new Promise((resolve3) => {
     const stdoutChunks = [];
     let stderrText = "";
@@ -11255,20 +11203,17 @@ function waitForChild(child, signal, timeoutMs) {
     child.stderr?.on("data", (c) => {
       stderrText += c.toString("utf8");
     });
-    let timer2;
-    if (timeoutMs !== null) {
-      timer2 = setTimeout(() => {
-        child.kill("SIGTERM");
-        finish2({ code: null, stdout: "", stderr: stderrText, timedOut: true });
-      }, timeoutMs);
-    }
+    const timer2 = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish2({ code: null, stdout: "", stderr: stderrText, timedOut: true });
+    }, SYNC_TIMEOUT_MS);
     const onAbort = () => {
-      if (timer2) clearTimeout(timer2);
+      clearTimeout(timer2);
       child.kill("SIGTERM");
     };
     signal?.addEventListener("abort", onAbort, { once: true });
     function finish2(r) {
-      if (timer2) clearTimeout(timer2);
+      clearTimeout(timer2);
       signal?.removeEventListener("abort", onAbort);
       resolve3(r);
     }
@@ -11286,18 +11231,6 @@ function waitForChild(child, signal, timeoutMs) {
     });
   });
 }
-function fmtMinutes(ms) {
-  const m = ms / 6e4;
-  return Number.isInteger(m) ? `${m}m` : `${m.toFixed(1)}m`;
-}
-function asyncWatchdogDescription() {
-  const parts = [];
-  if (delegatePolicy.idleMs !== null) parts.push(`no output for ${fmtMinutes(delegatePolicy.idleMs)}`);
-  parts.push(`${EOF_GRACE_MS / 1e3}s after output ends`);
-  if (delegatePolicy.asyncTimeoutMs !== null) parts.push(`a ${fmtMinutes(delegatePolicy.asyncTimeoutMs)} hard limit`);
-  const joined = parts.length > 1 ? `${parts.slice(0, -1).join(", ")}, or ${parts[parts.length - 1]}` : parts[0];
-  return `A watchdog force-finishes a hung run: ${joined} \u2014 the result reflects whatever was produced.`;
-}
 function formatSyncResult(agent, runId, task, r, file) {
   const status = r.timedOut ? "timed out" : r.code === 0 ? "completed" : "FAILED \u26A0\uFE0F";
   const header = `Delegate **${agent}** ${status} (runId \`${runId}\`, ${exitLabel(r.code, r.signal)}).`;
@@ -12520,15 +12453,12 @@ function wireSessionLifecycle(pi, runtime) {
     runtime.clearCompressRetryTracking();
     resetDelegateUsage();
     setDelegateDisplayUsage("separate");
-    setDelegatePolicy(DEFAULT_DELEGATE_POLICY);
     const sid = ctx.sessionManager.getSessionId();
     const modelInfo = ctx.model;
     logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.56" : 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);
-      setDelegatePolicy(delegateCfg);
+      setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);
     } catch (e) {
       logThrow("config", e, { sid, phase: "session_start" });
     }
@@ -12697,7 +12627,7 @@ ${rendered.text}${example}`);
 function wireSystemPrompt(pi, runtime) {
   pi.on("before_agent_start", (event) => {
     if (runtime.refused) return;
-    const delegate = resolveDelegate(runtime.adapter).enabled;
+    const delegate = runtime.adapter.delegate !== false;
     const acp = buildAcpSystemPrompt(runtime.prompts);
     const prompt = delegate ? `${acp}
 ${ACP_DELEGATE_PROMPT}` : acp;