@tintinweb/pi-subagents 0.6.3 → 0.7.0

package/dist/ui/conversation-viewer.js

@@ -6,7 +6,8 @@
  */
 import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
 import { extractText } from "../context.js";
-import { describeActivity, formatDuration, formatTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.js";
+import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
+import { describeActivity, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.js";
 /** Lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
 const CHROME_LINES = 6;
 const MIN_VIEWPORT = 3;
@@ -101,13 +102,10 @@ export class ConversationViewer {
         const toolUses = this.activity?.toolUses ?? this.record.toolUses;
         if (toolUses > 0)
             headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
-        if (this.activity?.session) {
-            try {
-                const tokens = this.activity.session.getSessionStats().tokens.total;
-                if (tokens > 0)
-                    headerParts.push(formatTokens(tokens));
-            }
-            catch { /* */ }
+        const tokens = getLifetimeTotal(this.activity?.lifetimeUsage);
+        if (tokens > 0) {
+            const percent = getSessionContextPercent(this.activity?.session);
+            headerParts.push(formatSessionTokens(tokens, percent, th, this.record.compactionCount));
         }
         lines.push(row(`${statusIcon} ${th.bold(name)}${modeTag}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${th.fg("dim", headerParts.join(" · "))}`));
         lines.push(hrMid);

package/dist/ui/schedule-menu.d.ts

@@ -0,0 +1,16 @@
+/**
+ * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
+ *
+ * Minimal v1 surface: list scheduled jobs, select one to inspect details +
+ * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
+ * is the canonical creation path), no toggle/cleanup (cancel is enough for
+ * "I scheduled something dumb, get rid of it"). Add management surfaces here
+ * if real demand emerges.
+ */
+import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { SubagentScheduler } from "../schedule.js";
+/**
+ * List scheduled jobs; selecting one opens a cancel-confirm with details.
+ * Returns when the user backs out or after a cancellation.
+ */
+export declare function showSchedulesMenu(ctx: ExtensionCommandContext, scheduler: SubagentScheduler): Promise<void>;

package/dist/ui/schedule-menu.js

@@ -0,0 +1,95 @@
+/**
+ * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
+ *
+ * Minimal v1 surface: list scheduled jobs, select one to inspect details +
+ * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
+ * is the canonical creation path), no toggle/cleanup (cancel is enough for
+ * "I scheduled something dumb, get rid of it"). Add management surfaces here
+ * if real demand emerges.
+ */
+/** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
+function relTime(iso, now = Date.now()) {
+    if (!iso)
+        return "—";
+    const t = new Date(iso).getTime();
+    if (Number.isNaN(t))
+        return "—";
+    const diff = t - now;
+    const abs = Math.abs(diff);
+    const future = diff > 0;
+    if (abs < 60_000)
+        return future ? "in <1m" : "<1m ago";
+    const m = Math.round(abs / 60_000);
+    if (m < 60)
+        return future ? `in ${m}m` : `${m}m ago`;
+    const h = Math.round(abs / 3_600_000);
+    if (h < 24)
+        return future ? `in ${h}h` : `${h}h ago`;
+    const d = Math.round(abs / 86_400_000);
+    return future ? `in ${d}d` : `${d}d ago`;
+}
+/** One-line status icon. */
+function statusIcon(j) {
+    if (!j.enabled)
+        return "✗";
+    if (j.lastStatus === "error")
+        return "!";
+    if (j.lastStatus === "running")
+        return "⋯";
+    return "✓";
+}
+/** Compact selectable row — name, schedule, agent type, next/last run, count. */
+function formatJob(j, scheduler) {
+    const next = scheduler.getNextRun(j.id);
+    return [
+        statusIcon(j),
+        j.name.padEnd(18).slice(0, 18),
+        j.schedule.padEnd(14).slice(0, 14),
+        `[${j.subagent_type}]`,
+        `next ${relTime(next)}`,
+        `last ${relTime(j.lastRun)}`,
+        `runs ${j.runCount}`,
+    ].join("  ");
+}
+/** Multi-line details block for the cancel confirm. */
+function formatDetails(j, scheduler) {
+    const next = scheduler.getNextRun(j.id) ?? "—";
+    return [
+        `name:      ${j.name}`,
+        `schedule:  ${j.schedule} (${j.scheduleType})`,
+        `agent:     ${j.subagent_type}`,
+        `prompt:    ${j.prompt.slice(0, 200)}${j.prompt.length > 200 ? "…" : ""}`,
+        `created:   ${j.createdAt}`,
+        `last run:  ${j.lastRun ?? "—"} (${j.lastStatus ?? "—"})`,
+        `next run:  ${next}`,
+        `runs:      ${j.runCount}`,
+    ].join("\n");
+}
+/**
+ * List scheduled jobs; selecting one opens a cancel-confirm with details.
+ * Returns when the user backs out or after a cancellation.
+ */
+export async function showSchedulesMenu(ctx, scheduler) {
+    if (!scheduler.isActive()) {
+        ctx.ui.notify("Scheduler is not active in this session.", "warning");
+        return;
+    }
+    const jobs = scheduler.list();
+    if (jobs.length === 0) {
+        ctx.ui.notify("No scheduled jobs.", "info");
+        return;
+    }
+    const labels = jobs.map(j => formatJob(j, scheduler));
+    const choice = await ctx.ui.select(`Scheduled jobs (${jobs.length}) — select to cancel`, labels);
+    if (!choice)
+        return;
+    const idx = labels.indexOf(choice);
+    if (idx < 0)
+        return;
+    const job = jobs[idx];
+    const ok = await ctx.ui.confirm(`Cancel "${job.name}"?`, formatDetails(job, scheduler));
+    if (!ok)
+        return;
+    scheduler.removeJob(job.id);
+    ctx.ui.notify(`Cancelled "${job.name}".`, "info");
+}

package/dist/usage.d.ts

@@ -0,0 +1,50 @@
+/** usage.ts — Token usage: shapes, accumulator operators, session-stats readers. */
+/**
+ * Lifetime usage components, accumulated via `message_end` events. Survives
+ * compaction (which replaces session.state.messages and would reset any
+ * stats-derived sum). cacheRead is excluded because each turn's cacheRead is
+ * the cumulative cached prefix re-read on that one call — summing across
+ * turns counts the prefix N times. See issue #38.
+ */
+export type LifetimeUsage = {
+    input: number;
+    output: number;
+    cacheWrite: number;
+};
+/** Sum of lifetime usage components, or 0 if undefined. */
+export declare function getLifetimeTotal(u?: LifetimeUsage): number;
+/** Add a usage delta into a target accumulator (mutates target). */
+export declare function addUsage(into: LifetimeUsage, delta: LifetimeUsage): void;
+/** Minimal shape we read from upstream `getSessionStats()`. */
+export type SessionStatsLike = {
+    tokens: {
+        input: number;
+        output: number;
+        cacheWrite: number;
+    };
+    contextUsage?: {
+        percent: number | null;
+    };
+};
+export type SessionLike = {
+    getSessionStats(): SessionStatsLike;
+};
+/**
+ * Session-scoped token count: input + output + cacheWrite as reported by
+ * upstream `getSessionStats().tokens` for the *current* session window.
+ *
+ * RESETS at compaction — upstream replaces `session.state.messages` and the
+ * stats are derived from that array. For a lifetime total that survives
+ * compaction, use `getLifetimeTotal(lifetimeUsage)` instead, which reads
+ * from an independent accumulator fed by `message_end` events.
+ *
+ * Avoids upstream's `tokens.total` field, which sums per-turn `cacheRead`
+ * and so counts the cumulative cached prefix N times across N turns
+ * (issue #38).
+ */
+export declare function getSessionTokens(session: SessionLike | undefined): number;
+/**
+ * Context-window utilization (0–100), or null when unavailable
+ * (no model contextWindow, or post-compaction before the next response).
+ */
+export declare function getSessionContextPercent(session: SessionLike | undefined): number | null;

package/dist/usage.js

@@ -0,0 +1,49 @@
+/** usage.ts — Token usage: shapes, accumulator operators, session-stats readers. */
+/** Sum of lifetime usage components, or 0 if undefined. */
+export function getLifetimeTotal(u) {
+    return u ? u.input + u.output + u.cacheWrite : 0;
+}
+/** Add a usage delta into a target accumulator (mutates target). */
+export function addUsage(into, delta) {
+    into.input += delta.input;
+    into.output += delta.output;
+    into.cacheWrite += delta.cacheWrite;
+}
+/**
+ * Session-scoped token count: input + output + cacheWrite as reported by
+ * upstream `getSessionStats().tokens` for the *current* session window.
+ *
+ * RESETS at compaction — upstream replaces `session.state.messages` and the
+ * stats are derived from that array. For a lifetime total that survives
+ * compaction, use `getLifetimeTotal(lifetimeUsage)` instead, which reads
+ * from an independent accumulator fed by `message_end` events.
+ *
+ * Avoids upstream's `tokens.total` field, which sums per-turn `cacheRead`
+ * and so counts the cumulative cached prefix N times across N turns
+ * (issue #38).
+ */
+export function getSessionTokens(session) {
+    if (!session)
+        return 0;
+    try {
+        const t = session.getSessionStats().tokens;
+        return t.input + t.output + t.cacheWrite;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Context-window utilization (0–100), or null when unavailable
+ * (no model contextWindow, or post-compaction before the next response).
+ */
+export function getSessionContextPercent(session) {
+    if (!session)
+        return null;
+    try {
+        return session.getSessionStats().contextUsage?.percent ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tintinweb/pi-subagents",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "tintinweb",
   "license": "MIT",
@@ -20,11 +20,15 @@
     "agent",
     "autonomous"
   ],
+  "peerDependencies": {
+    "@mariozechner/pi-ai": ">=0.70.5",
+    "@mariozechner/pi-coding-agent": ">=0.70.5",
+    "@mariozechner/pi-tui": ">=0.70.5"
+  },
   "dependencies": {
-    "@mariozechner/pi-ai": "^0.70.5",
-    "@mariozechner/pi-coding-agent": "^0.70.5",
-    "@mariozechner/pi-tui": "^0.70.5",
-    "@sinclair/typebox": "latest"
+    "@sinclair/typebox": "^0.34.49",
+    "croner": "^10.0.1",
+    "nanoid": "^5.0.0"
   },
   "scripts": {
     "build": "tsc",
@@ -36,7 +40,7 @@
     "lint:fix": "biome check --fix src/ test/"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.5",
+    "@biomejs/biome": "^2.4.14",
     "@types/node": "^25.5.0",
     "typescript": "^6.0.0",
     "vitest": "^4.0.18"

package/src/agent-manager.ts

@@ -11,10 +11,13 @@ import type { Model } from "@mariozechner/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { resumeAgent, runAgent, type ToolActivity } from "./agent-runner.js";
 import type { AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
+import { addUsage } from "./usage.js";
 import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
 
 export type OnAgentComplete = (record: AgentRecord) => void;
 export type OnAgentStart = (record: AgentRecord) => void;
+export type OnAgentCompact = (record: AgentRecord, info: CompactionInfo) => void;
+export type CompactionInfo = { reason: "manual" | "threshold" | "overflow"; tokensBefore: number };
 
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
@@ -35,8 +38,16 @@ interface SpawnOptions {
   inheritContext?: boolean;
   thinkingLevel?: ThinkingLevel;
   isBackground?: boolean;
+  /**
+   * Skip the maxConcurrent queue check for this spawn — start immediately even
+   * if the configured concurrency limit would otherwise queue it. Used by the
+   * scheduler so a fired job can't be deferred past its trigger window.
+   */
+  bypassQueue?: boolean;
   /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
   isolation?: IsolationMode;
+  /** Parent abort signal — when aborted, the subagent is also stopped. */
+  signal?: AbortSignal;
   /** Called on tool start/end with activity info (for streaming progress to UI). */
   onToolActivity?: (activity: ToolActivity) => void;
   /** Called on streaming text deltas from the assistant response. */
@@ -45,6 +56,10 @@ interface SpawnOptions {
   onSessionCreated?: (session: AgentSession) => void;
   /** Called at the end of each agentic turn with the cumulative count. */
   onTurnEnd?: (turnCount: number) => void;
+  /** Called once per assistant message_end with that message's usage delta. */
+  onAssistantUsage?: (usage: { input: number; output: number; cacheWrite: number }) => void;
+  /** Called when the session successfully compacts. */
+  onCompaction?: (info: CompactionInfo) => void;
 }
 
 export class AgentManager {
@@ -52,6 +67,7 @@ export class AgentManager {
   private cleanupInterval: ReturnType<typeof setInterval>;
   private onComplete?: OnAgentComplete;
   private onStart?: OnAgentStart;
+  private onCompact?: OnAgentCompact;
   private maxConcurrent: number;
 
   /** Queue of background agents waiting to start. */
@@ -59,9 +75,15 @@ export class AgentManager {
   /** Number of currently running background agents. */
   private runningBackground = 0;
 
-  constructor(onComplete?: OnAgentComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart?: OnAgentStart) {
+  constructor(
+    onComplete?: OnAgentComplete,
+    maxConcurrent = DEFAULT_MAX_CONCURRENT,
+    onStart?: OnAgentStart,
+    onCompact?: OnAgentCompact,
+  ) {
     this.onComplete = onComplete;
     this.onStart = onStart;
+    this.onCompact = onCompact;
     this.maxConcurrent = maxConcurrent;
     // Cleanup completed agents after 10 minutes (but keep sessions for resume)
     this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
@@ -99,12 +121,14 @@ export class AgentManager {
       toolUses: 0,
       startedAt: Date.now(),
       abortController,
+      lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+      compactionCount: 0,
     };
     this.agents.set(id, record);
 
     const args: SpawnArgs = { pi, ctx, type, prompt, options };
 
-    if (options.isBackground && this.runningBackground >= this.maxConcurrent) {
+    if (options.isBackground && !options.bypassQueue && this.runningBackground >= this.maxConcurrent) {
       // Queue it — will be started when a running agent completes
       this.queue.push({ id, args });
       return id;
@@ -121,6 +145,15 @@ export class AgentManager {
     if (options.isBackground) this.runningBackground++;
     this.onStart?.(record);
 
+    // Wire parent abort signal to stop the subagent when the parent is interrupted
+    let detachParentSignal: (() => void) | undefined;
+    if (options.signal) {
+      const onParentAbort = () => this.abort(id);
+      options.signal.addEventListener("abort", onParentAbort, { once: true });
+      detachParentSignal = () => options.signal!.removeEventListener("abort", onParentAbort);
+    }
+    const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
+
     // Worktree isolation: create a temporary git worktree if requested
     let worktreeCwd: string | undefined;
     let worktreeWarning = "";
@@ -152,6 +185,15 @@ export class AgentManager {
       },
       onTurnEnd: options.onTurnEnd,
       onTextDelta: options.onTextDelta,
+      onAssistantUsage: (usage) => {
+        addUsage(record.lifetimeUsage, usage);
+        options.onAssistantUsage?.(usage);
+      },
+      onCompaction: (info) => {
+        record.compactionCount++;
+        this.onCompact?.(record, info);
+        options.onCompaction?.(info);
+      },
       onSessionCreated: (session) => {
         record.session = session;
         // Flush any steers that arrived before the session was ready
@@ -173,6 +215,8 @@ export class AgentManager {
         record.session = session;
         record.completedAt ??= Date.now();
 
+        detach();
+
         // Final flush of streaming output file
         if (record.outputCleanup) {
           try { record.outputCleanup(); } catch { /* ignore */ }
@@ -204,6 +248,8 @@ export class AgentManager {
         record.error = err instanceof Error ? err.message : String(err);
         record.completedAt ??= Date.now();
 
+        detach();
+
         // Final flush of streaming output file on error
         if (record.outputCleanup) {
           try { record.outputCleanup(); } catch { /* ignore */ }
@@ -278,6 +324,13 @@ export class AgentManager {
         onToolActivity: (activity) => {
           if (activity.type === "end") record.toolUses++;
         },
+        onAssistantUsage: (usage) => {
+          addUsage(record.lifetimeUsage, usage);
+        },
+        onCompaction: (info) => {
+          record.compactionCount++;
+          this.onCompact?.(record, info);
+        },
         signal,
       });
       record.status = "completed";

package/src/agent-runner.ts

@@ -103,6 +103,17 @@ export interface RunOptions {
   onSessionCreated?: (session: AgentSession) => void;
   /** Called at the end of each agentic turn with the cumulative count. */
   onTurnEnd?: (turnCount: number) => void;
+  /**
+   * Called once per assistant message_end with that message's usage delta.
+   * Lets callers maintain a lifetime accumulator that survives compaction
+   * (which replaces session.state.messages and resets stats-derived sums).
+   */
+  onAssistantUsage?: (usage: { input: number; output: number; cacheWrite: number }) => void;
+  /**
+   * Called when the session successfully compacts. `tokensBefore` is upstream's
+   * pre-compaction context size estimate. Aborted compactions don't fire.
+   */
+  onCompaction?: (info: { reason: "manual" | "threshold" | "overflow"; tokensBefore: number }) => void;
 }
 
 export interface RunResult {
@@ -343,6 +354,17 @@ export async function runAgent(
     if (event.type === "tool_execution_end") {
       options.onToolActivity?.({ type: "end", toolName: event.toolName });
     }
+    if (event.type === "message_end" && event.message.role === "assistant") {
+      const u = (event.message as any).usage;
+      if (u) options.onAssistantUsage?.({
+        input: u.input ?? 0,
+        output: u.output ?? 0,
+        cacheWrite: u.cacheWrite ?? 0,
+      });
+    }
+    if (event.type === "compaction_end" && !event.aborted && event.result) {
+      options.onCompaction?.({ reason: event.reason, tokensBefore: event.result.tokensBefore });
+    }
   });
 
   const collector = collectResponseText(session);
@@ -375,15 +397,31 @@ export async function runAgent(
 export async function resumeAgent(
   session: AgentSession,
   prompt: string,
-  options: { onToolActivity?: (activity: ToolActivity) => void; signal?: AbortSignal } = {},
+  options: {
+    onToolActivity?: (activity: ToolActivity) => void;
+    onAssistantUsage?: (usage: { input: number; output: number; cacheWrite: number }) => void;
+    onCompaction?: (info: { reason: "manual" | "threshold" | "overflow"; tokensBefore: number }) => void;
+    signal?: AbortSignal;
+  } = {},
 ): Promise<string> {
   const collector = collectResponseText(session);
   const cleanupAbort = forwardAbortSignal(session, options.signal);
 
-  const unsubToolUse = options.onToolActivity
+  const unsubEvents = (options.onToolActivity || options.onAssistantUsage || options.onCompaction)
     ? session.subscribe((event: AgentSessionEvent) => {
-        if (event.type === "tool_execution_start") options.onToolActivity!({ type: "start", toolName: event.toolName });
-        if (event.type === "tool_execution_end") options.onToolActivity!({ type: "end", toolName: event.toolName });
+        if (event.type === "tool_execution_start") options.onToolActivity?.({ type: "start", toolName: event.toolName });
+        if (event.type === "tool_execution_end") options.onToolActivity?.({ type: "end", toolName: event.toolName });
+        if (event.type === "message_end" && event.message.role === "assistant") {
+          const u = (event.message as any).usage;
+          if (u) options.onAssistantUsage?.({
+            input: u.input ?? 0,
+            output: u.output ?? 0,
+            cacheWrite: u.cacheWrite ?? 0,
+          });
+        }
+        if (event.type === "compaction_end" && !event.aborted && event.result) {
+          options.onCompaction?.({ reason: event.reason, tokensBefore: event.result.tokensBefore });
+        }
       })
     : () => {};
 
@@ -391,7 +429,7 @@ export async function resumeAgent(
     await session.prompt(prompt);
   } finally {
     collector.unsubscribe();
-    unsubToolUse();
+    unsubEvents();
     cleanupAbort();
   }