@bermudi/pi-delegate 0.1.11 → 0.1.13

package/delegate.ts

@@ -40,9 +40,14 @@ export {
   getMaxConcurrent,
   getStallTimeoutMs,
   resolveModelSpec,
+  getAgentOverrides,
+  getAgentOverridesByParentModel,
+  reloadDelegateConfig,
+  getDelegateConfigSnapshot,
   getOutputSpillThreshold,
   getOutputSpillTail,
 } from "./config.ts";
+export type { AgentOverride } from "./config.ts";
 export {
   checkout,
   commit,
@@ -142,10 +147,12 @@ export {
 } from "./model.ts";
 export {
   readDelegateSettingsFile,
+  findLegacyDelegateSettings,
+  warnLegacyDelegateSettingsMoved,
   loadDelegateSettings,
   clearDelegateSettingsCache,
 } from "./settings.ts";
-export type { AgentOverride } from "./settings.ts";
+export type { DelegateSettings } from "./settings.ts";
 export { resolveCwd, extractOutput, extractUsage } from "./utils.ts";
 export {
   decideSpill,

package/dispatch.ts

@@ -9,7 +9,13 @@ import {
   settleTicket,
   notifyWaiters,
 } from "./tickets.ts";
-import { getConcurrencyLimit, getMaxAsyncTickets } from "./config.ts";
+import {
+  getConcurrencyLimit,
+  getMaxAsyncTickets,
+  getDelegateConfigSnapshot,
+  getTelemetryConfig,
+} from "./config.ts";
+import type { DelegateConfig } from "./config.ts";
 import { getCurrentLeafId } from "./leaf.ts";
 import { getModelKey, mapConcurrentByModel } from "./concurrency.ts";
 import { aggregateTaskResults, sumUsage } from "./usage.ts";
@@ -24,8 +30,13 @@ import {
 import { validateDelegateOperation } from "./schema.ts";
 import { notifyCrossLeafDelivery, syncDelegateStatus } from "./status.ts";
 import { validateTasks, resolveTasks } from "./task-resolution.ts";
-import { clearDelegateSettingsCache } from "./settings.ts";
+import {
+  findSharedWriteConflicts,
+  isSharedWriter,
+  type SharedWriteConflict,
+} from "./shared-write-safety.ts";
 import type { CallSpan } from "./telemetry.ts";
+import { prepareIsolatedBatch } from "./isolated-workspace.ts";
 import type {
   AgentConfig,
   AsyncTicket,
@@ -41,6 +52,36 @@ import type {
   TaskRunEnv,
 } from "./types.ts";
 
+const UNSAFE_SHARED_WRITES_WARNING =
+  "UNSAFE SHARED WRITES ENABLED: shared-write admission is bypassed. Delegate provides no isolation or rollback.";
+
+interface ActiveSyncDispatch {
+  tasks: TaskDef[];
+  resolved: ResolvedTask[];
+}
+
+const activeSyncDispatches = new Map<symbol, ActiveSyncDispatch>();
+let sharedWriteAdmissionTail: Promise<void> = Promise.resolve();
+
+/** Serialize the preflight snapshot and publication step. The lock is held only
+ * during admission, never while subagents run. This prevents two concurrent
+ * calls from both inspecting an empty active set and then starting together. */
+async function withSharedWriteAdmissionLock<T>(
+  operation: () => Promise<T>,
+): Promise<T> {
+  const previous = sharedWriteAdmissionTail;
+  let release!: () => void;
+  sharedWriteAdmissionTail = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+  }
+}
+
 /** Return the structured result for an invalid top-level operation, or null when
  * the call may proceed to a ticket control/help/dispatch path. */
 export function validateDelegateOperationResult(
@@ -89,6 +130,7 @@ export function makeFireUpdater(
   progress: TaskProgress[],
   resolved: ResolvedTask[],
   parentModelId: string | undefined,
+  dispatchWarning?: string,
 ): () => void {
   return () =>
     onUpdate?.({
@@ -103,6 +145,7 @@ export function makeFireUpdater(
         results: [],
         progress: [...progress],
         parentModel: parentModelId,
+        dispatchWarning,
       },
     });
 }
@@ -116,6 +159,8 @@ export interface AsyncDispatchInput {
   progress: TaskProgress[];
   parentModelId: string | undefined;
   callSpan?: CallSpan;
+  dispatchConfig: DelegateConfig;
+  dispatchWarning?: string;
 }
 
 /** Inputs needed by the sync (blocking) dispatch path. */
@@ -128,6 +173,8 @@ export interface SyncDispatchInput {
   signal: AbortSignal | undefined;
   fire: () => void;
   callSpan?: CallSpan;
+  dispatchConfig: DelegateConfig;
+  dispatchWarning?: string;
 }
 
 /** Inputs for the normal task-validation, resolution, and dispatch path. */
@@ -143,13 +190,78 @@ export interface DelegateDispatchInput {
   callSpan?: CallSpan;
 }
 
+function taskReference(task: TaskDef, index: number): string {
+  return `Task ${index + 1}${task.id ? `#${task.id}` : ""}`;
+}
+
+/** Isolated workers do not share their worktrees with each other, but their
+ * source root must remain reserved against shared writers until ordered apply
+ * finishes. Represent them as shared only inside the admission index. */
+function asAdmissionWriter(task: ResolvedTask): ResolvedTask {
+  return task.workspace === "isolated"
+    ? { ...task, workspace: "shared" }
+    : task;
+}
+
+function sharedWriteRejection(
+  tasks: TaskDef[],
+  parentModelId: string | undefined,
+  conflicts: SharedWriteConflict[],
+  references: readonly string[] = tasks.map(taskReference),
+): DelegateToolResult {
+  const scopes = conflicts
+    .map(({ scope, taskIndexes }) => {
+      const refs = taskIndexes
+        .map((index) => references[index] ?? `Active writer ${index + 1}`)
+        .join(", ");
+      return `${refs} share ${scope.kind === "git" ? "Git root" : "directory"} '${scope.root}'.`;
+    })
+    .join(" ");
+  return {
+    content: [
+      {
+        type: "text",
+        text:
+          `Rejected before dispatch; no tasks were started. ${scopes} ` +
+          "Each listed task has mutating or unclassified tool capability, so concurrent shared execution could silently overwrite work. " +
+          'Run them sequentially, use workspace: "isolated" for Git-backed ordered reconciliation, or use workspace: "scratch" when changes may be discarded. ' +
+          "External processes remain outside this check.",
+      },
+    ],
+    details: { tasks, results: [], progress: [], parentModel: parentModelId },
+  };
+}
+
+function sharedWriteSafetyFailure(
+  tasks: TaskDef[],
+  parentModelId: string | undefined,
+  error: unknown,
+): DelegateToolResult {
+  const detail =
+    error instanceof Error ? error.message : "Unknown workspace error.";
+  return {
+    content: [
+      {
+        type: "text",
+        text:
+          `Rejected before dispatch; no tasks were started because shared-write safety could not be verified. ${detail} ` +
+          'Fix the task directory or Git metadata, run tasks sequentially, use workspace: "isolated" for Git-backed ordered reconciliation, or use workspace: "scratch" when changes may be discarded.',
+      },
+    ],
+    details: { tasks, results: [], progress: [], parentModel: parentModelId },
+  };
+}
+
 /** Validate, resolve, and dispatch a non-short-circuit delegate operation. */
 export async function dispatchDelegate(
   input: DelegateDispatchInput,
 ): Promise<DelegateToolResult> {
-  // Settings are user-editable. Clear once at the dispatch boundary so every
-  // task in this batch observes one consistent settings snapshot.
-  clearDelegateSettingsCache();
+  // The extension entry point already reloaded delegate.json and reconfigured
+  // the global concurrency cap. Capture a dispatch-scoped snapshot here so the
+  // retry/stall/output/provider settings stay immutable for every task in this
+  // batch, even if a later dispatch mutates the global singleton while async
+  // work is still in flight.
+  const dispatchConfig = getDelegateConfigSnapshot();
   const {
     pi,
     params,
@@ -174,39 +286,211 @@ export async function dispatchDelegate(
     return validationError;
   }
 
-  const resolved = resolveTasks(tasks, ctx, agents, parentDefaults);
-  const progress = initProgress(resolved);
-  const fire = makeFireUpdater(
-    onUpdate,
+  const resolved = resolveTasks(
     tasks,
-    progress,
-    resolved,
-    parentModelId,
+    ctx,
+    agents,
+    parentDefaults,
+    dispatchConfig,
   );
-  fire();
+  if (params.async && resolved.some((task) => task.workspace === "isolated")) {
+    callSpan?.finish({
+      status: "failed",
+      totalTokens: 0,
+      totalCost: 0,
+      wallMs: Date.now() - callSpan.startedAt,
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: 'Invalid delegate call: workspace "isolated" is synchronous; remove async.',
+        },
+      ],
+      details: {
+        tasks,
+        results: [],
+        progress: [],
+        parentModel: parentModelId,
+      },
+    };
+  }
+
+  const dispatchWarning = dispatchConfig.allowUnsafeSharedWrites
+    ? UNSAFE_SHARED_WRITES_WARNING
+    : undefined;
+  const signalWasAbortedBeforeAdmission = signal?.aborted === true;
+  let syncReservation: symbol | undefined;
+  let admissionResult:
+    DelegateToolResult | { progress: TaskProgress[]; fire: () => void };
+
+  try {
+    admissionResult = await withSharedWriteAdmissionLock(async () => {
+      // The call may have been cancelled while queued behind another
+      // preflight. Async dispatch uses its own controller after publication, so
+      // this check must happen before progress, reservations, or ticket
+      // creation rather than relying on the parent signal downstream.
+      if (!signalWasAbortedBeforeAdmission && signal?.aborted) {
+        throw new Error("Delegate call aborted while waiting for admission.");
+      }
+      if (
+        !dispatchConfig.allowUnsafeSharedWrites &&
+        resolved.some((task) => isSharedWriter(asAdmissionWriter(task)))
+      ) {
+        const incomingForSafety = resolved.map(asAdmissionWriter);
+        const activeResolved: ResolvedTask[] = [];
+        const references = resolved.map((_, index) =>
+          taskReference(tasks[index]!, index),
+        );
 
-  if (params.async) {
-    return dispatchAsync({
-      pi,
+        for (const ticket of ticketRegistry.values()) {
+          if (
+            ticket.status !== "running" &&
+            ticket.status !== "cancelling" &&
+            ticket.workersSettled !== false
+          ) {
+            continue;
+          }
+          for (let index = 0; index < ticket.resolved.length; index++) {
+            activeResolved.push(ticket.resolved[index]!);
+            references.push(
+              `async ticket '${ticket.id}' ${taskReference(ticket.tasks[index]!, index).toLowerCase()}`,
+            );
+          }
+        }
+        for (const active of activeSyncDispatches.values()) {
+          for (let index = 0; index < active.resolved.length; index++) {
+            activeResolved.push(active.resolved[index]!);
+            references.push(
+              `active sync ${taskReference(active.tasks[index]!, index).toLowerCase()}`,
+            );
+          }
+        }
+
+        const incomingCount = resolved.length;
+        const conflicts = (
+          await findSharedWriteConflicts(
+            [...incomingForSafety, ...activeResolved],
+            signal,
+          )
+        ).filter(({ taskIndexes }) => {
+          if (!taskIndexes.some((index) => index < incomingCount)) return false;
+          // Multiple isolated tasks in this call intentionally share one
+          // baseline/root. Any shared task or active dispatch in the same
+          // conflict group still rejects the call.
+          return !taskIndexes.every(
+            (index) =>
+              index < incomingCount &&
+              resolved[index]?.workspace === "isolated",
+          );
+        });
+        if (conflicts.length) {
+          return sharedWriteRejection(
+            tasks,
+            parentModelId,
+            conflicts,
+            references,
+          );
+        }
+      }
+
+      const progress = initProgress(resolved);
+      const fire = makeFireUpdater(
+        onUpdate,
+        tasks,
+        progress,
+        resolved,
+        parentModelId,
+        dispatchWarning,
+      );
+      fire();
+
+      if (params.async) {
+        return dispatchAsync({
+          pi,
+          ctx,
+          tasks,
+          resolved,
+          progress,
+          parentModelId,
+          callSpan,
+          dispatchConfig,
+          dispatchWarning,
+        });
+      }
+
+      syncReservation = Symbol("shared-write-dispatch");
+      activeSyncDispatches.set(syncReservation, {
+        tasks,
+        resolved: resolved.map(asAdmissionWriter),
+      });
+      return { progress, fire };
+    });
+  } catch (error) {
+    // A parent abort mid-preflight rejects the git rev-parse execFile call;
+    // gitRepositoryRoot wraps every execFile error (abort-shaped ones
+    // included) in GitScopeError, so the error alone cannot distinguish a
+    // cancellation from a verification failure. Check the signal first —
+    // reporting Git-metadata advice for a plain abort would misdirect.
+    if (signal?.aborted) {
+      callSpan?.finish({
+        status: "cancelled",
+        totalTokens: 0,
+        totalCost: 0,
+        wallMs: Date.now() - callSpan.startedAt,
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Aborted before dispatch; no tasks were started.",
+          },
+        ],
+        details: {
+          tasks,
+          results: [],
+          progress: [],
+          parentModel: parentModelId,
+        },
+      };
+    }
+    callSpan?.finish({
+      status: "failed",
+      totalTokens: 0,
+      totalCost: 0,
+      wallMs: Date.now() - callSpan.startedAt,
+    });
+    return sharedWriteSafetyFailure(tasks, parentModelId, error);
+  }
+
+  if ("content" in admissionResult) {
+    if (admissionResult.content[0]?.text.includes("Rejected before dispatch")) {
+      callSpan?.finish({
+        status: "failed",
+        totalTokens: 0,
+        totalCost: 0,
+        wallMs: Date.now() - callSpan.startedAt,
+      });
+    }
+    return admissionResult;
+  }
+
+  try {
+    return await dispatchSync({
       ctx,
       tasks,
       resolved,
-      progress,
+      progress: admissionResult.progress,
       parentModelId,
+      signal,
+      fire: admissionResult.fire,
       callSpan,
+      dispatchConfig,
+      dispatchWarning,
     });
+  } finally {
+    if (syncReservation) activeSyncDispatches.delete(syncReservation);
   }
-
-  return dispatchSync({
-    ctx,
-    tasks,
-    resolved,
-    progress,
-    parentModelId,
-    signal,
-    fire,
-    callSpan,
-  });
 }
 
 /** Deliver a settled ticket and, when leaf affinity downgraded delivery to a
@@ -238,13 +522,24 @@ function settleAsyncCall(
  *  the concurrent run, and returns the ticket acknowledgment immediately.
  *  Results are delivered via `deliverTicketResults` when all tasks settle. */
 export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
-  const { pi, ctx, tasks, resolved, progress, parentModelId, callSpan } = input;
+  const {
+    pi,
+    ctx,
+    tasks,
+    resolved,
+    progress,
+    parentModelId,
+    callSpan,
+    dispatchConfig,
+    dispatchWarning,
+  } = input;
 
   sweepTickets();
   const runningCount = [...ticketRegistry.values()].filter(
     (t) => t.status === "running" || t.status === "cancelling",
   ).length;
-  if (runningCount >= getMaxAsyncTickets()) {
+  const maxAsyncTickets = getMaxAsyncTickets(dispatchConfig);
+  if (runningCount >= maxAsyncTickets) {
     callSpan?.finish({
       status: "failed",
       totalTokens: 0,
@@ -255,7 +550,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       content: [
         {
           type: "text",
-          text: `Too many async tickets running or cancelling (${runningCount}/${getMaxAsyncTickets()}). Poll existing tickets or cancel one first.`,
+          text: `Too many async tickets running or cancelling (${runningCount}/${maxAsyncTickets}). Poll existing tickets or cancel one first.`,
         },
       ],
       details: { tasks, results: [], progress: [], parentModel: parentModelId },
@@ -281,6 +576,13 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     callStartedAt: callSpan?.startedAt,
     callRecord: callSpan ? { ...callSpan.baseRecord() } : undefined,
     telemetryGeneration: callSpan?.generation,
+    telemetryConfig: callSpan?.telemetryConfig,
+    workersSettled: false,
+    dispatchWarning,
+    // Capture the dispatch-scoped snapshot so async workers and later poll/wait
+    // formatting use the same retry/stall/output/provider settings that were
+    // in effect when the ticket was spawned.
+    config: dispatchConfig,
   };
   ticketRegistry.set(ticketId, ticket);
   callSpan?.spawn();
@@ -301,7 +603,10 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
     delegateStartedAt: ticket.created,
     telemetryCallId: callSpan?.id,
     telemetryGeneration: callSpan?.generation,
+    telemetryConfig:
+      callSpan?.telemetryConfig ?? getTelemetryConfig(dispatchConfig),
     async: true,
+    config: dispatchConfig,
     onProgress: (p, u) => {
       updateProgressFromRun(p, u);
       notifyWaiters(ticket);
@@ -332,7 +637,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   const completion = mapConcurrentByModel(
     resolved,
     (t) => getModelKey(t.model),
-    getConcurrencyLimit,
+    (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
     async (t, i) => {
       const result = await runResolvedTask(asyncEnv, t, ticket.progress[i]!, i);
       ticket.results[i] = result;
@@ -380,6 +685,9 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
         error: err instanceof Error ? err.message : String(err),
       });
       finishLiveSettlement(ticket);
+    })
+    .finally(() => {
+      ticket.workersSettled = true;
     });
   ticket.completion = completion;
 
@@ -389,7 +697,8 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
         type: "text",
         text: [
           `Async ticket: ${ticketId}`,
-          `${resolved.length} task(s) dispatched · ${runningCount + 1}/${getMaxAsyncTickets()} async slots in use`,
+          `${resolved.length} task(s) dispatched · ${runningCount + 1}/${maxAsyncTickets} async slots in use`,
+          ...(dispatchWarning ? [`WARNING: ${dispatchWarning}`] : []),
           "",
           "Work is detached. Stop this turn to let final results auto-deliver.",
           `If this turn must block for the result, call once: delegate({ ticketAction: "wait", ticket: "${ticketId}" }) — omit timeoutMs and do not poll`,
@@ -404,6 +713,7 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       parentModel: parentModelId,
       ticketId,
       status: ticket.status,
+      dispatchWarning,
     },
   };
 }
@@ -422,9 +732,39 @@ export async function dispatchSync(
     signal,
     fire,
     callSpan,
+    dispatchConfig,
+    dispatchWarning,
   } = input;
 
   const startedAt = Date.now();
+  let executionResolved = resolved;
+  let isolatedBatch: Awaited<ReturnType<typeof prepareIsolatedBatch>>;
+  try {
+    isolatedBatch = await prepareIsolatedBatch(resolved, signal);
+    if (isolatedBatch) executionResolved = isolatedBatch.resolved;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    callSpan?.finish({
+      status: "failed",
+      totalTokens: 0,
+      totalCost: 0,
+      wallMs: Date.now() - startedAt,
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Isolated workspace setup failed; no subagents were started. ${detail}`,
+        },
+      ],
+      details: {
+        tasks,
+        results: [],
+        progress: [],
+        parentModel: parentModelId,
+      },
+    };
+  }
   const syncEnv: TaskRunEnv = {
     signal,
     modelRegistry: ctx.modelRegistry,
@@ -432,7 +772,10 @@ export async function dispatchSync(
     delegateStartedAt: startedAt,
     telemetryCallId: callSpan?.id,
     telemetryGeneration: callSpan?.generation,
+    telemetryConfig:
+      callSpan?.telemetryConfig ?? getTelemetryConfig(dispatchConfig),
     async: false,
+    config: dispatchConfig,
     onProgress: (p, u) => {
       updateProgressFromRun(p, u);
       fire();
@@ -440,13 +783,33 @@ export async function dispatchSync(
     onStatusChange: () => fire(),
   };
 
-  const results = await mapConcurrentByModel(
-    resolved,
+  let results = await mapConcurrentByModel(
+    executionResolved,
     (t) => getModelKey(t.model),
-    getConcurrencyLimit,
+    (modelKey) => getConcurrencyLimit(modelKey, dispatchConfig),
     async (t, i) => runResolvedTask(syncEnv, t, progress[i]!, i),
     signal,
   );
+  if (isolatedBatch) {
+    try {
+      results = await isolatedBatch.reconcile(results);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.error("[delegate] isolated reconciliation failed", error);
+      for (let index = 0; index < results.length; index++) {
+        if (resolved[index]?.workspace !== "isolated") continue;
+        results[index] = {
+          ...results[index]!,
+          integration: {
+            status: "apply_failed",
+            proposedFiles: [],
+            appliedFiles: [],
+            conflicts: [{ path: "(batch)", reason: detail }],
+          },
+        };
+      }
+    }
+  }
 
   // ── Format for LLM ────────────────────────────────────────────
   const finalResults: TaskResult[] = results;
@@ -457,10 +820,11 @@ export async function dispatchSync(
   parts.push(
     `${succeeded}/${finalResults.length} tasks completed successfully · ${fmtDuration(elapsedTotal)} wall time\n`,
   );
+  if (dispatchWarning) parts.push(`WARNING: ${dispatchWarning}`);
   for (let i = 0; i < finalResults.length; i++) {
     const r = finalResults[i]!;
     const t = resolved[i]!;
-    parts.push(...formatCompletedTask(t, r));
+    parts.push(...formatCompletedTask(t, r, dispatchConfig));
   }
 
   const overlapWarning = formatTouchedOverlapWarning(
@@ -468,7 +832,14 @@ export async function dispatchSync(
   );
   if (overlapWarning) parts.push("", overlapWarning);
 
-  const status = finalResults.some((r) => r.error) ? "failed" : "success";
+  const status = finalResults.some(
+    (r) =>
+      r.error ||
+      r.integration?.status === "conflict" ||
+      r.integration?.status === "apply_failed",
+  )
+    ? "failed"
+    : "success";
   const totalTokens = finalResults.reduce((sum, r) => sum + r.tokens, 0);
   const totalCost = finalResults.reduce(
     (sum, r) => sum + r.usage.cost.total,
@@ -489,6 +860,7 @@ export async function dispatchSync(
       progress,
       parentModel: parentModelId,
       overlapWarning: overlapWarning || undefined,
+      dispatchWarning,
     },
     // Aggregate subagent spend so Pi folds it into the parent's
     // session/footer totals. Sync dispatch only — async results arrive via a

package/extension.ts

@@ -22,6 +22,9 @@ import { invalidateHostDepsCache } from "./host.ts";
 import { registerProviderExtensionNotifier } from "./provider-extensions.ts";
 import { recordTreeNavigation, resetLeafTracking } from "./leaf.ts";
 import { closeAllPooledAgents } from "./pool.ts";
+import { reconfigureGlobalConcurrency } from "./concurrency.ts";
+import { reloadDelegateConfig, getMaxConcurrent } from "./config.ts";
+import { warnLegacyDelegateSettingsMoved } from "./settings.ts";
 import {
   activeTicketSummary,
   clearDelegateStatusContext,
@@ -123,6 +126,17 @@ export default function delegateExtension(pi: ExtensionAPI): void {
     prepareArguments: normalizeDelegateArguments,
 
     async execute(_id, params: DelegateArguments, signal, onUpdate, ctx) {
+      // Reload user-edited delegate.json at the start of every execution.
+      // Help, poll, cancel, wait, and invalid calls observe new settings, and
+      // the global concurrency cap is reconfigured so hot-reloaded maxConcurrent
+      // takes effect for subsequent acquisitions. A parse/read error keeps the
+      // previous snapshot and warns instead of falling back to defaults.
+      warnLegacyDelegateSettingsMoved(ctx.cwd, (message) =>
+        ctx.ui.notify(message, "warning"),
+      );
+      reloadDelegateConfig();
+      reconfigureGlobalConcurrency(getMaxConcurrent());
+
       // Prime the UI notice for best-effort provider extensions that load for
       // subagents (host.ts consumes it where the fact is discovered). Every
       // execute re-primes so a stale ctx never sticks.