@bermudi/pi-delegate 0.1.10 → 0.1.11

package/delegate.ts

@@ -5,7 +5,6 @@ export type {
   SessionAction,
   WorkspaceMode,
   TicketAction,
-  DelegateAction,
   DelegateArguments,
   TaskDef,
   AsyncTicket,
@@ -72,9 +71,10 @@ export {
   notifyWaiters,
   deliverTicketResults,
   resolveFinalTicketStatus,
+  settleTicket,
   formatCompletedTicket,
 } from "./tickets.ts";
-export type { TicketDelivery } from "./tickets.ts";
+export type { TicketDelivery, SettleTicketOptions } from "./tickets.ts";
 export {
   recordTreeNavigation,
   getCurrentLeafId,
@@ -98,6 +98,7 @@ export {
 export type { ActiveTicketSummary } from "./status.ts";
 export { getHostDeps, invalidateHostDepsCache } from "./host.ts";
 export type { HostDeps, HostDepsOptions } from "./host.ts";
+export { registerProviderExtensionNotifier } from "./provider-extensions.ts";
 export {
   aggregateTaskResults,
   emptyUsage,

package/dispatch.ts

@@ -6,7 +6,7 @@ import {
   deliverTicketResults,
   sweepTickets,
   resolveFinalTicketStatus,
-  syncTicketBusyIndex,
+  settleTicket,
   notifyWaiters,
 } from "./tickets.ts";
 import { getConcurrencyLimit, getMaxAsyncTickets } from "./config.ts";
@@ -319,6 +319,16 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
   // Worker must store the TaskResult back into ticket.results, since
   // formatCompletedTicket/handlePoll read from there. Without the write,
   // completed async tasks would be reported as PENDING.
+  //
+  // Worker settlement is complete before these live-runtime observers run.
+  // In particular, result delivery is allowed to fail without re-entering the
+  // worker completion path; the terminal ticket remains available to poll.
+  const finishLiveSettlement = (t: AsyncTicket): void => {
+    syncDelegateStatus();
+    settleAsyncCall(t, callSpan);
+    finishTicketDelivery(pi, t);
+  };
+
   const completion = mapConcurrentByModel(
     resolved,
     (t) => getModelKey(t.model),
@@ -346,21 +356,16 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
       // NOT be marked "done" — that would mask incomplete work as
       // complete. resolveFinalTicketStatus returns "failed" for that
       // case and for any case with a failed task.
-      if (ticket.status === "running") {
-        ticket.status = resolveFinalTicketStatus(ticket);
-        ticket.completedAt = Date.now();
-        syncTicketBusyIndex(ticket);
-      } else if (ticket.status === "cancelling") {
-        // Cancellation was requested while tasks were still settling. The
-        // per-task results record what actually happened; the ticket state
-        // reports that the batch was aborted by the caller.
-        ticket.status = "cancelled";
-        ticket.completedAt = Date.now();
-        syncTicketBusyIndex(ticket);
-      }
-      syncDelegateStatus();
-      settleAsyncCall(ticket, callSpan);
-      finishTicketDelivery(pi, ticket);
+      // A "cancelling" ticket that outlived its workers settles as
+      // "cancelled": the per-task results record what actually happened;
+      // the ticket state reports that the batch was aborted by the caller.
+      settleTicket(ticket, {
+        status:
+          ticket.status === "running"
+            ? resolveFinalTicketStatus(ticket)
+            : "cancelled",
+      });
+      finishLiveSettlement(ticket);
     })
     .catch((err) => {
       // Defense-in-depth — should not happen if individual tasks catch properly.
@@ -370,17 +375,11 @@ export function dispatchAsync(input: AsyncDispatchInput): DelegateToolResult {
         settleAsyncCall(ticket, callSpan);
         return;
       }
-      if (ticket.status === "cancelling") {
-        ticket.status = "cancelled";
-      } else if (ticket.status === "running") {
-        ticket.status = "failed";
-      }
-      ticket.error = err instanceof Error ? err.message : String(err);
-      ticket.completedAt = Date.now();
-      syncTicketBusyIndex(ticket);
-      syncDelegateStatus();
-      settleAsyncCall(ticket, callSpan);
-      finishTicketDelivery(pi, ticket);
+      settleTicket(ticket, {
+        status: ticket.status === "cancelling" ? "cancelled" : "failed",
+        error: err instanceof Error ? err.message : String(err),
+      });
+      finishLiveSettlement(ticket);
     });
   ticket.completion = completion;
 

package/extension.ts

@@ -18,10 +18,8 @@ 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 {

package/format.ts

@@ -442,7 +442,7 @@ export function formatCompletedTask(
 
 // ── 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 +499,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();
+  }
+}