@cad0p/pi-subagents-tintinweb 0.14.2 → 0.22.0

package/src/ui/fleet-list.ts

@@ -13,9 +13,10 @@
 
 import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
+import { toSingleLine } from "../text-safety.js";
 import type { AgentRecord } from "../types.js";
-import { getLifetimeTotal } from "../usage.js";
-import { type AgentActivity, getDisplayName, type Theme } from "./agent-widget.js";
+import { getLifetimeCost, getLifetimeTotal } from "../usage.js";
+import { type AgentActivity, formatCost, getDisplayName, type Theme } from "./agent-widget.js";
 import { ConversationViewer, VIEWPORT_HEIGHT_PCT } from "./conversation-viewer.js";
 
 /** Widget key for the below-editor fleet list. */
@@ -93,6 +94,12 @@ export class FleetList {
   constructor(
     private manager: AgentManager,
     private agentActivity: Map<string, AgentActivity>,
+    /**
+     * Read live at render time. Whether each row shows an estimated cost after
+     * its token count. Defaults to off — the extension supplies the user's
+     * `showCost` setting.
+     */
+    private showCost: () => boolean = () => false,
   ) {}
 
   // ---- Lifecycle ----
@@ -188,7 +195,7 @@ export class FleetList {
   private agentRecords(): AgentRecord[] {
     const now = Date.now();
     return this.manager.listAgents()
-      .filter(a => a.session && (
+      .filter(a => !a.parentAgentId && a.session && (
         a.status === "running" || a.status === "queued"
         || a.id === this.viewingAgentId
         || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS)
@@ -288,7 +295,7 @@ export class FleetList {
     const record = entry.record;
     if (!this.ui) return;
     if (!record.session) {
-      this.ui.notify(`Agent is ${record.status} — no session available.`, "info");
+      this.ui.notify(`Agent is ${toSingleLine(record.status)} — no session available.`, "info");
       return;
     }
     const session = record.session;
@@ -306,10 +313,11 @@ export class FleetList {
           theme,
           done,
           () => {
-            if (this.manager.abort(record.id)) this.ui?.notify(`Stopped "${record.description}".`, "info");
+            if (this.manager.abort(record.id)) this.ui?.notify(`Stopped "${toSingleLine(record.description)}".`, "info");
           },
           keybindings,
           (message: string) => this.manager.steer(record.id, message),
+          this.showCost(),
         );
       },
       {
@@ -371,10 +379,13 @@ export class FleetList {
   }
 
   private renderAgentRow(rosterIndex: number, sel: number, record: AgentRecord, width: number, theme: Theme): string {
-    const left = `  ${this.bullet(rosterIndex, sel, theme)} ${theme.fg("muted", getDisplayName(record.type))}  ${record.description}`;
-    const tokens = getLifetimeTotal(this.agentActivity.get(record.id)?.lifetimeUsage ?? record.lifetimeUsage);
+    const left = `  ${this.bullet(rosterIndex, sel, theme)} ${theme.fg("muted", toSingleLine(getDisplayName(record.type)))}  ${toSingleLine(record.description)}`;
+    const usage = this.agentActivity.get(record.id)?.lifetimeUsage ?? record.lifetimeUsage;
+    const tokens = getLifetimeTotal(usage);
     const elapsedMs = (record.completedAt ?? Date.now()) - record.startedAt; // freezes once finished
-    const right = theme.fg("dim", `${formatFleetElapsed(elapsedMs)} · ${formatFleetTokens(tokens)}`);
+    const cost = this.showCost() ? formatCost(getLifetimeCost(usage)) : "";
+    const stats = `${formatFleetElapsed(elapsedMs)} · ${formatFleetTokens(tokens)}${cost ? ` · ${cost}` : ""}`;
+    const right = theme.fg("dim", stats);
     return rightAlign(left, right, width);
   }
 }

package/src/ui/schedule-menu.ts

@@ -10,6 +10,7 @@
 
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { SubagentScheduler } from "../schedule.js";
+import { safeTruncate, stripControlChars, toSingleLine } from "../text-safety.js";
 import type { ScheduledSubagent } from "../types.js";
 
 /** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
@@ -40,29 +41,44 @@ function statusIcon(j: ScheduledSubagent): string {
 /** Compact selectable row — name, schedule, agent type, next/last run, count. */
 function formatJob(j: ScheduledSubagent, scheduler: SubagentScheduler): string {
   const next = scheduler.getNextRun(j.id);
+  // runCount is typed number but comes from unvalidated JSON; coerce before the
+  // single-line sanitizer, which returns "" for non-string input.
+  const runCount = Number(j.runCount);
   return [
     statusIcon(j),
-    j.name.padEnd(18).slice(0, 18),
-    j.schedule.padEnd(14).slice(0, 14),
-    `[${j.subagent_type}]`,
+    safeTruncate(toSingleLine(j.name), 18).padEnd(18),
+    safeTruncate(toSingleLine(j.schedule), 14).padEnd(14),
+    `[${toSingleLine(j.subagent_type)}]`,
     `next ${relTime(next)}`,
     `last ${relTime(j.lastRun)}`,
-    `runs ${j.runCount}`,
+    `runs ${toSingleLine(String(Number.isFinite(runCount) ? runCount : 0))}`,
   ].join("  ");
 }
 
 /** Multi-line details block for the cancel confirm. */
 function formatDetails(j: ScheduledSubagent, scheduler: SubagentScheduler): string {
   const next = scheduler.getNextRun(j.id) ?? "—";
+  // The prompt is the only multi-line field and goes last, under its own
+  // label, so nothing it contains can forge a metadata line above it. The
+  // store is not validated per field, so a corrupted entry can hand it a
+  // non-string; coerce before the sanitizer touches it.
+  const rawPrompt = typeof j.prompt === "string" ? j.prompt : "";
+  const prompt = stripControlChars(rawPrompt);
+  const promptPreview = prompt.length > 200 ? `${safeTruncate(prompt, 200)}…` : prompt;
+  // runCount is typed number but comes from unvalidated JSON; coerce before the
+  // single-line sanitizer, which returns "" for non-string input.
+  const runCount = Number(j.runCount);
   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}`,
+    `name:      ${toSingleLine(j.name)}`,
+    `schedule:  ${toSingleLine(j.schedule)} (${toSingleLine(j.scheduleType)})`,
+    `agent:     ${toSingleLine(j.subagent_type)}`,
+    `created:   ${toSingleLine(j.createdAt)}`,
+    `last run:  ${toSingleLine(j.lastRun ?? "—")} (${toSingleLine(j.lastStatus ?? "—")})`,
+    `next run:  ${toSingleLine(next)}`,
+    `runs:      ${toSingleLine(String(Number.isFinite(runCount) ? runCount : 0))}`,
+    "",
+    "prompt:",
+    promptPreview,
   ].join("\n");
 }
 
@@ -85,20 +101,48 @@ export async function showSchedulesMenu(
     return;
   }
 
-  const labels = jobs.map(j => formatJob(j, scheduler));
+  // Labels are the user-facing rows, so two jobs whose names collapse to the
+  // same text would otherwise be indistinguishable. Make each generated label
+  // unique and resolve the selected label back to its job, so confirm/cancel
+  // act on the row the user picked.
+  const jobByLabel = new Map<string, ScheduledSubagent>();
+  const nextSuffix = new Map<string, number>();
+  const labels = jobs.map(j => {
+    const base = formatJob(j, scheduler);
+    let label = base;
+    if (jobByLabel.has(label)) {
+      // A repeated base (rows can truncate to the same text) is load-bearing:
+      // the suffix keeps the labels distinct. Resume from the last used suffix
+      // so a fully-conflicting set costs one step per row.
+      let n = nextSuffix.get(base) ?? 2;
+      // The rescan is unreachable today (every base ends with its `runs N`
+      // tail), but keep it: a duplicate label would let the user cancel the
+      // wrong job if the row shape changes.
+      while (jobByLabel.has(`${base} (${n})`)) n++;
+      label = `${base} (${n})`;
+      nextSuffix.set(base, n + 1);
+    }
+    jobByLabel.set(label, j);
+    return label;
+  });
   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 job = jobByLabel.get(choice);
+  if (!job) return;
 
-  const ok = await ctx.ui.confirm(`Cancel "${job.name}"?`, formatDetails(job, scheduler));
+  const ok = await ctx.ui.confirm(`Cancel "${toSingleLine(job.name)}"?`, formatDetails(job, scheduler));
   if (!ok) return;
 
-  scheduler.removeJob(job.id);
-  ctx.ui.notify(`Cancelled "${job.name}".`, "info");
+  const removed = scheduler.removeJob(job.id);
+  if (removed) {
+    ctx.ui.notify(`Cancelled "${toSingleLine(job.name)}".`, "info");
+  } else {
+    // The record vanished between the list read and the removal — do not
+    // claim a cancellation that did not happen.
+    ctx.ui.notify(`Could not cancel "${toSingleLine(job.name)}" — it is no longer a scheduled job.`, "warning");
+  }
 }

package/src/usage.ts

@@ -1,30 +1,123 @@
 /** usage.ts — Token usage: shapes, accumulator operators, session-stats readers. */
 
+import type { Usage } from "@earendil-works/pi-ai";
+
 /**
  * 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.
+ * stats-derived sum). cacheRead is excluded from `getLifetimeTotal` 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.
+ *
+ * That exclusion is about this *display* total, not about what was billed: the
+ * prefix really is re-read and re-charged on every call. So `cacheRead` is
+ * accumulated here anyway, kept out of `getLifetimeTotal` and used only where
+ * billing is the question — reporting to the parent session, whose own messages
+ * pi counts the same way (`addUsageToTotals`). Reporting 0 there would make a
+ * subagent's rows count differently from every other row in one total.
+ *
+ * `cost` is a plain sum for the same reason: it is what pi charged for that one
+ * message (`usage.cost.total`, priced from the model's rates), not a cumulative
+ * figure. Both are optional because a model with no pricing data reports no
+ * cost, and because every accumulator predates them; absent reads as 0.
  */
-export type LifetimeUsage = { input: number; output: number; cacheWrite: number };
+export type LifetimeUsage = { input: number; output: number; cacheWrite: number; cacheRead?: number; cost?: number };
 
-/** Sum of lifetime usage components, or 0 if undefined. */
+/**
+ * Sum of lifetime *token* components for DISPLAY, or 0 if undefined.
+ * Deliberately excludes `cacheRead` (see above) and `cost` — that is money, not
+ * tokens, and lives on the same object only because it accumulates on the same
+ * events.
+ */
 export function getLifetimeTotal(u?: LifetimeUsage): number {
   return u ? u.input + u.output + u.cacheWrite : 0;
 }
 
+/** Accumulated cost in USD, or 0 when unpriced/undefined. */
+export function getLifetimeCost(u?: LifetimeUsage): number {
+  return u?.cost ?? 0;
+}
+
 /** Add a usage delta into a target accumulator (mutates target). */
 export function addUsage(into: LifetimeUsage, delta: LifetimeUsage): void {
   into.input += delta.input;
   into.output += delta.output;
   into.cacheWrite += delta.cacheWrite;
+  if (delta.cacheRead) into.cacheRead = (into.cacheRead ?? 0) + delta.cacheRead;
+  if (delta.cost) into.cost = (into.cost ?? 0) + delta.cost;
+}
+
+/**
+ * Render an accumulator as a pi `Usage`, or undefined when nothing was spent —
+ * callers attach nothing rather than a zero, so a consumer can tell "spent
+ * nothing" from "never ran".
+ *
+ * `cacheRead` IS included, unlike in `getLifetimeTotal`: pi sums it across a
+ * session's own assistant messages, and the prefix genuinely is re-read and
+ * re-billed on every call. Only `total` is populated on the cost breakdown; pi
+ * reads nothing else from it, and the per-kind split is not tracked.
+ *
+ * This is pi's own shape on purpose: every extension-facing payload that carries
+ * spend takes a whole `Usage` (`AgentToolResult.usage`, `ToolResultEventResult`,
+ * `AssistantMessage`, …), never a flattened cost — pi flattens only in computed
+ * read APIs it expects you to render, like `SessionStats`. Handing over pi's own
+ * type means `usage.cost.total` is where a listener already looks, and whatever
+ * pi adds to `Usage` later arrives without a change here.
+ */
+export function toReportedUsage(u: LifetimeUsage): Usage | undefined {
+  const { input, output, cacheWrite, cacheRead = 0, cost = 0 } = u;
+  if (input === 0 && output === 0 && cacheWrite === 0 && cacheRead === 0 && cost === 0) return undefined;
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    totalTokens: input + output + cacheRead + cacheWrite,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: cost },
+  };
+}
+
+/**
+ * Subagent spend that the parent session has not been told about yet.
+ *
+ * Subagents run in their own pi sessions, so none of what they spend appears in
+ * the parent's `getSessionStats()`. Pi does aggregate `toolResult.usage` into
+ * those stats, though — so the way back into the parent's footer and `/cost` is
+ * to hang the spend on a tool result. Background agents finish between tool
+ * calls with nothing to hang it on, hence a pool: every assistant message lands
+ * here as it happens, and the next tool result this extension returns carries
+ * whatever has accumulated.
+ *
+ * Drain empties it, so each message is reported exactly once no matter how many
+ * results are returned or how many agents were running.
+ */
+export class PendingUsagePool {
+  private pending: LifetimeUsage = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, cost: 0 };
+  private dirty = false;
+
+  add(delta: LifetimeUsage): void {
+    addUsage(this.pending, delta);
+    this.dirty = true;
+  }
+
+  /**
+   * Take everything accumulated so far as a pi `Usage`, resetting the pool.
+   * Returns undefined when nothing is pending, so callers can leave the tool
+   * result untouched rather than attaching a zero.
+   */
+  drain(): Usage | undefined {
+    if (!this.dirty) return undefined;
+    const drained = toReportedUsage(this.pending);
+    this.pending = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, cost: 0 };
+    this.dirty = false;
+    return drained;
+  }
 }
 
 /** Minimal shape we read from upstream `getSessionStats()`. */
 export type SessionStatsLike = {
   tokens: { input: number; output: number; cacheWrite: number };
-  contextUsage?: { percent: number | null };
+  contextUsage?: { percent: number | null; contextWindow?: number | null };
 };
 export type SessionLike = { getSessionStats(): SessionStatsLike };
 
@@ -55,6 +148,33 @@ export function getSessionTokens(session: SessionLike | undefined): number {
  */
 export function getSessionContextPercent(session: SessionLike | undefined): number | null {
   if (!session) return null;
-  try { return session.getSessionStats().contextUsage?.percent ?? null; }
-  catch { return null; }
+  try {
+    const percent = session.getSessionStats().contextUsage?.percent;
+    // A non-finite/negative percent would render `Context: NaN%` (or a nonsense
+    // negative) in the tool text and skew the widget/viewer thresholds.
+    return typeof percent === "number" && Number.isFinite(percent) && percent >= 0 ? percent : null;
+  } catch { return null; }
+}
+
+/** Format a context-window size for the report: "1.0M" at ≥1M, else "NNNk". */
+function formatContextWindow(contextWindow: number): string {
+  return contextWindow >= 1_000_000 ? "1.0M" : `${(contextWindow / 1000).toFixed(0)}k`;
+}
+
+/**
+ * Context-window utilization as `<percent>% of <window>` (e.g. "61.0% of 200k"),
+ * or null when unavailable (no model contextWindow, post-compaction, a
+ * disposed/throwing session, a non-finite/negative percent, or a non-finite
+ * window ≤ 0). A real 0.0% renders — the percent gate is not 0.
+ */
+export function formatSessionContext(session: SessionLike | undefined): string | null {
+  if (!session) return null;
+  try {
+    const usage = session.getSessionStats().contextUsage;
+    const percent = usage?.percent;
+    const contextWindow = usage?.contextWindow;
+    if (percent == null || !Number.isFinite(percent) || percent < 0) return null;
+    if (contextWindow == null || !Number.isFinite(contextWindow) || contextWindow <= 0) return null;
+    return `${percent.toFixed(1)}% of ${formatContextWindow(contextWindow)}`;
+  } catch { return null; }
 }

package/src/worktree.ts

@@ -28,6 +28,25 @@ export interface WorktreeInfo {
   workPath: string;
 }
 
+/**
+ * Project-wide switch for worktree isolation (`worktreeIsolation` in
+ * subagents.json). Default `true` — unchanged behaviour.
+ *
+ * The `"off"` isolation value gives a model a legal way to decline a worktree,
+ * but it still depends on the model choosing it. This is the deterministic half
+ * of the same fix: on a large repo where every worktree costs real time and
+ * disk, turning it off means no caller can create one, whatever it passes.
+ */
+let worktreeIsolationEnabled = true;
+
+export function setWorktreeIsolationEnabled(enabled: boolean): void {
+  worktreeIsolationEnabled = enabled;
+}
+
+export function isWorktreeIsolationEnabled(): boolean {
+  return worktreeIsolationEnabled;
+}
+
 export interface WorktreeCleanupResult {
   /** Whether changes were found in the worktree. */
   hasChanges: boolean;

package/src/group-join.ts

@@ -1,141 +0,0 @@
-/**
- * group-join.ts — Manages grouped background agent completion notifications.
- *
- * Instead of each agent individually nudging the main agent on completion,
- * agents in a group are held until all complete (or a timeout fires),
- * then a single consolidated notification is sent.
- */
-
-import type { AgentRecord } from "./types.js";
-
-export type DeliveryCallback = (records: AgentRecord[], partial: boolean) => void;
-
-interface AgentGroup {
-  groupId: string;
-  agentIds: Set<string>;
-  completedRecords: Map<string, AgentRecord>;
-  timeoutHandle?: ReturnType<typeof setTimeout>;
-  delivered: boolean;
-  /** Shorter timeout for stragglers after a partial delivery. */
-  isStraggler: boolean;
-}
-
-/** Default timeout: 30s after first completion in a group. */
-const DEFAULT_TIMEOUT = 30_000;
-/** Straggler re-batch timeout: 15s. */
-const STRAGGLER_TIMEOUT = 15_000;
-
-export class GroupJoinManager {
-  private groups = new Map<string, AgentGroup>();
-  private agentToGroup = new Map<string, string>();
-
-  constructor(
-    private deliverCb: DeliveryCallback,
-    private groupTimeout = DEFAULT_TIMEOUT,
-  ) {}
-
-  /** Register a group of agent IDs that should be joined. */
-  registerGroup(groupId: string, agentIds: string[]): void {
-    const group: AgentGroup = {
-      groupId,
-      agentIds: new Set(agentIds),
-      completedRecords: new Map(),
-      delivered: false,
-      isStraggler: false,
-    };
-    this.groups.set(groupId, group);
-    for (const id of agentIds) {
-      this.agentToGroup.set(id, groupId);
-    }
-  }
-
-  /**
-   * Called when an agent completes.
-   * Returns:
-   * - 'pass'      — agent is not grouped, caller should send individual nudge
-   * - 'held'      — result held, waiting for group completion
-   * - 'delivered'  — this completion triggered the group notification
-   */
-  onAgentComplete(record: AgentRecord): 'delivered' | 'held' | 'pass' {
-    const groupId = this.agentToGroup.get(record.id);
-    if (!groupId) return 'pass';
-
-    const group = this.groups.get(groupId);
-    if (!group || group.delivered) return 'pass';
-
-    group.completedRecords.set(record.id, record);
-
-    // All done — deliver immediately
-    if (group.completedRecords.size >= group.agentIds.size) {
-      this.deliver(group, false);
-      return 'delivered';
-    }
-
-    // First completion in this batch — start timeout
-    if (!group.timeoutHandle) {
-      const timeout = group.isStraggler ? STRAGGLER_TIMEOUT : this.groupTimeout;
-      group.timeoutHandle = setTimeout(() => {
-        this.onTimeout(group);
-      }, timeout);
-    }
-
-    return 'held';
-  }
-
-  private onTimeout(group: AgentGroup): void {
-    if (group.delivered) return;
-    group.timeoutHandle = undefined;
-
-    // Partial delivery — some agents still running
-    const remaining = new Set<string>();
-    for (const id of group.agentIds) {
-      if (!group.completedRecords.has(id)) remaining.add(id);
-    }
-
-    // Clean up agentToGroup for delivered agents (they won't complete again)
-    for (const id of group.completedRecords.keys()) {
-      this.agentToGroup.delete(id);
-    }
-
-    // Deliver what we have
-    this.deliverCb([...group.completedRecords.values()], true);
-
-    // Set up straggler group for remaining agents
-    group.completedRecords.clear();
-    group.agentIds = remaining;
-    group.isStraggler = true;
-    // Timeout will be started when the next straggler completes
-  }
-
-  private deliver(group: AgentGroup, partial: boolean): void {
-    if (group.timeoutHandle) {
-      clearTimeout(group.timeoutHandle);
-      group.timeoutHandle = undefined;
-    }
-    group.delivered = true;
-    this.deliverCb([...group.completedRecords.values()], partial);
-    this.cleanupGroup(group.groupId);
-  }
-
-  private cleanupGroup(groupId: string): void {
-    const group = this.groups.get(groupId);
-    if (!group) return;
-    for (const id of group.agentIds) {
-      this.agentToGroup.delete(id);
-    }
-    this.groups.delete(groupId);
-  }
-
-  /** Check if an agent is in a group. */
-  isGrouped(agentId: string): boolean {
-    return this.agentToGroup.has(agentId);
-  }
-
-  dispose(): void {
-    for (const group of this.groups.values()) {
-      if (group.timeoutHandle) clearTimeout(group.timeoutHandle);
-    }
-    this.groups.clear();
-    this.agentToGroup.clear();
-  }
-}