@tintinweb/pi-subagents 0.6.2 → 0.7.0

package/dist/schedule.d.ts

@@ -0,0 +1,109 @@
+/**
+ * schedule.ts — `SubagentScheduler`: timer-driven dispatcher of scheduled subagents.
+ *
+ * Mirrors the engine shape of pi-cron-schedule/src/scheduler.ts:
+ *   - two-Map split (jobs = croner Cron, intervals = setInterval/setTimeout)
+ *   - addJob/removeJob/updateJob/scheduleJob/unscheduleJob/executeJob
+ *   - static parsers for cron / "+10m" / "5m" / ISO formats
+ *
+ * Differences vs pi-cron-schedule:
+ *   - Persistence is via ScheduleStore (PID-locked, session-scoped, atomic).
+ *   - `executeJob` calls `manager.spawn(..., { bypassQueue: true })` instead
+ *     of dispatching a user message — schedule fires bypass maxConcurrent so
+ *     a 5-minute interval can't be deferred behind 4 long-running agents.
+ *   - Result delivery is implicit: spawn → background completion → existing
+ *     `subagent-notification` followUp path. No new delivery code.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentManager } from "./agent-manager.js";
+import type { ScheduleStore } from "./schedule-store.js";
+import type { IsolationMode, ScheduledSubagent, SubagentType, ThinkingLevel } from "./types.js";
+/** Event emitted on `pi.events` for cross-extension consumers. */
+export type ScheduleChangeEvent = {
+    type: "added";
+    job: ScheduledSubagent;
+} | {
+    type: "removed";
+    jobId: string;
+} | {
+    type: "updated";
+    job: ScheduledSubagent;
+} | {
+    type: "fired";
+    jobId: string;
+    agentId: string;
+    name: string;
+} | {
+    type: "error";
+    jobId: string;
+    error: string;
+};
+/** Params accepted at job creation — ID, timestamps, and state are derived. */
+export interface NewJobInput {
+    name: string;
+    description: string;
+    schedule: string;
+    subagent_type: SubagentType;
+    prompt: string;
+    model?: string;
+    thinking?: ThinkingLevel;
+    max_turns?: number;
+    isolated?: boolean;
+    isolation?: IsolationMode;
+}
+export declare class SubagentScheduler {
+    private jobs;
+    private intervals;
+    private store;
+    private pi;
+    private ctx;
+    private manager;
+    /** Start the scheduler: bind to a session's store and arm enabled jobs. */
+    start(pi: ExtensionAPI, ctx: ExtensionContext, manager: AgentManager, store: ScheduleStore): void;
+    /** Stop all timers; drop refs. Safe to call repeatedly. */
+    stop(): void;
+    /** True if start() has bound a store and the scheduler is active. */
+    isActive(): boolean;
+    list(): ScheduledSubagent[];
+    /**
+     * Build a `ScheduledSubagent` from user input. Validates the schedule
+     * format and tags `scheduleType`. Throws on invalid input.
+     */
+    buildJob(input: NewJobInput): ScheduledSubagent;
+    /** Add a job, persist, and arm if enabled. Returns the stored job. */
+    addJob(input: NewJobInput): ScheduledSubagent;
+    removeJob(id: string): boolean;
+    /** Toggle / mutate a job. Re-arms based on the new `enabled` state. */
+    updateJob(id: string, patch: Partial<ScheduledSubagent>): ScheduledSubagent | undefined;
+    /** Next-run time as ISO, or undefined if not currently armed. */
+    getNextRun(jobId: string): string | undefined;
+    private scheduleJob;
+    private unscheduleJob;
+    /**
+     * Fire a job: persist running state, spawn (bypassing the concurrency
+     * queue), persist completion. Fire-and-forget: the timer tick returns
+     * immediately so other jobs keep firing.
+     */
+    private executeJob;
+    private emit;
+    private requireStore;
+    /**
+     * Sniff a schedule string and tag its type. Throws on invalid input.
+     * Order matters: relative ("+10m") and interval ("5m") both match digit+unit;
+     * relative requires the leading "+" to disambiguate.
+     */
+    static detectSchedule(s: string): {
+        type: "cron" | "once" | "interval";
+        intervalMs?: number;
+        normalized: string;
+    };
+    /** 6-field cron — 'second minute hour dom month dow'. */
+    static validateCronExpression(expr: string): {
+        valid: boolean;
+        error?: string;
+    };
+    /** "+10s"/"+5m"/"+1h"/"+2d" → ISO timestamp. */
+    static parseRelativeTime(s: string): string | null;
+    /** "10s"/"5m"/"1h"/"2d" → milliseconds. */
+    static parseInterval(s: string): number | null;
+}

