billion-context-pi 0.1.34 → 0.1.35

package/dist/config.d.ts

@@ -22,6 +22,12 @@ export interface AdapterConfig {
      *  section. Default: true. Set `delegate: false` (adapter config or
      *  ~/.pi/acp.json) to skip registering them. */
     delegate?: boolean;
+    /** How to display delegate usage in session totals.
+     *  "merged" — delegate usage is added to main session totals (Pi default).
+     *  "separate" — delegate usage is tracked separately, displayed in
+     *               system notifications (excluded from main session totals).
+     *  Default: "separate" */
+    displayUsage?: "merged" | "separate";
     /** Default timeout in seconds injected into the bash tool when the model
      *  omits `timeout`. Pi has NO built-in default, so without this a command
      *  that the model forgets to time out can hang for thousands of seconds.

package/dist/delegate-events.d.ts

@@ -1,3 +1,27 @@
+export interface Usage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cacheWrite1h?: number;
+    reasoning?: number;
+    totalTokens: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}
+export interface UsageUpdateEvent {
+    kind: "usage-update";
+    usage: Usage;
+}
+export interface AgentSettledEvent {
+    kind: "agent-settled";
+}
+export declare function handleMessageEnd(event: Record<string, unknown>): UsageUpdateEvent | null;
 export interface ToolStartEvent {
     kind: "tool-start";
     toolName: string;
@@ -25,7 +49,7 @@ export interface ThinkingDeltaEvent {
     kind: "thinking-delta";
     delta: string;
 }
-export type ParsedEvent = ToolStartEvent | ToolUpdateEvent | ToolEndEvent | ReplyDeltaEvent | ReplyCompleteEvent | ThinkingDeltaEvent | ThinkingEndEvent | RetryStartEvent | RetryEndEvent;
+export type ParsedEvent = ToolStartEvent | ToolUpdateEvent | ToolEndEvent | ReplyDeltaEvent | ReplyCompleteEvent | ThinkingDeltaEvent | ThinkingEndEvent | RetryStartEvent | RetryEndEvent | UsageUpdateEvent | AgentSettledEvent;
 export interface ThinkingEndEvent {
     kind: "thinking-end";
 }
@@ -37,10 +61,12 @@ export interface ThinkingEndEvent {
 export declare class ThinkingCollector {
     private readonly showThinking;
     private buf;
+    private usage;
     constructor(showThinking: boolean);
     push(delta: string): void;
-    /** Return the segment line to write ("" when empty or disabled), resetting. */
+    process(ev: ParsedEvent): void;
     flush(): string;
+    getUsage(): Usage | undefined;
 }
 export interface RetryStartEvent {
     kind: "retry-start";

package/dist/delegate-tool.d.ts

@@ -1,7 +1,44 @@
-import { type SpawnOptions } from "node:child_process";
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import { Type, type Static } from "typebox";
-import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Usage } from "./delegate-events.js";
 export declare function delegateSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): SpawnOptions;
