@bermudi/pi-delegate 0.1.10 → 0.1.12

package/extension.ts

@@ -18,12 +18,13 @@ import {
 } from "./dispatch.ts";
 import { renderDelegateCall, renderDelegateResult } from "./render-result.ts";
 import { hostCompatError } from "./host-compat.ts";
-import {
-  invalidateHostDepsCache,
-  registerProviderExtensionNotifier,
-} from "./host.ts";
+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,
@@ -125,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.

package/format.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { renderOutputForLLM } from "./spill.ts";
+import { getOutputSpillThreshold, getOutputSpillTail } from "./config.ts";
 import type {
   ResolvedTask,
   TaskProgress,
@@ -355,7 +356,13 @@ function isResumableSessionFile(sessionFile: string): boolean {
  * notice instead of a retry hint — so the parent model is told to re-dispatch
  * fresh rather than left to fabricate a path or chase a dead resume.
  */
-export function formatFailedTask(r: TaskResult, cwd?: string): string[] {
+export function formatFailedTask(
+  r: TaskResult,
+  cwd?: string,
+  /** Dispatch-scoped snapshot for output-spill bounds; falls back to live
+   *  config when unset (direct callers, legacy tests). */
+  config?: import("./config.ts").DelegateConfig,
+): string[] {
   const parts: string[] = [];
   const isAbort = r.error === "Aborted";
   // Empty string is falsy but not nullish — `||` covers both undefined and "".
@@ -366,8 +373,16 @@ export function formatFailedTask(r: TaskResult, cwd?: string): string[] {
   parts.push(`[${isAbort ? "ABORTED" : "FAILED"}: ${failParts.join(" · ")}]`);
 
   // Surface partial assistant output even when the task did not complete.
+  // Pass the dispatch-scoped spill bounds so a mid-task config change cannot
+  // widen (or narrow) the partial output the parent sees — the bounds captured
+  // when the task started are the ones the caller committed to.
   if (r.output && r.output !== "(no output)") {
-    parts.push(renderOutputForLLM(r.output, r.agent));
+    parts.push(
+      renderOutputForLLM(r.output, r.agent, {
+        thresholdChars: getOutputSpillThreshold(config),
+        tailChars: getOutputSpillTail(config),
+      }),
+    );
   }
 
   if (r.sessionFile && isResumableSessionFile(r.sessionFile)) {
@@ -414,6 +429,8 @@ export function formatFailedTask(r: TaskResult, cwd?: string): string[] {
 export function formatCompletedTask(
   task: ResolvedTask,
   result: TaskResult,
+  /** Dispatch-scoped snapshot for output-spill bounds. */
+  config?: import("./config.ts").DelegateConfig,
 ): string[] {
   const parts: string[] = [];
   // `|| task.sessionAction` covers action-only tasks (close/list/...) where prompt is
@@ -425,7 +442,7 @@ export function formatCompletedTask(
     for (const w of task.warnings) parts.push(`[WARNING: ${w}]`);
   }
   if (result.error) {
-    parts.push(...formatFailedTask(result, task.cwd));
+    parts.push(...formatFailedTask(result, task.cwd, config));
   } else {
     const meta = [
       `OK | ${fmtDuration(result.durationMs)} | ${fmtTokens(result.tokens)} tokens`,
@@ -434,15 +451,44 @@ export function formatCompletedTask(
     const touched = relativeTouchedSummary(result.touchedFiles, task.cwd);
     if (touched) meta.push(`touched (best-effort): ${touched}`);
     parts.push(
-      `[${meta.join(" · ")}]\n\n${renderOutputForLLM(result.output, result.agent)}`,
+      `[${meta.join(" · ")}]\n\n${renderOutputForLLM(
+        result.output,
+        result.agent,
+        {
+          thresholdChars: getOutputSpillThreshold(config),
+          tailChars: getOutputSpillTail(config),
+        },
+      )}`,
+    );
+  }
+  if (result.integration) {
+    const integration = result.integration;
+    parts.push(
+      `[INTEGRATION: ${integration.status} · proposed ${integration.proposedFiles.length} file(s) · applied ${integration.appliedFiles.length} file(s)]`,
     );
+    if (integration.baselineRef)
+      parts.push(`baseline ref: ${integration.baselineRef}`);
+    if (integration.proposalRef)
+      parts.push(`proposal ref: ${integration.proposalRef}`);
+    if (integration.patchPath)
+      parts.push(`full patch: ${integration.patchPath}`);
+    if (integration.worktreePath)
+      parts.push(`conflict worktree: ${integration.worktreePath}`);
+    for (const conflict of integration.conflicts ?? []) {
+      parts.push(`conflict: ${conflict.path}: ${conflict.reason}`);
+    }
+    if (integration.status === "applied_unverified") {
+      parts.push(
+        'Changes were applied but not verified. Suggested next call: delegate({ tasks: [{ agent: "reviewer", workspace: "scratch", prompt: "Review the applied isolated changes and run the relevant tests." }] })',
+      );
+    }
   }
   return parts;
 }
 
 // ── Shared live-progress row helpers ───────────────────────────────────────
 // These dedupe the per-task computations the LLM-facing poll view
-// (tickets.handlePoll) and the TUI branches (render-branches) both need. Each is
+// (ticket-format.ts) and the TUI branches (render-branches) both need. Each is
 // pure over TaskProgress/TaskResult, so it tests without a renderer.
 
 /** The in-flight tool activity (no result yet), or null — the "current thing
@@ -499,7 +545,7 @@ export function waitingLabel(runningCount: number, cap: number): string {
 
 /** Touched-files summary relative to cwd ("src/a.ts, src/b.ts"), or null when
  *  none resolve under cwd. Was byte-for-byte duplicated in formatCompletedTask
- *  and tickets.handlePoll. */
+ *  and ticket-format.ts. */
 export function relativeTouchedSummary(
   files: string[],
   cwd: string,

package/host-cache.ts

@@ -0,0 +1,70 @@
+/**
+ * A generation-guarded async memo.
+ *
+ * Host deps are expensive (`ResourceLoader.reload()` is ~1.2s cold) and are
+ * shared across the parallel tasks of a single delegate dispatch, then thrown
+ * away so the next dispatch observes edits to auth, models, settings, and
+ * context files. That gives three requirements the plain
+ * `Map<string, Promise<T>>` pattern does not meet:
+ *
+ *   - **in-flight dedup** — concurrent tasks with the same key must await one
+ *     build, not start N reloads;
+ *   - **generation guard** — an invalidation during a build must not let that
+ *     older build install its now-stale value, nor let it delete the in-flight
+ *     marker a newer build has since installed for the same key;
+ *   - **one invalidation path** — every reset goes through `invalidate()`.
+ *     Before this was factored out, two test-only helpers cleared the maps
+ *     directly without bumping the generation, leaving exactly the stale-write
+ *     window the guard exists to close.
+ */
+export class GenerationCache<T> {
+  private entries = new Map<string, T>();
+  private inflight = new Map<string, Promise<T>>();
+  private generation = 0;
+
+  /**
+   * Return the cached value for `key`, joining an in-flight build or starting
+   * one. When `cacheable` is false the value is built and returned without ever
+   * being stored or shared.
+   */
+  async resolve(
+    key: string,
+    cacheable: boolean,
+    build: () => Promise<T>,
+  ): Promise<T> {
+    if (!cacheable) return build();
+
+    const cached = this.entries.get(key);
+    if (cached !== undefined) return cached;
+    const pending = this.inflight.get(key);
+    if (pending) return pending;
+
+    const generation = this.generation;
+    const promise = build().then((value) => {
+      // A build that outlived its generation is stale by definition; return it
+      // to its own caller but never publish it.
+      if (this.generation === generation) this.entries.set(key, value);
+      return value;
+    });
+    this.inflight.set(key, promise);
+    try {
+      return await promise;
+    } finally {
+      // An invalidation can let a newer generation install its own in-flight
+      // build for this key. Never let the older promise delete that marker.
+      if (this.inflight.get(key) === promise) this.inflight.delete(key);
+    }
+  }
+
+  /** Drop every cached and in-flight value, invalidating builds already running. */
+  invalidate(): void {
+    this.generation++;
+    this.entries.clear();
+    this.inflight.clear();
+  }
+
+  /** Cached values only — in-flight builds are not observable here. */
+  values(): Iterable<T> {
+    return this.entries.values();
+  }
+}