package/dist/schedule.js

@@ -0,0 +1,338 @@
+/**
+ * schedule.ts — `SubagentScheduler`: timer-driven dispatcher of scheduled subagents.
+ *
+ * Mirrors the engine shape of pi-cron-schedule/src/scheduler.ts:
+ *   - two-Map split (jobs = croner Cron, intervals = setInterval/setTimeout)
+ *   - addJob/removeJob/updateJob/scheduleJob/unscheduleJob/executeJob
+ *   - static parsers for cron / "+10m" / "5m" / ISO formats
+ *
+ * Differences vs pi-cron-schedule:
+ *   - Persistence is via ScheduleStore (PID-locked, session-scoped, atomic).
+ *   - `executeJob` calls `manager.spawn(..., { bypassQueue: true })` instead
+ *     of dispatching a user message — schedule fires bypass maxConcurrent so
+ *     a 5-minute interval can't be deferred behind 4 long-running agents.
+ *   - Result delivery is implicit: spawn → background completion → existing
+ *     `subagent-notification` followUp path. No new delivery code.
+ */
+import { Cron } from "croner";
+import { nanoid } from "nanoid";
+import { resolveModel } from "./model-resolver.js";
+export class SubagentScheduler {
+    jobs = new Map();
+    intervals = new Map();
+    store;
+    pi;
+    ctx;
+    manager;
+    /** Start the scheduler: bind to a session's store and arm enabled jobs. */
+    start(pi, ctx, manager, store) {
+        this.pi = pi;
+        this.ctx = ctx;
+        this.manager = manager;
+        this.store = store;
+        for (const job of store.list()) {
+            if (job.enabled)
+                this.scheduleJob(job);
+        }
+    }
+    /** Stop all timers; drop refs. Safe to call repeatedly. */
+    stop() {
+        for (const cron of this.jobs.values())
+            cron.stop();
+        this.jobs.clear();
+        for (const t of this.intervals.values())
+            clearTimeout(t);
+        this.intervals.clear();
+        this.store = undefined;
+        this.pi = undefined;
+        this.ctx = undefined;
+        this.manager = undefined;
+    }
+    /** True if start() has bound a store and the scheduler is active. */
+    isActive() {
+        return this.store !== undefined;
+    }
+    list() {
+        return this.store?.list() ?? [];
+    }
+    /**
+     * Build a `ScheduledSubagent` from user input. Validates the schedule
+     * format and tags `scheduleType`. Throws on invalid input.
+     */
+    buildJob(input) {
+        const detected = SubagentScheduler.detectSchedule(input.schedule);
+        return {
+            id: nanoid(10),
+            name: input.name,
+            description: input.description,
+            schedule: detected.normalized,
+            scheduleType: detected.type,
+            intervalMs: detected.intervalMs,
+            subagent_type: input.subagent_type,
+            prompt: input.prompt,
+            model: input.model,
+            thinking: input.thinking,
+            max_turns: input.max_turns,
+            isolated: input.isolated,
+            isolation: input.isolation,
+            enabled: true,
+            createdAt: new Date().toISOString(),
+            runCount: 0,
+        };
+    }
+    /** Add a job, persist, and arm if enabled. Returns the stored job. */
+    addJob(input) {
+        const store = this.requireStore();
+        if (store.hasName(input.name)) {
+            throw new Error(`A scheduled job named "${input.name}" already exists.`);
+        }
+        const job = this.buildJob(input);
+        store.add(job);
+        if (job.enabled)
+            this.scheduleJob(job);
+        this.emit({ type: "added", job });
+        return job;
+    }
+    removeJob(id) {
+        const store = this.requireStore();
+        if (!store.get(id))
+            return false;
+        this.unscheduleJob(id);
+        const ok = store.remove(id);
+        if (ok)
+            this.emit({ type: "removed", jobId: id });
+        return ok;
+    }
+    /** Toggle / mutate a job. Re-arms based on the new `enabled` state. */
+    updateJob(id, patch) {
+        const store = this.requireStore();
+        const updated = store.update(id, patch);
+        if (!updated)
+            return undefined;
+        this.unscheduleJob(id);
+        if (updated.enabled)
+            this.scheduleJob(updated);
+        this.emit({ type: "updated", job: updated });
+        return updated;
+    }
+    /** Next-run time as ISO, or undefined if not currently armed. */
+    getNextRun(jobId) {
+        const cron = this.jobs.get(jobId);
+        if (cron)
+            return cron.nextRun()?.toISOString();
+        const job = this.store?.get(jobId);
+        if (!job?.enabled)
+            return undefined;
+        if (job.scheduleType === "once")
+            return job.schedule;
+        if (job.scheduleType === "interval" && job.intervalMs) {
+            // Before the first fire there's no `lastRun`, so fall back to "now" —
+            // accurate at create time (setInterval was just armed) and within
+            // intervalMs of correct in any pre-first-fire view.
+            const base = job.lastRun ? new Date(job.lastRun).getTime() : Date.now();
+            return new Date(base + job.intervalMs).toISOString();
+        }
+        return undefined;
+    }
+    // ── Scheduling primitives ────────────────────────────────────────────
+    scheduleJob(job) {
+        const store = this.store;
+        if (!store)
+            return;
+        try {
+            if (job.scheduleType === "interval" && job.intervalMs) {
+                const t = setInterval(() => this.executeJob(job.id), job.intervalMs);
+                this.intervals.set(job.id, t);
+            }
+            else if (job.scheduleType === "once") {
+                const target = new Date(job.schedule).getTime();
+                const delay = target - Date.now();
+                if (delay > 0) {
+                    const t = setTimeout(() => {
+                        this.executeJob(job.id);
+                        // Auto-disable one-shots after they fire (mirrors pi-cron-schedule)
+                        store.update(job.id, { enabled: false });
+                        const updated = store.get(job.id);
+                        if (updated)
+                            this.emit({ type: "updated", job: updated });
+                    }, delay);
+                    this.intervals.set(job.id, t);
+                }
+                else {
+                    // Past timestamp — disable, mark error, never fire
+                    store.update(job.id, { enabled: false, lastStatus: "error" });
+                    this.emit({ type: "error", jobId: job.id, error: `Scheduled time ${job.schedule} is in the past` });
+                }
+            }
+            else {
+                const cron = new Cron(job.schedule, () => this.executeJob(job.id));
+                this.jobs.set(job.id, cron);
+            }
+        }
+        catch (err) {
+            this.emit({ type: "error", jobId: job.id, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    unscheduleJob(id) {
+        const cron = this.jobs.get(id);
+        if (cron) {
+            cron.stop();
+            this.jobs.delete(id);
+        }
+        const t = this.intervals.get(id);
+        if (t) {
+            clearTimeout(t);
+            clearInterval(t);
+            this.intervals.delete(id);
+        }
+    }
+    /**
+     * Fire a job: persist running state, spawn (bypassing the concurrency
+     * queue), persist completion. Fire-and-forget: the timer tick returns
+     * immediately so other jobs keep firing.
+     */
+    executeJob(id) {
+        const store = this.store;
+        const pi = this.pi;
+        const ctx = this.ctx;
+        const manager = this.manager;
+        if (!store || !pi || !ctx || !manager)
+            return;
+        const job = store.get(id);
+        if (!job?.enabled)
+            return;
+        store.update(id, { lastStatus: "running" });
+        // Resolve model at fire time — registry contents may have changed since the
+        // job was created (auth added/removed). Fall back silently to spawn-default
+        // if resolution fails; the spawn path handles undefined model gracefully.
+        let resolvedModel;
+        if (job.model) {
+            const r = resolveModel(job.model, ctx.modelRegistry);
+            if (typeof r !== "string")
+                resolvedModel = r;
+        }
+        let agentId;
+        try {
+            agentId = manager.spawn(pi, ctx, job.subagent_type, job.prompt, {
+                description: job.description,
+                isBackground: true,
+                bypassQueue: true,
+                model: resolvedModel,
+                maxTurns: job.max_turns,
+                isolated: job.isolated,
+                thinkingLevel: job.thinking,
+                isolation: job.isolation,
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            store.update(id, { lastRun: new Date().toISOString(), lastStatus: "error" });
+            this.emit({ type: "error", jobId: id, error });
+            return;
+        }
+        this.emit({ type: "fired", jobId: id, agentId, name: job.name });
+        const record = manager.getRecord(agentId);
+        const finalize = (status) => {
+            const next = this.getNextRun(id);
+            const current = store.get(id);
+            store.update(id, {
+                lastRun: new Date().toISOString(),
+                lastStatus: status,
+                runCount: (current?.runCount ?? 0) + 1,
+                nextRun: next,
+            });
+        };
+        // AgentManager's promise resolves either way (its .catch returns ""), so we
+        // can't infer success/failure from the promise — read record.status instead.
+        // Terminal states: completed/steered = success; error/aborted/stopped = error.
+        if (record?.promise) {
+            record.promise
+                .then(() => {
+                const r = manager.getRecord(agentId);
+                const failed = r?.status === "error" || r?.status === "aborted" || r?.status === "stopped";
+                finalize(failed ? "error" : "success");
+            })
+                .catch(() => finalize("error"));
+        }
+        else {
+            // Spawn returned without a promise (defensive — bypassQueue path always sets one).
+            finalize("success");
+        }
+    }
+    emit(event) {
+        if (this.pi)
+            this.pi.events.emit("subagents:scheduled", event);
+    }
+    requireStore() {
+        if (!this.store)
+            throw new Error("Scheduler not started — no active session.");
+        return this.store;
+    }
+    // ── Format detection / parsers (statics — pure) ──────────────────────
+    /**
+     * Sniff a schedule string and tag its type. Throws on invalid input.
+     * Order matters: relative ("+10m") and interval ("5m") both match digit+unit;
+     * relative requires the leading "+" to disambiguate.
+     */
+    static detectSchedule(s) {
+        const trimmed = s.trim();
+        // "+10m" — relative one-shot
+        const rel = SubagentScheduler.parseRelativeTime(trimmed);
+        if (rel !== null)
+            return { type: "once", normalized: rel };
+        // "5m" — interval
+        const ivl = SubagentScheduler.parseInterval(trimmed);
+        if (ivl !== null)
+            return { type: "interval", intervalMs: ivl, normalized: trimmed };
+        // ISO timestamp — one-shot. Reject past timestamps upfront so we never
+        // create a dead-on-arrival record (scheduleJob's safety net still catches
+        // micro-races from `+0s`-style relatives).
+        if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
+            const d = new Date(trimmed);
+            if (!Number.isNaN(d.getTime())) {
+                if (d.getTime() <= Date.now()) {
+                    throw new Error(`Scheduled time ${d.toISOString()} is in the past.`);
+                }
+                return { type: "once", normalized: d.toISOString() };
+            }
+        }
+        // Cron — 6-field
+        const cronCheck = SubagentScheduler.validateCronExpression(trimmed);
+        if (cronCheck.valid)
+            return { type: "cron", normalized: trimmed };
+        throw new Error(`Invalid schedule "${s}". Use 6-field cron (e.g. "0 0 9 * * 1" — 9am every Monday), interval ("5m"/"1h"), or one-shot ("+10m" / ISO).`);
+    }
+    /** 6-field cron — 'second minute hour dom month dow'. */
+    static validateCronExpression(expr) {
+        const fields = expr.trim().split(/\s+/);
+        if (fields.length !== 6) {
+            return {
+                valid: false,
+                error: `Cron must have 6 fields (second minute hour dom month dow), got ${fields.length}. Example: "0 0 9 * * 1" for 9am every Monday.`,
+            };
+        }
+        try {
+            // Croner validates by construction.
+            new Cron(expr, () => { });
+            return { valid: true };
+        }
+        catch (e) {
+            return { valid: false, error: e instanceof Error ? e.message : "Invalid cron expression" };
+        }
+    }
+    /** "+10s"/"+5m"/"+1h"/"+2d" → ISO timestamp. */
+    static parseRelativeTime(s) {
+        const m = s.match(/^\+(\d+)(s|m|h|d)$/);
+        if (!m)
+            return null;
+        const ms = parseInt(m[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2]];
+        return new Date(Date.now() + ms).toISOString();
+    }
+    /** "10s"/"5m"/"1h"/"2d" → milliseconds. */
+    static parseInterval(s) {
+        const m = s.match(/^(\d+)(s|m|h|d)$/);
+        if (!m)
+            return null;
+        return parseInt(m[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2]];
+    }
+}

package/dist/settings.d.ts

@@ -9,6 +9,15 @@ export interface SubagentsSettings {
     defaultMaxTurns?: number;
     graceTurns?: number;
     defaultJoinMode?: JoinMode;
+    /**
+     * Master switch for the schedule subagent feature. Defaults to `true`.
+     * When `false`: the `Agent` tool's `schedule` param + its guideline are
+     * stripped from the tool spec at registration (zero LLM-context cost), the
+     * scheduler doesn't bind to the session, and the `/agents → Scheduled jobs`
+     * menu entry is hidden. Schema-level removal applies at extension load
+     * (next pi session); runtime menu/runtime-fire short-circuit is immediate.
+     */
+    schedulingEnabled?: boolean;
 }
 /** Setter hooks used by applySettings to wire persisted values into in-memory state. */
 export interface SettingsAppliers {
@@ -16,6 +25,7 @@ export interface SettingsAppliers {
     setDefaultMaxTurns: (n: number) => void;
     setGraceTurns: (n: number) => void;
     setDefaultJoinMode: (mode: JoinMode) => void;
+    setSchedulingEnabled: (b: boolean) => void;
 }
 /** Emit callback — a subset of `pi.events.emit` to keep helpers testable. */
 export type SettingsEmit = (event: string, payload: unknown) => void;

package/dist/settings.js

@@ -35,6 +35,9 @@ function sanitize(raw) {
     if (typeof r.defaultJoinMode === "string" && VALID_JOIN_MODES.has(r.defaultJoinMode)) {
         out.defaultJoinMode = r.defaultJoinMode;
     }
+    if (typeof r.schedulingEnabled === "boolean") {
+        out.schedulingEnabled = r.schedulingEnabled;
+    }
     return out;
 }
 function globalPath() {
@@ -90,6 +93,8 @@ export function applySettings(s, appliers) {
         appliers.setGraceTurns(s.graceTurns);
     if (s.defaultJoinMode)
         appliers.setDefaultJoinMode(s.defaultJoinMode);
+    if (typeof s.schedulingEnabled === "boolean")
+        appliers.setSchedulingEnabled(s.schedulingEnabled);
 }
 /**
  * Format the user-facing toast for a settings mutation. Pure function —

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));