@esso0428/pi-subagents 0.15.4 → 0.15.6

package/CHANGELOG.md

@@ -7,25 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.15.4] - 2026-09-11
+## [0.15.6] - 2026-09-11
 
 ### Fixed
-- **Unavailable history records no longer load the subagent panels.** Reload-restored metadata is shown in AgentWidget, FleetView, and `/agents` only when its project-local transcript still exists; stale records remain available through the normal session result/history data without creating a dead-end Enter target.
-
-## [0.15.3] - 2026-09-11
-
-### Added
-- **Reload-safe transcript history.** Agents now keep a project-local copy under `.pi-subagents/agent-transcripts/`; terminal records persist a relative locator and `/agents`/FleetView can open a read-only history viewer after reload. The shared `.pi-subagents/.gitignore` is created with `*` to keep private transcripts out of git.
-
-## [0.15.2] - 2026-09-10
-
-### Added
-- **Completed subagent records survive session reloads.** On `session_start`, the extension now reconstructs validated terminal records persisted as `subagents:record` entries. Restored records retain their result and status for `get_subagent_result`, but never pretend to have a live child session; running and queued records are ignored, and duplicate IDs use the newest branch entry.
-
-## [0.15.1] - 2026-09-10
-
-### Added
-- **Markdown-rendered subagent results.** Expanded foreground results and background completion notifications now render headings, lists, inline code, and fenced code through pi's Markdown renderer. Display output is capped to keep terminal notifications bounded; use `get_subagent_result` for the complete result.
+- **FleetView stays within a six-row budget** while preserving full-roster keyboard navigation, selected-row visibility, overflow indicators, and prompt-area separation.
+- **Agent history and live FleetView are routed separately**, keeping terminal records in the read-only history viewer instead of treating them as active sessions.
+- **Pi 0.85.1 model-runtime type compatibility** is restored without changing the legacy fallback path.
 
 ## [0.14.3] - 2026-07-23
 

package/README.md

@@ -28,7 +28,7 @@ https://github.com/user-attachments/assets/8685261b-9338-4fea-8dfe-1c590d5df543
 - **Git worktree isolation** — run agents in isolated repo copies; changes auto-committed to branches on completion
 - **Skill preloading** — inject named skills into agent system prompts, discovered from `.pi/skills/`, `.agents/skills/`, and global locations (Pi-standard `<name>/SKILL.md` directory layout supported)
 - **Tool denylist** — block specific tools via `disallowed_tools` frontmatter
-- **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expanded results render headings, lists, inline code, and fenced code as Markdown, with a bounded display to keep the TUI responsive. Group completions render each agent individually
+- **Styled completion notifications** — background agent results render as themed, compact notification boxes (icon, stats, result preview) instead of raw XML. Expandable to show full output. Group completions render each agent individually
 - **Event bus** — lifecycle events (`subagents:created`, `started`, `completed`, `failed`, `steered`, `compacted`) emitted via `pi.events`, enabling other extensions to react to sub-agent activity
 - **Cross-extension RPC** — other pi extensions can spawn and stop subagents via the `pi.events` event bus (`subagents:rpc:ping`, `subagents:rpc:spawn`, `subagents:rpc:stop`). Standardized reply envelopes with protocol versioning. Emits `subagents:ready` on session start
 - **Schedule subagents** — pass `schedule` to the `Agent` tool to fire on cron / interval / one-shot. Session-scoped jobs with PID-locked persistence; results land via the same `subagent-notification` followUp path as manual background completions; manage via `/agents → Scheduled jobs`
@@ -138,9 +138,9 @@ Individual agent results render Claude Code-style in the conversation:
 | **Error** | `✗ ↻3 · 3 tool uses · 12.4k token (8%)` / `⎿ Error: timeout` |
 | **Aborted** | `✗ ↻55≤50 · 55 tool uses · 102.3k token (95% · ⇊3)` / `⎿ Aborted (max turns exceeded)` |
 
-Completed results can be expanded (ctrl+o in pi) to show the agent output inline with Markdown formatting. Expanded output is capped at 50 rendered lines (background notification results at 30 lines) and ends with a marker when more output is available; use `get_subagent_result` for the complete result.
+Completed results can be expanded (ctrl+o in pi) to show the full agent output inline.
 
