@bermudi/pi-delegate 0.1.11 → 0.1.13

package/task-resolution.ts

@@ -16,9 +16,19 @@ 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,
@@ -32,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
@@ -115,10 +132,9 @@ 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])
@@ -126,13 +142,13 @@ export function validateTasks(
     const workspace = task.workspace ?? agent?.workspace ?? "shared";
     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}.`,
@@ -199,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;
@@ -221,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
@@ -229,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
@@ -259,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.
@@ -389,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
@@ -466,6 +524,8 @@ export function resolveTasks(
           ? (t.thinking ??
             parentModelOverride?.thinking ??
             agentOverride?.thinking ??
+            legacyParentModelOverride?.thinking ??
+            legacyAgentOverride?.thinking ??
             (agent?.explicitThinking ? agent.thinking : undefined) ??
             modelSuffix ??
             parentDefaults.thinking ??
@@ -474,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 ??
@@ -498,6 +563,11 @@ 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));
@@ -542,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];
+}

package/ticket-format.ts

@@ -12,6 +12,7 @@ import {
   formatTouchedOverlapWarning,
 } from "./format.ts";
 import { renderOutputForPoll } from "./spill.ts";
+import { getOutputSpillTail } from "./config.ts";
 import type {
   AsyncTicket,
   DelegateDetails,
@@ -111,18 +112,20 @@ function appendTouchedMeta(
 }
 
 function formatSettledPollLines(
+  ticket: AsyncTicket,
   result: TaskResult,
   task: ResolvedTask,
   failed: boolean,
 ): string[] {
   const meta = taskMetaBase(result);
   appendTouchedMeta(meta, result, task);
+  const tailChars = getOutputSpillTail(ticket.config);
   if (!failed) {
     const lines = [
       `✓ ${result.agent}${formatTaskId(result.id)} · ${meta.join(" · ")}`,
     ];
     if (result.output && result.output !== "(no output)") {
-      lines.push(renderOutputForPoll(result.output));
+      lines.push(renderOutputForPoll(result.output, { tailChars }));
     }
     return lines;
   }
@@ -133,7 +136,7 @@ function formatSettledPollLines(
   if (result.sessionFile)
     lines.push(`  session: ${shortenPath(result.sessionFile)}`);
   if (result.output && result.output !== "(no output)") {
-    lines.push(renderOutputForPoll(result.output));
+    lines.push(renderOutputForPoll(result.output, { tailChars }));
   }
   return lines;
 }
@@ -146,13 +149,13 @@ function formatPollTaskLines(
   const r = ticket.results[index];
   if (p.status === "done" && r) {
     return {
-      lines: formatSettledPollLines(r, ticket.resolved[index]!, false),
+      lines: formatSettledPollLines(ticket, r, ticket.resolved[index]!, false),
       result: r,
     };
   }
   if (p.status === "failed" && r) {
     return {
-      lines: formatSettledPollLines(r, ticket.resolved[index]!, true),
+      lines: formatSettledPollLines(ticket, r, ticket.resolved[index]!, true),
       result: r,
     };
   }
@@ -237,10 +240,15 @@ export function formatLiveTicketPoll(
     findTouchedOverlaps(completedForOverlap),
   );
   const guidance = liveTicketGuidance(ticket);
+  const dispatchWarning = ticket.dispatchWarning
+    ? `WARNING: ${ticket.dispatchWarning}`
+    : "";
   return {
     text: `${formatLiveTicketHeader(ticket, now)}\n${lines.join("\n")}${
       guidance ? `\n\n${guidance}` : ""
-    }${overlapWarning ? `\n\n${overlapWarning}` : ""}`,
+    }${dispatchWarning ? `\n\n${dispatchWarning}` : ""}${
+      overlapWarning ? `\n\n${overlapWarning}` : ""
+    }`,
     completedResults,
     overlapWarning,
   };