@bermudi/pi-delegate 0.1.10 → 0.1.12

package/task-resolution.ts

@@ -6,15 +6,29 @@ import {
   DEFAULT_TOOLS,
   VALID_THINKING,
 } from "./constants.ts";
-import { TOOL_FACTORIES, resolveToolGroups } from "./tools.ts";
+import {
+  TOOL_FACTORIES,
+  availableToolNames,
+  resolveToolGroups,
+} from "./tools.ts";
 import { configFor } from "./pool.ts";
 import { isSessionBusy } from "./tickets.ts";
 import { BUILTIN_AGENT_CONFIGS, buildSubagentSystemPrompt } from "./agents.ts";
 import { buildParentTranscript } from "./parent-context.ts";
 import { findAvailableAlternative, resolveModelRequest } from "./model.ts";
-import { resolveModelSpec } from "./config.ts";
-import { loadDelegateSettings } from "./settings.ts";
+import {
+  getAgentOverrides,
+  getAgentOverridesByParentModel,
+  resolveModelSpec,
+  getDelegateConfigSnapshot,
+  getProviderExtensionSignature,
+} from "./config.ts";
+import type { DelegateConfig } from "./config.ts";
 import { resolveCwd } from "./utils.ts";
+import {
+  loadDelegateSettings,
+  warnLegacyDelegateSettingsMoved,
+} from "./settings.ts";
 import type {
   AgentConfig,
   DelegateToolCtx,
@@ -28,6 +42,13 @@ const PROJECT_CONTEXT_START =
   "\n\n<project_context>\n\nProject-specific instructions and guidelines:\n\n";
 const PROJECT_CONTEXT_END = "\n</project_context>\n";
 
+function getOwnMapValue<T>(
+  map: Record<string, T> | undefined,
+  key: string,
+): T | undefined {
+  return map && Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
 /**
  * Parent `getSystemPrompt()` is the fully assembled prompt, including the
  * parent's AGENTS.md files. A delegated session resolves resources for its own
@@ -111,24 +132,23 @@ export function validateTasks(
     );
   }
 
-  // Scratch sessions are deliberately one-shot. This check uses the
-  // effective workspace, so reviewer gets the same protection even when the
-  // caller omits workspace. Explicit scratch is never silently promoted to
-  // shared.
+  // Scratch and isolated sessions are deliberately one-shot. This check uses
+  // the effective workspace, so named agents get the same protection even
+  // when the caller omits workspace.
   for (const [index, task] of tasks.entries()) {
     const agent = task.agent
       ? (agents.get(task.agent) ?? BUILTIN_AGENT_CONFIGS[task.agent])
       : undefined;
     const workspace = task.workspace ?? agent?.workspace ?? "shared";
-    const sessionAction = task.sessionAction ?? task.action;
+    const sessionAction = task.sessionAction;
     if (
-      workspace === "scratch" &&
+      (workspace === "scratch" || workspace === "isolated") &&
       (task.sessionId || task.resumeFrom || sessionAction !== undefined)
     ) {
       const defaultText =
-        task.workspace === undefined && agent?.workspace === "scratch"
-          ? "defaults to workspace `scratch`"
-          : "uses workspace `scratch`";
+        task.workspace === undefined && agent?.workspace === workspace
+          ? `defaults to workspace \`${workspace}\``
+          : `uses workspace \`${workspace}\``;
       const persistentAgent = task.agent ?? "agent";
       return noticeResult(
         `${formatTaskRef(index, task.id)}: Agent \`${persistentAgent}\` ${defaultText}, which is one-shot and cannot use \`sessionId\`, \`resumeFrom\`, or session actions. Set \`workspace: "shared"\` to use a persistent ${persistentAgent}.`,
@@ -195,6 +215,7 @@ export function resolveTasks(
   ctx: DelegateToolCtx,
   agents: Map<string, AgentConfig>,
   parentDefaults: ParentAgentDefaults,
+  dispatchConfig: DelegateConfig = getDelegateConfigSnapshot(),
 ): ResolvedTask[] {
   // Build parent transcript lazily — only computed once if any task uses with-parent-transcript
   let parentTranscript: string | null = null;
@@ -217,6 +238,12 @@ export function resolveTasks(
     ctx.getSystemPrompt?.(),
   );
 
+  // Modern overrides come from delegate.json. A one-release bridge below also
+  // reads legacy settings.json model/thinking values; modern values win
+  // field-by-field and legacy tools are never honored.
+  const agentOverrides = getAgentOverrides(dispatchConfig);
+  const overridesByParentModel = getAgentOverridesByParentModel(dispatchConfig);
+
   return tasks.map((t, i) => {
     const isDefaultAgent = t.agent === DEFAULT_AGENT_NAME;
     const agent = t.agent
@@ -225,18 +252,42 @@ export function resolveTasks(
     const isBuiltinAgent = agent?.builtin === true;
     const cwd = resolveCwd(t.cwd ?? ctx.cwd, ctx.cwd);
 
-    // Load settings-based overrides for this agent
-    const settings = loadDelegateSettings(cwd);
+    // A task can resolve to a different cwd than the parent; legacy
+    // `delegate` blocks in those project settings must be surfaced too.
+    warnLegacyDelegateSettingsMoved(cwd, (message) =>
+      ctx.ui?.notify(message, "warning"),
+    );
+    const legacySettings = loadDelegateSettings(cwd);
+
+    // delegate.json agent overrides for this agent. `default` bypasses them
+    // entirely (it mirrors the live parent by contract).
     const parentModelKey = ctx.model
       ? `${ctx.model.provider}/${ctx.model.id}`
       : undefined;
     const parentModelOverride =
       t.agent && !isDefaultAgent && parentModelKey
-        ? settings?.agentOverridesByParentModel?.[parentModelKey]?.[t.agent]
+        ? getOwnMapValue(
+            getOwnMapValue(overridesByParentModel, parentModelKey),
+            t.agent,
+          )
         : undefined;
     const agentOverride =
-      t.agent && !isDefaultAgent && settings?.agentOverrides?.[t.agent]
-        ? settings.agentOverrides[t.agent]
+      t.agent && !isDefaultAgent
+        ? getOwnMapValue(agentOverrides, t.agent)
+        : undefined;
+    const legacyParentModelOverride =
+      t.agent && !isDefaultAgent && parentModelKey
+        ? getOwnMapValue(
+            getOwnMapValue(
+              legacySettings?.agentOverridesByParentModel,
+              parentModelKey,
+            ),
+            t.agent,
+          )
+        : undefined;
+    const legacyAgentOverride =
+      t.agent && !isDefaultAgent
+        ? getOwnMapValue(legacySettings?.agentOverrides, t.agent)
         : undefined;
 
     // Build system prompt. Explicit task prompts and named agent prompts
@@ -255,6 +306,10 @@ export function resolveTasks(
       warnings.push(
         "Scratch workspace: relative file changes run in a disposable CoW copy and are discarded.",
       );
+    } else if (workspace === "isolated") {
+      warnings.push(
+        "Isolated workspace: changes run in a detached Git worktree, then proposals are reconciled in task order. Applied changes remain unverified.",
+      );
     }
 
     // Prompt is required for fresh tasks. ResumeFrom provides context already.
@@ -284,9 +339,7 @@ export function resolveTasks(
         !agent?.explicitTools
       ) {
         const denied = new Set(agent.deniedTools);
-        effectiveParentTools = parentNativeTools.filter(
-          (t) => !denied.has(t),
-        );
+        effectiveParentTools = parentNativeTools.filter((t) => !denied.has(t));
       }
       tools = resolveToolGroups(
         t.tools ??
@@ -302,15 +355,6 @@ export function resolveTasks(
           (isPoolHit ? pooledConfig?.tools : undefined) ??
           DEFAULT_TOOLS,
       );
-      const unknownTools = tools.filter(
-        (name) => !Object.hasOwn(TOOL_FACTORIES, name),
-      );
-      if (unknownTools.length) {
-        warnings.push(
-          `Unknown tool(s) ignored: ${unknownTools.join(", ")}. Available: ${Object.keys(TOOL_FACTORIES).join(", ")}`,
-        );
-      }
-      tools = tools.filter((name) => Object.hasOwn(TOOL_FACTORIES, name));
     }
 
     // System prompt resolution. AgentSession's resource loader owns
@@ -334,14 +378,14 @@ export function resolveTasks(
       parentSystemPrompt,
       tools,
     });
-    const requestedSystemPrompt = t.systemPrompt?.trim()
+    let requestedSystemPrompt = t.systemPrompt?.trim()
       ? t.systemPrompt
       : agent?.systemPrompt?.trim()
         ? agent.systemPrompt
         : isDefaultAgent
           ? resolvedBasePrompt
           : undefined;
-    const systemPrompt = buildSubagentSystemPrompt({
+    let systemPrompt = buildSubagentSystemPrompt({
       taskSystemPrompt: t.systemPrompt,
       agentSystemPrompt: agent?.systemPrompt,
       parentSystemPrompt,
@@ -396,12 +440,19 @@ export function resolveTasks(
           ? (t.model ??
             parentModelOverride?.model ??
             agentOverride?.model ??
+            legacyParentModelOverride?.model ??
+            legacyAgentOverride?.model ??
             (agent?.explicitModel ? agent.model : undefined))
           : resolveModelSpec({
               taskModel:
-                t.model ?? parentModelOverride?.model ?? agentOverride?.model,
+                t.model ??
+                parentModelOverride?.model ??
+                agentOverride?.model ??
+                legacyParentModelOverride?.model ??
+                legacyAgentOverride?.model,
               agentType,
               frontmatterModel: agent?.model,
+              config: dispatchConfig,
             });
 
       // A pool hit always runs its frozen model, but an explicitly requested
@@ -473,6 +524,8 @@ export function resolveTasks(
           ? (t.thinking ??
             parentModelOverride?.thinking ??
             agentOverride?.thinking ??
+            legacyParentModelOverride?.thinking ??
+            legacyAgentOverride?.thinking ??
             (agent?.explicitThinking ? agent.thinking : undefined) ??
             modelSuffix ??
             parentDefaults.thinking ??
@@ -481,13 +534,18 @@ export function resolveTasks(
           : (t.thinking ??
             parentModelOverride?.thinking ??
             agentOverride?.thinking ??
+            legacyParentModelOverride?.thinking ??
+            legacyAgentOverride?.thinking ??
             (agent?.explicitThinking ? agent.thinking : undefined) ??
             (isPoolHit ? pooledConfig?.thinking : undefined) ??
             modelSuffix ??
             parentDefaults.thinking ??
             "off")
         : (t.thinking ??
+          parentModelOverride?.thinking ??
           agentOverride?.thinking ??
+          legacyParentModelOverride?.thinking ??
+          legacyAgentOverride?.thinking ??
           agent?.thinking ??
           (isPoolHit ? pooledConfig?.thinking : undefined) ??
           modelSuffix ??
@@ -504,6 +562,36 @@ export function resolveTasks(
         );
       }
     }
+
+    const providerExtensionSources = getProviderExtensionSignature(
+      model?.provider,
+      dispatchConfig,
+    );
+
+    const availableTools = availableToolNames(model?.provider);
+    const availableToolSet = new Set(availableTools);
+    const unknownTools = tools.filter((name) => !availableToolSet.has(name));
+    if (unknownTools.length) {
+      warnings.push(
+        `Unknown tool(s) ignored: ${unknownTools.join(", ")}. Available: ${availableTools.join(", ")}`,
+      );
+    }
+    tools = tools.filter((name) => availableToolSet.has(name));
+    systemPrompt = buildSubagentSystemPrompt({
+      taskSystemPrompt: t.systemPrompt,
+      agentSystemPrompt: agent?.systemPrompt,
+      parentSystemPrompt,
+      pooledSystemPrompt: pooledConfig?.systemPrompt,
+      tools,
+    });
+    if (
+      isDefaultAgent &&
+      !t.systemPrompt?.trim() &&
+      !agent?.systemPrompt?.trim()
+    ) {
+      requestedSystemPrompt = systemPrompt;
+    }
+
     return {
       ...t,
       id: t.id,
@@ -524,6 +612,7 @@ export function resolveTasks(
         model: requestedModel,
         systemPrompt: requestedSystemPrompt,
       },
+      providerExtensionSources,
     };
   });
 }

package/telemetry.ts

@@ -69,9 +69,16 @@ interface TelemetryBackend {
   close(): void;
 }
 
-let backend: TelemetryBackend | undefined;
-let backendGeneration: number | undefined;
-let backendFailed = false;
+/** One backend follows the live config. A call captures its config, but if the
+ * path changes before a later row is written that row is deliberately dropped
+ * rather than retaining/reopening a stale database. Telemetry is best-effort;
+ * this small policy avoids a generation-keyed resource manager. */
+let activeBackend: TelemetryBackend | undefined;
+let activeBackendIdentity: string | undefined;
+/** Prevent repeated open/write logs for the current live config. Reset when
+ * the config identity changes. */
+let failedBackendIdentity: string | undefined;
+
 /** Monotonic runtime identity. A late worker from a previous runtime may not
  * write into the next runtime's backend after a bounded shutdown drain. */
 let telemetryGeneration = 0;
@@ -442,34 +449,51 @@ class RecorderBackend implements TelemetryBackend {
   close(): void {}
 }
 
-function disableBackend(operation: string, error: unknown): void {
-  if (backendFailed) return;
-  backendFailed = true;
-  const failedBackend = backend;
-  backend = undefined;
+function backendIdentity(
+  config: import("./config.ts").TelemetryConfig,
+): string | undefined {
+  if (config.enabled === false) return undefined;
+  return config.dbPath ?? defaultDbPath();
+}
+
+function disableActiveBackend(
+  identity: string,
+  operation: string,
+  error: unknown,
+): void {
+  if (activeBackendIdentity !== identity) return;
+  const failedBackend = activeBackend;
+  activeBackend = undefined;
+  activeBackendIdentity = undefined;
+  failedBackendIdentity = identity;
   try {
     failedBackend?.close();
   } catch (closeError) {
     console.error("[delegate] telemetry backend close failed", closeError);
   }
   console.error(
-    `[delegate] telemetry ${operation} failed; disabling telemetry`,
+    `[delegate] telemetry ${operation} failed; disabling telemetry until its config changes`,
     error,
   );
 }
 
-function openBackend(): TelemetryBackend | undefined {
-  const config = getTelemetryConfig();
-  if (config.enabled === false) return undefined;
-  if (backendFailed || telemetryClosed) return undefined;
-  if (testingRecorder) {
-    return new RecorderBackend(testingRecorder, disableBackend);
+function closeTelemetryBackend(): void {
+  try {
+    activeBackend?.close();
+  } catch (error) {
+    console.error("[delegate] telemetry backend close failed", error);
   }
+  activeBackend = undefined;
+  activeBackendIdentity = undefined;
+  failedBackendIdentity = undefined;
+}
 
-  if (!DatabaseSyncCtor) {
-    backendFailed = true;
-    return undefined;
-  }
+function openSqliteBackend(
+  config: import("./config.ts").TelemetryConfig,
+  onFailure: (operation: string, error: unknown) => void,
+): TelemetryBackend | undefined {
+  if (config.enabled === false || telemetryClosed) return undefined;
+  if (!DatabaseSyncCtor) return undefined;
 
   const dbPath = config.dbPath ?? defaultDbPath();
   let db: DatabaseSync | undefined;
@@ -484,41 +508,78 @@ function openBackend(): TelemetryBackend | undefined {
     db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS};`);
     db.exec("PRAGMA journal_mode = WAL;");
     initSchema(db);
-    return new SqliteTelemetryBackend(db, disableBackend);
+    return new SqliteTelemetryBackend(db, onFailure);
   } catch (error) {
     try {
       db?.close();
     } catch (closeError) {
       console.error("[delegate] telemetry database close failed", closeError);
     }
-    backendFailed = true;
     console.error("[delegate] telemetry database failed to open", error);
     return undefined;
   }
 }
 
-function getBackend(generation?: number): TelemetryBackend | undefined {
+function getBackendForConfig(
+  generation: number,
+  config: import("./config.ts").TelemetryConfig,
+): TelemetryBackend | undefined {
   if (telemetryClosed) return undefined;
-  if (generation !== undefined && generation !== telemetryGeneration) {
+  if (generation !== telemetryGeneration) return undefined;
+  const capturedIdentity = backendIdentity(config);
+  const liveConfig = getTelemetryConfig();
+  const liveIdentity = backendIdentity(liveConfig);
+
+  // A hot reload changed the destination. Drop every old-identity span's
+  // remaining rows, including concurrent spans, and release the one live
+  // handle; the next call opens the new destination. Telemetry is best-effort,
+  // so retaining/refcounting obsolete backends is deliberately out of scope.
+  if (capturedIdentity !== liveIdentity) {
+    if (activeBackend && activeBackendIdentity !== liveIdentity) {
+      closeTelemetryBackend();
+    } else if (failedBackendIdentity !== liveIdentity) {
+      failedBackendIdentity = undefined;
+    }
     return undefined;
   }
-  if (backend) {
-    if (backendGeneration !== telemetryGeneration) {
-      // A previous runtime left its handle open while its bounded shutdown
-      // drain timed out. Dispose that stale handle before opening this one.
-      const stale = backend;
-      backend = undefined;
-      backendGeneration = undefined;
-      stale.close();
-    } else if (generation !== undefined && backendGeneration !== generation) {
-      return undefined;
-    } else {
-      return backend;
-    }
+  if (liveIdentity === undefined) {
+    if (activeBackend || failedBackendIdentity) closeTelemetryBackend();
+    return undefined;
+  }
+
+  if (activeBackend && activeBackendIdentity !== liveIdentity) {
+    closeTelemetryBackend();
+  }
+  if (failedBackendIdentity !== liveIdentity) failedBackendIdentity = undefined;
+  if (failedBackendIdentity === liveIdentity) return undefined;
+  if (activeBackend) return activeBackend;
+
+  activeBackendIdentity = liveIdentity;
+  activeBackend = testingRecorder
+    ? new RecorderBackend(testingRecorder, (operation, error) =>
+        disableActiveBackend(liveIdentity, operation, error),
+      )
+    : openSqliteBackend(liveConfig, (operation, error) =>
+        disableActiveBackend(liveIdentity, operation, error),
+      );
+  if (!activeBackend) {
+    // This includes Bun's intentional no-node:sqlite path. No log is needed
+    // there; real SQLite open failures were already logged at the boundary.
+    activeBackendIdentity = undefined;
+    failedBackendIdentity = liveIdentity;
   }
-  backend = openBackend();
-  if (backend) backendGeneration = telemetryGeneration;
-  return backend;
+  return activeBackend;
+}
+
+/** Legacy unpinned backend lookup: uses the *live* telemetry config. Callers
+ *  that need a stable backend for the lifetime of a span/task should use
+ *  `getBackendForConfig` with the config captured at creation. */
+function getBackend(generation?: number): TelemetryBackend | undefined {
+  if (telemetryClosed) return undefined;
+  return getBackendForConfig(
+    generation ?? telemetryGeneration,
+    getTelemetryConfig(),
+  );
 }
 
 export interface CallSpanInput {
@@ -540,6 +601,8 @@ export interface CallSpan {
   readonly startedAt: number;
   /** Runtime generation captured at call creation; stale calls cannot write. */
   readonly generation: number;
+  /** Telemetry config captured at call creation; binds the span to one backend. */
+  readonly telemetryConfig: import("./config.ts").TelemetryConfig;
   /** Snapshot of the call row as it would be written at spawn. */
   baseRecord(): CallRecord;
   spawn(): void;
@@ -550,7 +613,9 @@ class CallSpanImpl implements CallSpan {
   readonly id: string;
   readonly startedAt: number;
   readonly generation = telemetryGeneration;
+  readonly telemetryConfig = getTelemetryConfig();
   private readonly input: CallSpanInput;
+  private finished = false;
 
   constructor(input: CallSpanInput) {
     this.id = crypto.randomUUID();
@@ -576,13 +641,15 @@ class CallSpanImpl implements CallSpan {
   }
 
   spawn(): void {
-    const b = getBackend(this.generation);
+    const b = getBackendForConfig(this.generation, this.telemetryConfig);
     if (!b) return;
     b.recordCall(this.baseRecord());
   }
 
   finish(finish: CallSpanFinish): void {
-    const b = getBackend(this.generation);
+    if (this.finished) return;
+    this.finished = true;
+    const b = getBackendForConfig(this.generation, this.telemetryConfig);
     if (!b) return;
     const record = this.baseRecord();
     record.wall_ms = finish.wallMs;
@@ -597,8 +664,14 @@ export function beginCall(input: CallSpanInput): CallSpan {
   return new CallSpanImpl(input);
 }
 
-export function recordCall(record: CallRecord, generation?: number): void {
-  const b = getBackend(generation);
+export function recordCall(
+  record: CallRecord,
+  generation?: number,
+  config?: import("./config.ts").TelemetryConfig,
+): void {
+  const b = config
+    ? getBackendForConfig(generation ?? telemetryGeneration, config)
+    : getBackend(generation);
   if (!b) return;
   b.recordCall(record);
 }
@@ -609,6 +682,9 @@ export interface TaskSpanInput {
   callId: string;
   /** Runtime generation captured by the dispatch that owns this task. */
   generation?: number;
+  /** Telemetry config captured at dispatch; binds the task row to the same
+   *  backend as the call span. */
+  telemetryConfig?: import("./config.ts").TelemetryConfig;
   async: boolean;
   taskIndex: number;
   task: ResolvedTask;
@@ -625,7 +701,12 @@ function outcomeFromResult(result: TaskResult): string {
 }
 
 export function recordTask(input: TaskSpanInput): string | undefined {
-  const b = getBackend(input.generation);
+  const b = input.telemetryConfig
+    ? getBackendForConfig(
+        input.generation ?? telemetryGeneration,
+        input.telemetryConfig,
+      )
+    : getBackend(input.generation);
   if (!b) return undefined;
 
   const { callId, async, taskIndex, task, progress, result, retries } = input;
@@ -671,10 +752,7 @@ export function sealTelemetryWrites(expectedGeneration?: number): boolean {
   }
   telemetryGeneration++;
   telemetryClosed = true;
-  const current = backend;
-  backend = undefined;
-  backendGeneration = undefined;
-  current?.close();
+  closeTelemetryBackend();
   return true;
 }
 
@@ -689,10 +767,7 @@ export function closeTelemetry(expectedGeneration?: number): void {
     return;
   }
   telemetryClosed = true;
-  const current = backend;
-  backend = undefined;
-  backendGeneration = undefined;
-  current?.close();
+  closeTelemetryBackend();
 }
 
 /** Current runtime identity for lifecycle owners such as session_shutdown. */
@@ -707,10 +782,7 @@ export function prepareTelemetryForSession(): void {
   // A timed-out old runtime may have left its handle open. Close it before
   // advancing the generation so the old shutdown handler cannot close the new
   // runtime's backend later.
-  const stale = backend;
-  backend = undefined;
-  backendGeneration = undefined;
-  stale?.close();
+  closeTelemetryBackend();
 
   telemetryGeneration++;
   telemetryClosed = false;
@@ -719,25 +791,20 @@ export function prepareTelemetryForSession(): void {
 export function _setTelemetryForTesting(
   recorder: TelemetryRecorder | undefined,
 ): void {
-  if (backend) {
-    backend.close();
-    backend = undefined;
-    backendGeneration = undefined;
-  }
+  closeTelemetryBackend();
   testingRecorder = recorder;
-  backendFailed = false;
   telemetryGeneration++;
   telemetryClosed = false;
 }
 
 export function _resetTelemetryForTesting(): void {
   testingRecorder = undefined;
-  if (backend) {
-    backend.close();
-    backend = undefined;
-    backendGeneration = undefined;
-  }
-  backendFailed = false;
+  closeTelemetryBackend();
   telemetryGeneration++;
   telemetryClosed = false;
 }
+
+/** @internal Test seam exposing the single live backend path, never handles. */
+export function _getTelemetryBackendPathsForTesting(): string[] {
+  return activeBackendIdentity === undefined ? [] : [activeBackendIdentity];
+}