-By default, foreground and background agents stream their full conversation to two per-subagent transcripts: the existing temporary JSON-lines file at `<os-tmpdir>/pi-subagents-<uid>/<cwd>/<session>/tasks/<agent-id>.output` (owner-only `0700`, cleared on reboot), plus a durable copy at `<cwd>/.pi-subagents/agent-transcripts/<agent-id>_<agent-type>_transcript.jsonl`. The project-local `.pi-subagents/.gitignore` contains `*` so these private transcripts are not accidentally uploaded to git. After `/reload`, terminal records use the durable locator to open a read-only history viewer. Set `output_transcript: false` on a custom agent, or `outputTranscript: false` in `subagents.json`, to suppress both transcript files. This governs **only** the transcript: it is independent of `persist_session` (the pi session on disk), and it does not affect `isolation: worktree` or `memory:`. Background agent completion notifications render as styled boxes:
+By default, foreground and background agents each stream their full conversation to a per-subagent transcript — a JSON-lines file at `<os-tmpdir>/pi-subagents-<uid>/<cwd>/<session>/tasks/<agent-id>.output` (owner-only `0700`, cleared on reboot). Set `output_transcript: false` on a custom agent to write no transcript path or file for it, or set `outputTranscript: false` in `subagents.json` to make transcripts opt-in for the whole project (frontmatter overrides the project default). This governs **only** the transcript: it is independent of `persist_session` (the pi session on disk), and it does not affect `isolation: worktree` (which commits the agent's work to a git branch) or `memory:` (durable files) — set those accordingly if the goal is to keep a run off disk entirely. Background agent completion notifications render as styled boxes:
 
 ```
 ✓ Find auth files completed
@@ -222,7 +222,7 @@ All fields are optional — sensible defaults for everything.
 | `thinking` | inherit | off, minimal, low, medium, high, xhigh, max — actual availability depends on your pi version and model; pi clamps unsupported levels down |
 | `max_turns` | unlimited | Max agentic turns before graceful shutdown. `0` or omit for unlimited |
 | `persist_session` | `false` | Persist this subagent as a normal pi session instead of keeping the session in memory only. The subagent's `.output` transcript is still written either way unless `output_transcript: false` |
-| `output_transcript` | `true` (or `subagents.json` `outputTranscript`) | Write the temporary `.output` transcript and durable `.pi-subagents/agent-transcripts/` copy; when set, overrides the `subagents.json` `outputTranscript` default. Set `false` to write neither. Governs only the transcript — independent of `persist_session`, `isolation: worktree`, and `memory:` |
+| `output_transcript` | `true` (or `subagents.json` `outputTranscript`) | Write this subagent's `.output` transcript; when set, overrides the `subagents.json` `outputTranscript` default. Set `false` to write no transcript file or path. Governs only the transcript — independent of `persist_session`, `isolation: worktree`, and `memory:` |
 | `session_dir` | pi default | Optional session directory when `persist_session: true`; omitted uses pi's normal session location, and relative paths resolve from the agent cwd |
 | `prompt_mode` | `replace` | `replace`: body is the full system prompt (no AGENTS.md / CLAUDE.md inheritance). `append`: body appended to parent's prompt (agent acts as a "parent twin" — inherits parent's AGENTS.md / CLAUDE.md) |
 | `inherit_context` | `false` | Fork parent conversation into agent |
@@ -508,7 +508,7 @@ Runtime tuning values set via `/agents` → Settings (max concurrency, default m
 
 **Disable defaults** (`disableDefaultAgents`, default `false`): when on, the three built-in agents (general-purpose, Explore, Plan) are not registered — only your project/global custom agents are advertised and spawnable. User-defined agents are unaffected, including ones that override a default by name. The Agent tool's type list updates on the next pi session (the tool schema is registered at startup).
 
-**Output transcript** (`outputTranscript`, default `true`): the project/global default for writing each subagent's temporary `.output` transcript and durable project-local history copy under `.pi-subagents/agent-transcripts/`. Toggle via `/agents → Settings → Output transcript`, or set `false` in `subagents.json` to make both transcripts opt-in project-wide. A custom agent's `output_transcript` frontmatter overrides this per agent. Applied live at spawn time. Governs only the transcript, not `persist_session`, worktree commits, or memory files.
+**Output transcript** (`outputTranscript`, default `true`): the project/global default for writing each subagent's `.output` transcript. Toggle via `/agents → Settings → Output transcript`, or set `false` in `subagents.json` to make transcripts opt-in project-wide — useful when run transcripts shouldn't sit on disk for backup or DLP tooling to pick up. A custom agent's `output_transcript` frontmatter overrides this per agent. Applied live at spawn time. Governs only the transcript, not `persist_session`, worktree commits, or memory files.
 
 **Tool description** (`toolDescriptionMode`, default `"full"`): which Agent tool description the LLM sees. `"full"` is the rich Claude Code-style prompt (~1,400 tokens with the default agents); `"compact"` is ~75% smaller — one-line agent type list, terse usage notes — for small/local models where tool-spec tokens are expensive. Per-option details stay in the parameter descriptions in every mode (the parameter schema is never customizable). Applies on the next pi session.
 

package/dist/agent-history-list.d.ts

@@ -0,0 +1,18 @@
+/** Helpers for separating openable active agents from terminal history. */
+import type { AgentRecord } from "./types.js";
+export type AgentHistoryStatus = "completed" | "steered" | "stopped" | "aborted" | "error";
+/** Return whether a record status represents a terminal agent run. */
+export declare function isTerminalAgentStatus(status: string): status is AgentHistoryStatus;
+/** Return whether an active record has a live session that can be opened. */
+export declare function canOpenActiveAgent(record: AgentRecord): boolean;
+/** Return whether a terminal record has an in-memory or durable conversation. */
+export declare function canOpenAgentHistory(record: AgentRecord, cwd: string | undefined): boolean;
+/** Split records into openable active and terminal-history buckets. */
+export declare function splitAgentRecords(records: readonly AgentRecord[], cwd: string | undefined): {
+    active: AgentRecord[];
+    history: AgentRecord[];
+};
+/** Format a bounded, single-line history menu option. */
+export declare function formatAgentHistoryOption(record: AgentRecord, now: number): string;
+/** Build the visible status-section labels for the agents menu. */
+export declare function buildAgentStatusMenuEntries(records: readonly AgentRecord[], cwd: string | undefined): string[];

package/dist/agent-history-list.js

@@ -0,0 +1,68 @@
+/** Helpers for separating openable active agents from terminal history. */
+import { hasAgentHistory } from "./agent-history.js";
+import { getAgentConfig } from "./agent-types.js";
+import { formatDuration, getDisplayName } from "./ui/agent-widget.js";
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "steered",
+    "stopped",
+    "aborted",
+    "error",
+]);
+/** Return whether a record status represents a terminal agent run. */
+export function isTerminalAgentStatus(status) {
+    return TERMINAL_STATUSES.has(status);
+}
+/** Return whether an active record has a live session that can be opened. */
+export function canOpenActiveAgent(record) {
+    return (record.status === "running" || record.status === "queued")
+        && record.session !== undefined;
+}
+/** Return whether a terminal record has an in-memory or durable conversation. */
+export function canOpenAgentHistory(record, cwd) {
+    if (!isTerminalAgentStatus(record.status))
+        return false;
+    return record.session !== undefined
+        || (cwd !== undefined && hasAgentHistory(cwd, record.transcriptPath));
+}
+/** Split records into openable active and terminal-history buckets. */
+export function splitAgentRecords(records, cwd) {
+    const active = [];
+    const history = [];
+    for (const record of records) {
+        if (canOpenActiveAgent(record)) {
+            active.push(record);
+        }
+        else if (canOpenAgentHistory(record, cwd)) {
+            history.push(record);
+        }
+    }
+    return { active, history };
+}
+const DESCRIPTION_LIMIT = 72;
+const LABEL_LIMIT = 140;
+function boundedDescription(description) {
+    const line = description.split("\n").find((part) => part.trim())?.trim() ?? "";
+    if (line.length <= DESCRIPTION_LIMIT)
+        return line;
+    return `${line.slice(0, DESCRIPTION_LIMIT - 1)}…`;
+}
+/** Format a bounded, single-line history menu option. */
+export function formatAgentHistoryOption(record, now) {
+    const duration = formatDuration(record.startedAt, record.completedAt ?? now);
+    // Unit consumers may format persisted records before the registry has been
+    // initialized; preserve the persisted type instead of falling back to
+    // general-purpose's generic display name in that case.
+    const displayName = getAgentConfig(record.type)?.displayName
+        ?? (record.type === "general-purpose" ? getDisplayName(record.type) : record.type);
+    const option = `[${record.status}] ${displayName} · ${boundedDescription(record.description)} · ${duration}`;
+    return option.length <= LABEL_LIMIT ? option : `${option.slice(0, LABEL_LIMIT - 1)}…`;
+}
+/** Build the visible status-section labels for the agents menu. */
+export function buildAgentStatusMenuEntries(records, cwd) {
+    const { active, history } = splitAgentRecords(records, cwd);
+    return [
+        ...(active.length > 0 ? [`Running agents (${active.length})`] : []),
+        ...(history.length > 0 ? [`Agent history (${history.length})`] : []),
+    ];
+}

package/dist/agent-history.d.ts

@@ -9,7 +9,7 @@ import type { AgentSession } from "@earendil-works/pi-coding-agent";
  */
 export declare function ensureSubagentsGitignore(cwd: string): string;
 /** Return the durable transcript path for an agent. */
-export declare function createAgentHistoryPath(cwd: string, agentId: string, agentType?: string): string;
+export declare function createAgentHistoryPath(cwd: string, agentId: string): string;
 /** Return the project-relative path stored in the parent session record. */
 export declare function agentHistoryLocator(cwd: string, historyPath: string): string;
 /** Resolve only paths in this package's project-local transcript namespace. */

package/dist/agent-history.js

@@ -1,14 +1,6 @@
-"use strict";
 /** Durable, project-local transcript storage for subagents. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureSubagentsGitignore = ensureSubagentsGitignore;
-exports.createAgentHistoryPath = createAgentHistoryPath;
-exports.agentHistoryLocator = agentHistoryLocator;
-exports.resolveAgentHistoryPath = resolveAgentHistoryPath;
-exports.hasAgentHistory = hasAgentHistory;
-exports.readAgentHistory = readAgentHistory;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 const SUBAGENTS_DIR = ".pi-subagents";
 const TRANSCRIPTS_DIR = "agent-transcripts";
 const MAX_HISTORY_BYTES = 20 * 1024 * 1024;
@@ -19,65 +11,70 @@ const MAX_HISTORY_BYTES = 20 * 1024 * 1024;
  * existing user-owned rules and makes concurrent callers harmless (duplicate
  * `*` rules are semantically equivalent).
  */
-function ensureSubagentsGitignore(cwd) {
-    const directory = (0, node_path_1.join)(cwd, SUBAGENTS_DIR);
-    (0, node_fs_1.mkdirSync)(directory, { recursive: true });
-    const path = (0, node_path_1.join)(directory, ".gitignore");
+export function ensureSubagentsGitignore(cwd) {
+    const directory = join(cwd, SUBAGENTS_DIR);
+    mkdirSync(directory, { recursive: true });
+    const path = join(directory, ".gitignore");
     let content = "";
     try {
-        content = (0, node_fs_1.readFileSync)(path, "utf8");
+        content = readFileSync(path, "utf8");
     }
     catch {
         // The append below also creates a missing file.
     }
     if (!content.split(/\r?\n/).some((line) => line.trim() === "*")) {
         const separator = content.length > 0 && !/[\r\n]$/.test(content) ? "\n" : "";
-        (0, node_fs_1.appendFileSync)(path, `${separator}*\n`, "utf8");
+        appendFileSync(path, `${separator}*\n`, "utf8");
     }
     return path;
 }
 /** Return the durable transcript path for an agent. */
-function createAgentHistoryPath(cwd, agentId, agentType = "agent") {
+export function createAgentHistoryPath(cwd, agentId) {
     ensureSubagentsGitignore(cwd);
-    const directory = (0, node_path_1.join)(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
-    (0, node_fs_1.mkdirSync)(directory, { recursive: true });
+    const directory = join(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
+    mkdirSync(directory, { recursive: true });
     const safeId = agentId.replace(/[^A-Za-z0-9._-]+/g, "-") || "agent";
-    const safeType = agentType.replace(/[^A-Za-z0-9._-]+/g, "-") || "agent";
-    return (0, node_path_1.join)(directory, `${safeId}_${safeType}_transcript.jsonl`);
+    return join(directory, `${safeId}.jsonl`);
 }
 /** Return the project-relative path stored in the parent session record. */
-function agentHistoryLocator(cwd, historyPath) {
-    return (0, node_path_1.relative)(cwd, historyPath).split(node_path_1.sep).join("/");
+export function agentHistoryLocator(cwd, historyPath) {
+    return relative(cwd, historyPath).split(sep).join("/");
 }
 /** Resolve only paths in this package's project-local transcript namespace. */
-function resolveAgentHistoryPath(cwd, locator) {
-    if (!locator || (0, node_path_1.isAbsolute)(locator))
+export function resolveAgentHistoryPath(cwd, locator) {
+    // Locators are persisted data, not arbitrary paths. Reject traversal syntax
+    // before resolving so a path which normalizes back inside the namespace is
+    // still not accepted as an unsafe locator.
+    if (!locator || isAbsolute(locator) || locator.includes("\0") || locator.includes("\\"))
         return undefined;
-    const root = (0, node_path_1.resolve)(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
-    const candidate = (0, node_path_1.resolve)(cwd, locator);
-    if (candidate !== root && !candidate.startsWith(`${root}${node_path_1.sep}`))
+    const segments = locator.split("/");
+    if (segments.some((segment) => segment === ".." || segment === ""))
+        return undefined;
+    const root = resolve(cwd, SUBAGENTS_DIR, TRANSCRIPTS_DIR);
+    const candidate = resolve(cwd, locator);
+    if (candidate !== root && !candidate.startsWith(`${root}${sep}`))
         return undefined;
     return candidate;
 }
 /** Return true only when a valid project-local transcript file exists. */
-function hasAgentHistory(cwd, locator) {
+export function hasAgentHistory(cwd, locator) {
     if (!locator)
         return false;
     const path = resolveAgentHistoryPath(cwd, locator);
-    return path !== undefined && (0, node_fs_1.existsSync)(path);
+    return path !== undefined && existsSync(path);
 }
 /**
  * Read persisted transcript entries into the message shape used by the live
  * conversation viewer. Malformed lines and unknown records are skipped so one
  * damaged entry cannot hide the rest of a history.
  */
-function readAgentHistory(cwd, locator) {
+export function readAgentHistory(cwd, locator) {
     const path = resolveAgentHistoryPath(cwd, locator);
-    if (!path)
+    if (!path || !existsSync(path))
         return undefined;
     let raw;
     try {
-        raw = (0, node_fs_1.readFileSync)(path, "utf8");
+        raw = readFileSync(path, "utf8");
     }
     catch {
         return undefined;
@@ -90,7 +87,7 @@ function readAgentHistory(cwd, locator) {
             continue;
         try {
             const entry = JSON.parse(line);
-            const message = entry.message;
+            const message = entry?.message;
             if (!message || typeof message !== "object")
                 continue;
             const role = message.role;

package/dist/agent-manager.d.ts

@@ -16,6 +16,25 @@ export type CompactionInfo = {
     reason: "manual" | "threshold" | "overflow";
     tokensBefore: number;
 };
+type RestorableAgentStatus = "completed" | "steered" | "stopped" | "aborted" | "error";
+/** Validate one persisted terminal record without constructing runtime handles. */
+export declare function isRestorableAgentRecord(value: unknown): value is {
+    id: string;
+    type: string;
+    description: string;
+    status: RestorableAgentStatus;
+    startedAt: number;
+    completedAt: number;
+    result?: string;
+    error?: string;
+    toolUses?: number;
+    lifetimeUsage?: {
+        input: number;
+        output: number;
+        cacheWrite: number;
+    };
+    transcriptPath?: string;
+};
 interface SpawnOptions {
     description: string;
     model?: Model<any>;
@@ -121,15 +140,10 @@ export declare class AgentManager {
      */
     steer(id: string, message: string): boolean;
     getRecord(id: string): AgentRecord | undefined;
-    /**
-     * Restore terminal records persisted in a parent session.
-     *
-     * Restored records deliberately have no live session, promise, or abort
-     * controller. Invalid data is ignored because session entries are persisted
-     * extension data and may have been written by an older version.
-     */
-    restoreCompleted(records: readonly unknown[]): void;
     listAgents(): AgentRecord[];
+    /** Restore terminal records persisted by a parent branch without runtime handles. */
+    restoreCompleted(records: readonly unknown[]): void;
+    private createRestoredRecord;
     abort(id: string): boolean;
     /** Dispose a record's session and remove it from the map. */
     private removeRecord;

package/dist/agent-manager.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * agent-manager.ts — Tracks agents, background execution, resume support.
  *
@@ -6,23 +5,64 @@
  * Excess agents are queued and auto-started as running agents complete.
  * Foreground agents bypass the queue (they block the parent anyway).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentManager = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const agent_runner_js_1 = require("./agent-runner.js");
-const usage_js_1 = require("./usage.js");
-const worktree_js_1 = require("./worktree.js");
+import { randomUUID } from "node:crypto";
+import { statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { resumeAgent, runAgent } from "./agent-runner.js";
+import { addUsage } from "./usage.js";
+import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
-const TERMINAL_STATUSES = new Set([
-    "completed",
-    "steered",
-    "aborted",
-    "stopped",
-    "error",
-]);
+const RESTORABLE_STATUSES = new Set(["completed", "steered", "stopped", "aborted", "error"]);
+/** Narrow persisted strings before putting them into runtime/UI state. */
+function isSafePersistedString(value, maxLength) {
+    return typeof value === "string" && value.length > 0 && value.length <= maxLength && !/[\0\r\n]/.test(value);
+}
+function isFiniteTimestamp(value) {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function isValidUsage(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const usage = value;
+    return ["input", "output", "cacheWrite"].every((key) => {
+        const n = usage[key];
+        return typeof n === "number" && Number.isFinite(n) && n >= 0;
+    });
+}
+function isSafeTranscriptLocator(value) {
+    return typeof value === "string"
+        && /^\.pi-subagents\/agent-transcripts\/[^/]+\.jsonl$/.test(value)
+        && !value.includes("..")
+        && !value.includes("\\")
+        && !value.includes("\0");
+}
+/** Validate one persisted terminal record without constructing runtime handles. */
+export function isRestorableAgentRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    if (!isSafePersistedString(record.id, 256)
+        || !isSafePersistedString(record.type, 256)
+        || !isSafePersistedString(record.description, 4096)
+        || typeof record.status !== "string"
+        || !RESTORABLE_STATUSES.has(record.status)
+        || !isFiniteTimestamp(record.startedAt)
+        || !isFiniteTimestamp(record.completedAt)
+        || record.completedAt < record.startedAt)
+        return false;
+    if (record.result !== undefined && !isSafePersistedString(record.result, 2_000_000))
+        return false;
+    if (record.error !== undefined && !isSafePersistedString(record.error, 64_000))
+        return false;
+    if (record.toolUses !== undefined && (!Number.isInteger(record.toolUses) || record.toolUses < 0))
+        return false;
+    if (record.lifetimeUsage !== undefined && !isValidUsage(record.lifetimeUsage))
+        return false;
+    if (record.transcriptPath !== undefined && !isSafeTranscriptLocator(record.transcriptPath))
+        return false;
+    return true;
+}
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
  * (parent cwd). Anything else must be an absolute path to an existing
@@ -32,12 +72,12 @@ const TERMINAL_STATUSES = new Set([
 function assertValidSpawnCwd(cwd) {
     if (cwd == null)
         return;
-    if (typeof cwd !== "string" || !(0, node_path_1.isAbsolute)(cwd)) {
+    if (typeof cwd !== "string" || !isAbsolute(cwd)) {
         throw new Error(`SpawnOptions.cwd must be an absolute path: "${String(cwd)}"`);
     }
     let isDirectory = false;
     try {
-        isDirectory = (0, node_fs_1.statSync)(cwd).isDirectory();
+        isDirectory = statSync(cwd).isDirectory();
     }
     catch {
         throw new Error(`SpawnOptions.cwd does not exist: "${cwd}"`);
@@ -46,37 +86,7 @@ function assertValidSpawnCwd(cwd) {
         throw new Error(`SpawnOptions.cwd is not a directory: "${cwd}"`);
     }
 }
-const RESTORABLE_STATUSES = new Set([
-    "completed",
-    "steered",
-    "aborted",
-    "stopped",
-    "error",
-]);
-function isRestorableRecord(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const record = value;
-    const transcriptPath = record.transcriptPath;
-    const validTranscriptPath = transcriptPath === undefined ||
-        (typeof transcriptPath === "string" &&
-            transcriptPath.startsWith(".pi-subagents/agent-transcripts/") &&
-            !transcriptPath.includes("..") &&
-            !transcriptPath.includes("\\"));
-    return (typeof record.id === "string" &&
-        record.id.length > 0 &&
-        typeof record.type === "string" &&
-        typeof record.description === "string" &&
-        RESTORABLE_STATUSES.has(record.status) &&
-        typeof record.startedAt === "number" &&
-        Number.isFinite(record.startedAt) &&
-        typeof record.completedAt === "number" &&
-        Number.isFinite(record.completedAt) &&
-        (record.result === undefined || typeof record.result === "string") &&
-        (record.error === undefined || typeof record.error === "string") &&
-        validTranscriptPath);
-}
-class AgentManager {
+export class AgentManager {
     agents = new Map();
     cleanupInterval;
     onComplete;
@@ -117,7 +127,7 @@ class AgentManager {
         // call, not minutes later at drain. Throw (not warn): programmatic callers
         // can fix and retry; the RPC layer converts throws into error envelopes.
         assertValidSpawnCwd(options.cwd);
-        const id = (0, node_crypto_1.randomUUID)().slice(0, 17);
+        const id = randomUUID().slice(0, 17);
         const abortController = new AbortController();
         const record = {
             id,
@@ -170,7 +180,7 @@ class AgentManager {
         // BEFORE state mutation so a throw doesn't leave the record half-running.
         let worktreeCwd;
         if (options.isolation === "worktree") {
-            const wt = (0, worktree_js_1.createWorktree)(baseCwd, id);
+            const wt = createWorktree(baseCwd, id);
             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`.');
@@ -198,7 +208,7 @@ class AgentManager {
             detachParentSignal = () => options.signal.removeEventListener("abort", onParentAbort);
         }
         const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
-        const promise = (0, agent_runner_js_1.runAgent)(ctx, type, prompt, {
+        const promise = runAgent(ctx, type, prompt, {
             pi,
             agentId: id,
             model: options.model,
@@ -222,7 +232,7 @@ class AgentManager {
             onTurnEnd: options.onTurnEnd,
             onTextDelta: options.onTextDelta,
             onAssistantUsage: (usage) => {
-                (0, usage_js_1.addUsage)(record.lifetimeUsage, usage);
+                addUsage(record.lifetimeUsage, usage);
                 options.onAssistantUsage?.(usage);
             },
             onCompaction: (info) => {
@@ -273,7 +283,7 @@ class AgentManager {
             }
             // Clean up worktree if used
             if (record.worktree) {
-                const wtResult = (0, worktree_js_1.cleanupWorktree)(baseCwd, record.worktree, options.description);
+                const wtResult = cleanupWorktree(baseCwd, record.worktree, options.description);
                 record.worktreeResult = wtResult;
                 if (wtResult.hasChanges && wtResult.branch) {
                     // With a caller-supplied cwd the branch lives in THAT repo, not the
@@ -321,7 +331,7 @@ class AgentManager {
             // Best-effort worktree cleanup on error
             if (record.worktree) {
                 try {
-                    const wtResult = (0, worktree_js_1.cleanupWorktree)(baseCwd, record.worktree, options.description);
+                    const wtResult = cleanupWorktree(baseCwd, record.worktree, options.description);
                     record.worktreeResult = wtResult;
                 }
                 catch { /* ignore cleanup errors */ }
@@ -406,13 +416,13 @@ class AgentManager {
         record.result = undefined;
         record.error = undefined;
         try {
-            const { text, failure } = await (0, agent_runner_js_1.resumeAgent)(record.session, prompt, {
+            const { text, failure } = await resumeAgent(record.session, prompt, {
                 onToolActivity: (activity) => {
                     if (activity.type === "end")
                         record.toolUses++;
                 },
                 onAssistantUsage: (usage) => {
-                    (0, usage_js_1.addUsage)(record.lifetimeUsage, usage);
+                    addUsage(record.lifetimeUsage, usage);
                 },
                 onCompaction: (info) => {
                     record.compactionCount++;
@@ -462,43 +472,41 @@ class AgentManager {
     getRecord(id) {
         return this.agents.get(id);
     }
-    /**
-     * Restore terminal records persisted in a parent session.
-     *
-     * Restored records deliberately have no live session, promise, or abort
-     * controller. Invalid data is ignored because session entries are persisted
-     * extension data and may have been written by an older version.
-     */
+    listAgents() {
+        return [...this.agents.values()].sort((a, b) => b.startedAt - a.startedAt);
+    }
+    /** Restore terminal records persisted by a parent branch without runtime handles. */
     restoreCompleted(records) {
-        const restoredIds = new Set();
-        // getBranch() is chronological; newest persisted state wins on duplicate IDs.
-        for (const value of [...records].reverse()) {
-            if (!isRestorableRecord(value))
-                continue;
-            if (restoredIds.has(value.id) || this.agents.has(value.id))
+        const latest = new Map();
+        for (const value of records) {
+            if (isRestorableAgentRecord(value)) {
+                latest.set(value.id, this.createRestoredRecord(value));
+            }
+        }
+        for (const [id, restored] of latest) {
+            const existing = this.agents.get(id);
+            if (existing?.status === "running" || existing?.status === "queued")
                 continue;
-            restoredIds.add(value.id);
-            this.agents.set(value.id, {
-                id: value.id,
-                type: value.type,
-                description: value.description,
-                status: value.status,
-                result: value.result,
-                error: value.error,
-                transcriptPath: value.transcriptPath,
-                toolUses: 0,
-                startedAt: value.startedAt,
-                completedAt: value.completedAt,
-                lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-                compactionCount: 0,
-                // Historical records have no inline tool surface and should remain
-                // visible in the background widget.
-                isBackground: true,
-            });
+            this.agents.set(id, restored);
         }
     }
-    listAgents() {
-        return [...this.agents.values()].sort((a, b) => b.startedAt - a.startedAt);
+    createRestoredRecord(record) {
+        return {
+            id: record.id,
+            type: record.type,
+            description: record.description,
+            status: record.status,
+            result: record.result,
+            error: record.error,
+            toolUses: record.toolUses ?? 0,
+            startedAt: record.startedAt,
+            completedAt: record.completedAt,
+            transcriptPath: record.transcriptPath,
+            lifetimeUsage: record.lifetimeUsage
+                ? { ...record.lifetimeUsage }
+                : { input: 0, output: 0, cacheWrite: 0 },
+            compactionCount: 0,
+        };
     }
     abort(id) {
         const record = this.agents.get(id);
@@ -602,17 +610,16 @@ class AgentManager {
         this.agents.clear();
         // Prune any orphaned git worktrees (crash recovery)
         try {
-            (0, worktree_js_1.pruneWorktrees)(process.cwd());
+            pruneWorktrees(process.cwd());
         }
         catch { /* ignore */ }
         // Also prune repos that caller-supplied cwds created worktrees in — a clean
         // exit with in-flight agents would otherwise leave stale registrations there.
         for (const repo of this.worktreeRepos) {
             try {
-                (0, worktree_js_1.pruneWorktrees)(repo);
+                pruneWorktrees(repo);
             }
             catch { /* ignore */ }
         }
     }
 }
-exports.AgentManager = AgentManager;