@tintinweb/pi-subagents 0.6.3 → 0.7.1

package/dist/types.d.ts

@@ -3,6 +3,7 @@
  */
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { LifetimeUsage } from "./usage.js";
 export type { ThinkingLevel };
 /** Agent type: any string name (built-in defaults or user-defined). */
 export type SubagentType = string;
@@ -82,6 +83,14 @@ export interface AgentRecord {
     outputFile?: string;
     /** Cleanup function for the output file stream subscription. */
     outputCleanup?: () => void;
+    /**
+     * Lifetime usage breakdown, accumulated via `message_end` events. Survives
+     * compaction. Total = input + output + cacheWrite (cacheRead deliberately
+     * excluded — see issue #38). Initialized to zeros at spawn.
+     */
+    lifetimeUsage: LifetimeUsage;
+    /** Number of times this agent's session has compacted. Initialized to 0 at spawn. */
+    compactionCount: number;
 }
 /** Details attached to custom notification messages for visual rendering. */
 export interface NotificationDetails {
@@ -104,3 +113,40 @@ export interface EnvInfo {
     branch: string;
     platform: string;
 }
+/**
+ * A subagent spawn registered to fire on a schedule.
+ *
+ * Stored at `<cwd>/.pi/subagent-schedules/<sessionId>.json`. Session-scoped:
+ * survives `/resume` but resets on `/new`, mirroring pi-chonky-tasks.
+ */
+export interface ScheduledSubagent {
+    id: string;
+    /** Unique within store. Defaults to `description`. */
+    name: string;
+    description: string;
+    /** Raw user input — cron expr | "+10m" | ISO | "5m". */
+    schedule: string;
+    scheduleType: "cron" | "once" | "interval";
+    /** Computed at create time for interval/once. */
+    intervalMs?: number;
+    subagent_type: SubagentType;
+    prompt: string;
+    model?: string;
+    thinking?: ThinkingLevel;
+    max_turns?: number;
+    isolated?: boolean;
+    isolation?: IsolationMode;
+    enabled: boolean;
+    /** ISO timestamp. */
+    createdAt: string;
+    lastRun?: string;
+    lastStatus?: "success" | "error" | "running";
+    /** Refreshed on every fire and on store load. */
+    nextRun?: string;
+    runCount: number;
+}
+export interface ScheduleStoreData {
+    /** For future migrations. */
+    version: 1;
+    jobs: ScheduledSubagent[];
+}

package/dist/ui/agent-widget.d.ts

@@ -6,6 +6,7 @@
  */
 import type { AgentManager } from "../agent-manager.js";
 import type { SubagentType } from "../types.js";
+import { type LifetimeUsage, type SessionLike } from "../usage.js";
 /** Braille spinner frames for animated running indicator. */
 export declare const SPINNER: string[];
 /** Statuses that indicate an error/non-success outcome (used for linger behavior and icon rendering). */
@@ -27,19 +28,14 @@ export type UICtx = {
 export interface AgentActivity {
     activeTools: Map<string, string>;
     toolUses: number;
-    tokens: string;
     responseText: string;
-    session?: {
-        getSessionStats(): {
-            tokens: {
-                total: number;
-            };
-        };
-    };
+    session?: SessionLike;
     /** Current turn count. */
     turnCount: number;
     /** Effective max turns for this agent (undefined = unlimited). */
     maxTurns?: number;
+    /** Lifetime usage breakdown — see LifetimeUsage docs. */
+    lifetimeUsage: LifetimeUsage;
 }
 /** Metadata attached to Agent tool results for custom rendering. */
 export interface AgentDetails {
@@ -67,6 +63,17 @@ export interface AgentDetails {
 }
 /** Format a token count compactly: "33.8k token", "1.2M token". */
 export declare function formatTokens(count: number): string;
+/**
+ * Token count with optional context-fill % and compaction-count annotations.
+ * Thresholds for percent: <70% dim, 70–85% warning, ≥85% error.
+ * Compaction count rendered as `↻N` in dim.
+ *
+ *   "12.3k token"               — no annotations
+ *   "12.3k token (45%)"         — percent only
+ *   "12.3k token (↻2)"          — compactions only (e.g. right after compact)
+ *   "12.3k token (45% · ↻2)"    — both
+ */
+export declare function formatSessionTokens(tokens: number, percent: number | null, theme: Theme, compactions?: number): string;
 /** Format turn count with optional max limit: "⟳5≤30" or "⟳5". */
 export declare function formatTurns(turnCount: number, maxTurns?: number | null): string;
 /** Format milliseconds as human-readable duration. */

package/dist/ui/agent-widget.js

@@ -6,6 +6,7 @@
  */
 import { truncateToWidth } from "@mariozechner/pi-tui";
 import { getConfig } from "../agent-types.js";
+import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 // ---- Constants ----
 /** Maximum number of rendered lines before overflow collapse kicks in. */
 const MAX_WIDGET_LINES = 12;
@@ -32,6 +33,30 @@ export function formatTokens(count) {
         return `${(count / 1_000).toFixed(1)}k token`;
     return `${count} token`;
 }
+/**
+ * Token count with optional context-fill % and compaction-count annotations.
+ * Thresholds for percent: <70% dim, 70–85% warning, ≥85% error.
+ * Compaction count rendered as `↻N` in dim.
+ *
+ *   "12.3k token"               — no annotations
+ *   "12.3k token (45%)"         — percent only
+ *   "12.3k token (↻2)"          — compactions only (e.g. right after compact)
+ *   "12.3k token (45% · ↻2)"    — both
+ */
+export function formatSessionTokens(tokens, percent, theme, compactions = 0) {
+    const tokenStr = formatTokens(tokens);
+    const annot = [];
+    if (percent !== null) {
+        const color = percent >= 85 ? "error" : percent >= 70 ? "warning" : "dim";
+        annot.push(theme.fg(color, `${Math.round(percent)}%`));
+    }
+    if (compactions > 0) {
+        annot.push(theme.fg("dim", `↻${compactions}`));
+    }
+    if (annot.length === 0)
+        return tokenStr;
+    return `${tokenStr} (${annot.join(" · ")})`;
+}
 /** Format turn count with optional max limit: "⟳5≤30" or "⟳5". */
 export function formatTurns(turnCount, maxTurns) {
     return maxTurns != null ? `⟳${turnCount}≤${maxTurns}` : `⟳${turnCount}`;
@@ -222,13 +247,9 @@ export class AgentWidget {
             const elapsed = formatMs(Date.now() - a.startedAt);
             const bg = this.agentActivity.get(a.id);
             const toolUses = bg?.toolUses ?? a.toolUses;
-            let tokenText = "";
-            if (bg?.session) {
-                try {
-                    tokenText = formatTokens(bg.session.getSessionStats().tokens.total);
-                }
-                catch { /* */ }
-            }
+            const tokens = getLifetimeTotal(bg?.lifetimeUsage);
+            const contextPercent = getSessionContextPercent(bg?.session);
+            const tokenText = tokens > 0 ? formatSessionTokens(tokens, contextPercent, theme, a.compactionCount) : "";
             const parts = [];
             if (bg)
                 parts.push(formatTurns(bg.turnCount, bg.maxTurns));

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.1",
   "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,12 +75,19 @@ 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);
+    this.cleanupInterval.unref();
   }
 
   /** Update the max concurrent background agents limit. */
@@ -99,45 +122,63 @@ 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;
     }
 
-    this.startAgent(id, record, args);
+    // startAgent can throw (e.g. strict worktree-isolation failure) — clean
+    // up the record so callers don't see an orphan in `listAgents()`.
+    try {
+      this.startAgent(id, record, args);
+    } catch (err) {
+      this.agents.delete(id);
+      throw err;
+    }
     return id;
   }
 
   /** Actually start an agent (called immediately or from queue drain). */
   private startAgent(id: string, record: AgentRecord, { pi, ctx, type, prompt, options }: SpawnArgs) {
-    record.status = "running";
-    record.startedAt = Date.now();
-    if (options.isBackground) this.runningBackground++;
-    this.onStart?.(record);
-
-    // Worktree isolation: create a temporary git worktree if requested
+    // Worktree isolation: try to create a temporary git worktree. Strict —
+    // fail loud if not possible (no silent fallback to main tree). Done
+    // BEFORE state mutation so a throw doesn't leave the record half-running.
     let worktreeCwd: string | undefined;
-    let worktreeWarning = "";
     if (options.isolation === "worktree") {
       const wt = createWorktree(ctx.cwd, id);
-      if (wt) {
-        record.worktree = wt;
-        worktreeCwd = wt.path;
-      } else {
-        worktreeWarning = "\n\n[WARNING: Worktree isolation was requested but failed (not a git repo, or no commits yet). Running in the main working directory instead.]";
+      if (!wt) {
+        throw new Error(
+          'Cannot run with isolation: "worktree" — not a git repo, no commits yet, or `git worktree add` failed. ' +
+          'Initialize git and commit at least once, or omit `isolation`.',
+        );
       }
+      record.worktree = wt;
+      worktreeCwd = wt.path;
     }
 
-    // Prepend worktree warning to prompt if isolation failed
-    const effectivePrompt = worktreeWarning ? worktreeWarning + "\n\n" + prompt : prompt;
+    record.status = "running";
+    record.startedAt = Date.now();
+    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; };
 
-    const promise = runAgent(ctx, type, effectivePrompt, {
+    const promise = runAgent(ctx, type, prompt, {
       pi,
       model: options.model,
       maxTurns: options.maxTurns,
@@ -152,6 +193,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 +223,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 */ }
@@ -191,7 +243,7 @@ export class AgentManager {
 
         if (options.isBackground) {
           this.runningBackground--;
-          this.onComplete?.(record);
+          try { this.onComplete?.(record); } catch { /* ignore completion side-effect errors */ }
           this.drainQueue();
         }
         return responseText;
@@ -204,6 +256,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 */ }
@@ -235,7 +289,16 @@ export class AgentManager {
       const next = this.queue.shift()!;
       const record = this.agents.get(next.id);
       if (!record || record.status !== "queued") continue;
-      this.startAgent(next.id, record, next.args);
+      try {
+        this.startAgent(next.id, record, next.args);
+      } catch (err) {
+        // Late failure (e.g. strict worktree-isolation) — surface on the record
+        // so the user/agent can see it via /agents, then keep draining.
+        record.status = "error";
+        record.error = err instanceof Error ? err.message : String(err);
+        record.completedAt = Date.now();
+        this.onComplete?.(record);
+      }
     }
   }
 
@@ -278,6 +341,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";