+type RunStatus = "running" | "completed" | "failed" | "cancelled";
+interface DelegateRun {
+    runId: string;
+    agent: string;
+    task: string;
+    cwd: string;
+    startedAt: number;
+    finishedAt?: number;
+    status: RunStatus;
+    exitCode?: number | null;
+    child?: ChildProcess;
+    result?: {
+        code: number | null;
+        file: string;
+        body: string;
+    };
+    consumed?: boolean;
+    /** True once the close handler injected the result as a system
+     *  notification (sendUserMessage succeeded). Lets a later wait() avoid
+     *  re-delivering the same payload. */
+    injected?: boolean;
+    /** Watchdog reason string when the run was force-terminated ("no output for
+     *  5m", "30m limit"); surfaced in completion headers as "(timed out: ...)". */
+    timedOut?: string;
+    waiter?: () => void;
+    /** Accumulated LLM usage from the delegate (from message_end events). */
+    usage?: Usage;
+    /** True once a wait/cancel tool has returned usage — prevents double-count. */
+    usageReported?: boolean;
+    /** True once agent_settled fired; a watchdog kill after this is stuck teardown, not a timeout. */
+    agentSettled?: boolean;
+}
+export declare function addDelegateUsage(u: Usage): void;
+export declare function getDelegateUsage(): Usage | undefined;
+export declare function resetDelegateUsage(): void;
+export declare function setDelegateDisplayUsage(mode: "merged" | "separate"): void;
 /** Snapshot of currently-running delegate runs, for the TUI status widget. */
 export declare function runningRunsSnapshot(): {
     runId: string;
@@ -36,6 +73,8 @@ export interface EventApplier {
  *  never lost from the file. */
 export declare function makeEventApplier(opts: {
     showThinking: boolean;
+    onUsage?: (usage: Usage) => void;
+    onSettled?: () => void;
 }, writers: EventApplierWriters): EventApplier;
 declare const DelegateParams: Type.TObject<{
     agent: Type.TString;
@@ -53,6 +92,7 @@ declare const WaitParams: Type.TObject<{
     runId: Type.TString;
     timeout: Type.TOptional<Type.TInteger>;
 }>;
+export declare function accumulateUsage(a: Usage | undefined, b: Usage): Usage;
 export declare function makeDelegateTool(pi: ExtensionAPI): ToolDefinition<typeof DelegateParams>;
 /** If the delegate already delivered its result via a system notification
  *  (the close handler injected before this wait was called), return a short
@@ -66,6 +106,25 @@ export declare function injectedWaitMessage(run: {
         file: string;
     };
 }, runId: string, remainingLine: string): string | null;
+/** Build usage-aware return payload. Sets usageReported=true so subsequent
+ *  waits on the same run skip usage. */
+export declare function buildWaitResult(run: DelegateRun, content: string, mode?: "merged" | "separate", contentType?: "text"): {
+    details: undefined;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    usage?: AgentToolResult<unknown>["usage"];
+};
+/** Build usage-aware result for cancel tool. */
+export declare function buildCancelResult(run: DelegateRun, content: string, mode?: "merged" | "separate"): {
+    details: undefined;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    usage?: AgentToolResult<unknown>["usage"];
+};
 export declare function makeDelegateWaitTool(_pi: ExtensionAPI): ToolDefinition<typeof WaitParams>;
 export declare function makeDelegateCancelTool(_pi: ExtensionAPI): ToolDefinition<typeof CancelParams>;
 export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, ctx: ExtensionContext): Promise<{
@@ -74,4 +133,5 @@ export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, c
     isAsync: boolean;
     useJsonStream: boolean;
 }>;
+export declare function injectResult(pi: ExtensionAPI, agent: string, runId: string, task: string, code: number | null, file: string, timedOut?: string, usage?: Usage, mode?: "merged" | "separate", usageAlreadyReported?: boolean): boolean;
 export {};

package/dist/delegate-watchdog.d.ts

@@ -18,6 +18,17 @@ export interface WatchdogHandle {
     poke(): void;
     /** Stop all timers (call on finalize). */
     dispose(): void;
+    /**
+     * agent_settled has been received: the agent's full flow (prompt + continue
+     * loop + retries) is over and pi emits this exactly once in the finally of
+     * _runAgentPrompt, after which the process should exit within milliseconds.
+     * If it is still alive after graceMs, the process is stuck in teardown
+     * (e.g. a provider call not returning) — kill it via killByWatchdog. graceMs
+     * is symmetric with EOF_GRACE_MS (10s): normal exits are millisecond-level,
+     * so 10s only hits genuinely hung processes. Idempotent (no-op when already
+     * settled or a grace timer is pending); dispose() clears the timer.
+     */
+    settledGrace(graceMs: number, _killGraceMs: number, reason: string): void;
 }
 /**
  * Guarantees a hung child process gets killed. A stuck child holds its stdout

package/dist/footer-status.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+/** Mirrors pi's footer.js formatTokens: lowercase k/M, thresholds <1000/<10000/<1e6/<1e7. */
+export declare function formatCompactTokens(count: number): string;
+export declare function initFooterStatus(ctx: ExtensionContext): void;
+/** Refresh the footer delegate-usage line. Cheap: reads the accumulated total
+ *  and no-ops when the rendered text is unchanged (called on a 500ms tick). */
+export declare function updateFooterStatus(): void;
+export declare function disposeFooterStatus(): void;