@bermudi/pi-delegate 0.1.2 → 0.1.3

package/tickets.ts

@@ -24,7 +24,8 @@ import {
 import { isCrossLeafTicket } from "./leaf.ts";
 import { renderOutputForPoll } from "./spill.ts";
 import { scheduleDeadline } from "./timer.ts";
-import { emptyUsage } from "./usage.ts";
+import { aggregateTaskResults, emptyUsage } from "./usage.ts";
+import { recordCall } from "./telemetry.ts";
 import type {
   AsyncTicket,
   DelegateDetails,
@@ -125,6 +126,19 @@ export function cancelTicketForShutdown(ticket: AsyncTicket): void {
   ticket.completedAt = Date.now();
   syncTicketBusyIndex(ticket);
   settleTicketWaiters(ticket);
+  if (ticket.callRecord) {
+    const { totalTokens, totalCost } = aggregateTaskResults(ticket.results);
+    recordCall(
+      {
+        ...ticket.callRecord,
+        status: "cancelled",
+        wall_ms: ticket.completedAt - (ticket.callStartedAt ?? ticket.created),
+        total_tokens: totalTokens,
+        total_cost: totalCost,
+      },
+      ticket.telemetryGeneration,
+    );
+  }
 }
 
 /** Request cooperative cancellation of a live ticket: abort the workers and
@@ -325,13 +339,25 @@ function buildWaitTimeoutResult(
   ticket: AsyncTicket,
   timeoutMs: number,
 ): AgentToolResult<DelegateDetails> {
-  const details = buildWaitDetails(ticket);
+  // A timeout must not be an information cliff. Reuse the same rich snapshot
+  // as poll so the caller can see activity and consume any completed outputs
+  // without making a second tool call.
+  const snapshot = handlePoll({ ticket: ticket.id }, {} as ExtensionContext);
+  const snapshotText = snapshot.content
+    .filter((item) => item.type === "text")
+    .map((item) => item.text)
+    .join("\n");
   const base = `Ticket ${ticket.id} still ${ticket.status} after ${fmtDuration(timeoutMs)} · wait timed out (ticket continues in background)`;
-  const text =
-    base + (details.overlapWarning ? `\n\n${details.overlapWarning}` : "");
+  const guidance =
+    "If you need the final result in this turn, call wait once with timeoutMs omitted; do not poll after a timeout. Otherwise stop calling ticket controls and let the final result auto-deliver.";
   return {
-    content: [{ type: "text", text }],
-    details,
+    content: [
+      {
+        type: "text",
+        text: `${base}\n\n${snapshotText}\n\n${guidance}`,
+      },
+    ],
+    details: snapshot.details,
   };
 }
 
@@ -693,12 +719,10 @@ export function handlePoll(
     const header = headerParts.join(" · ");
     const guidance =
       ticket.status === "cancelling"
-        ? "Cancellation requested. Active subagents are aborting and returning partial results; poll again for the final status."
+        ? "Cancellation requested. Active subagents are aborting and returning partial results. Wait without timeoutMs for final status; do not repeatedly poll."
         : settledCount === totalCount
           ? ""
-          : settledCount > 0
-            ? "Tasks are progressing. Do other work while remaining tasks finish — results will be delivered automatically when all complete."
-            : "Tasks are still running. Do other work while you wait — polling again immediately will not speed them up. Results are delivered automatically when all tasks complete.";
+          : "If you need the final result in this turn, call wait once with timeoutMs omitted. Otherwise stop calling ticket controls and let the final result auto-deliver after this turn; repeated polling will not speed it up.";
 
     return {
       content: [

package/types.ts

@@ -12,6 +12,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import type { Static } from "@sinclair/typebox";
 import type { delegateArgumentsSchema } from "./schema.ts";
+import type { CallRecord } from "./telemetry.ts";
 
 export interface AgentConfig {
   name: string;
@@ -86,6 +87,16 @@ export interface AsyncTicket {
   spawnLeafId?: string | null;
   /** Active blocking waiters. Resolved by terminal delivery or timeout/abort. */
   waiters?: TicketWaiter[];
+  /** Telemetry call span id attached to this async ticket. */
+  callId?: string;
+  /** Telemetry call span start timestamp for accurate wall-time on cancellation. */
+  callStartedAt?: number;
+  /** Snapshot of the call row at spawn, used to write the cancelled/settled row. */
+  callRecord?: CallRecord;
+  /** Runtime generation for rejecting shutdown writes from stale tickets. */
+  telemetryGeneration?: number;
+  /** Resolves after every async worker has settled, including shutdown aborts. */
+  completion?: Promise<void>;
 }
 
 /** Live parent settings captured when a delegate call starts. The built-in
@@ -245,6 +256,12 @@ export interface TaskRunEnv {
   onProgress: (p: TaskProgress, u: AgentProgressUpdate) => void;
   /** Called after every TaskProgress mutation (early-returns, completion). Sync uses this to fire onUpdate. */
   onStatusChange?: () => void;
+  /** Telemetry call id for this dispatch. undefined when telemetry is disabled or not started. */
+  telemetryCallId?: string;
+  /** Runtime generation for rejecting writes from a stale shutdown worker. */
+  telemetryGeneration?: number;
+  /** Whether this task is part of an async ticket. */
+  async?: boolean;
 }
 
 /** Structural subset of Pi's `ExtensionContext` used by delegate's

package/usage.ts

@@ -1,5 +1,6 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import type { Usage } from "@earendil-works/pi-ai";
+import type { TaskResult } from "./types.ts";
 
 /** Snapshot of the cumulative session usage fields we read for delta accounting. */
 export interface SessionUsageSnapshot {
@@ -119,3 +120,21 @@ export function sumUsage(usages: readonly (Usage | undefined)[]): Usage {
     emptyUsage(),
   );
 }
+
+/** Aggregate the completed result rows used by async call telemetry. */
+export function aggregateTaskResults(
+  results: readonly (TaskResult | undefined)[],
+): { totalTokens: number; totalCost: number } {
+  return results
+    .filter(
+      (result): result is TaskResult =>
+        result !== undefined && "touchedFiles" in result,
+    )
+    .reduce(
+      (total, result) => ({
+        totalTokens: total.totalTokens + result.tokens,
+        totalCost: total.totalCost + (result.usage?.cost?.total ?? 0),
+      }),
+      { totalTokens: 0, totalCost: 0 },
+    );
+}