@esso0428/pi-subagents 0.15.1 → 0.15.2

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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

package/dist/agent-manager.d.ts

@@ -121,6 +121,14 @@ 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[];
     abort(id: string): boolean;
     /** Dispose a record's session and remove it from the map. */

package/dist/agent-manager.js

@@ -16,6 +16,13 @@ const usage_js_1 = require("./usage.js");
 const worktree_js_1 = require("./worktree.js");
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "steered",
+    "aborted",
+    "stopped",
+    "error",
+]);
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
  * (parent cwd). Anything else must be an absolute path to an existing
@@ -39,6 +46,29 @@ 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;
+    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"));
+}
 class AgentManager {
     agents = new Map();
     cleanupInterval;
@@ -425,6 +455,40 @@ 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.
+     */
+    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))
+                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,
+                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,
+            });
+        }
+    }
     listAgents() {
         return [...this.agents.values()].sort((a, b) => b.startedAt - a.startedAt);
     }

package/dist/index.js

@@ -10,6 +10,39 @@
  * Commands:
  *   /agents                 — Interactive agent management menu
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderRunningAgentStatus = renderRunningAgentStatus;
 exports.default = default_1;
@@ -512,6 +545,11 @@ function default_1(pi) {
     pi.on("session_start", async (_event, ctx) => {
         currentCtx = ctx;
         manager.clearCompleted(true);
+        const historicalRecords = ctx.sessionManager
+            .getBranch()
+            .filter((entry) => entry?.type === "custom" && entry.customType === "subagents:record")
+            .map((entry) => entry.data);
+        manager.restoreCompleted(historicalRecords);
         // Guard mirrors the `!scheduler.isActive()` pattern below: session_start
         // fires once per activation, but a double-bind must not leak listeners.
         if (!rpcHandle) {
@@ -1611,7 +1649,7 @@ Terse command-style prompts produce shallow, generic work.
             ctx.ui.notify(`Agent is ${record.status === "queued" ? "queued" : "expired"} — no session available.`, "info");
             return;
         }
-        const { ConversationViewer, VIEWPORT_HEIGHT_PCT } = await import("./ui/conversation-viewer.js");
+        const { ConversationViewer, VIEWPORT_HEIGHT_PCT } = await Promise.resolve().then(() => __importStar(require("./ui/conversation-viewer.js")));
         const session = record.session;
         const activity = agentActivity.get(record.id);
         await ctx.ui.custom((tui, theme, keybindings, done) => {
@@ -1660,7 +1698,7 @@ Terse command-style prompts produce shallow, generic work.
             const content = (0, node_fs_1.readFileSync)(file.path, "utf-8");
             const edited = await ctx.ui.editor(`Edit ${name}`, content);
             if (edited !== undefined && edited !== content) {
-                const { writeFileSync } = await import("node:fs");
+                const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
                 writeFileSync(file.path, edited, "utf-8");
                 reloadCustomAgents();
                 ctx.ui.notify(`Updated ${file.path}`, "info");
@@ -1748,7 +1786,7 @@ Terse command-style prompts produce shallow, generic work.
         if (cfg.isolation)
             fmFields.push(`isolation: ${cfg.isolation}`);
         const content = `---\n${fmFields.join("\n")}\n---\n\n${cfg.systemPrompt}\n`;
-        const { writeFileSync } = await import("node:fs");
+        const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
         writeFileSync(targetPath, content, "utf-8");
         reloadCustomAgents();
         ctx.ui.notify(`Ejected ${name} to ${targetPath}`, "info");
@@ -1764,7 +1802,7 @@ Terse command-style prompts produce shallow, generic work.
                 return;
             }
             const updated = content.replace(/^---\n/, "---\nenabled: false\n");
-            const { writeFileSync } = await import("node:fs");
+            const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
             writeFileSync(file.path, updated, "utf-8");
             reloadCustomAgents();
             ctx.ui.notify(`Disabled ${name} (${file.path})`, "info");
@@ -1780,7 +1818,7 @@ Terse command-style prompts produce shallow, generic work.
         const targetDir = location.startsWith("Project") ? projectAgentsDir() : personalAgentsDir();
         (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
         const targetPath = (0, node_path_1.join)(targetDir, `${name}.md`);
-        const { writeFileSync } = await import("node:fs");
+        const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
         writeFileSync(targetPath, "---\nenabled: false\n---\n", "utf-8");
         reloadCustomAgents();
         ctx.ui.notify(`Disabled ${name} (${targetPath})`, "info");
@@ -1792,7 +1830,7 @@ Terse command-style prompts produce shallow, generic work.
             return;
         const content = (0, node_fs_1.readFileSync)(file.path, "utf-8");
         const updated = content.replace(/^(---\n)enabled: false\n/, "$1");
-        const { writeFileSync } = await import("node:fs");
+        const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
         // If the file was just a stub ("---\n---\n"), delete it to restore the built-in default
         if (updated.trim() === "---\n---" || updated.trim() === "---\n---\n") {
             (0, node_fs_1.unlinkSync)(file.path);
@@ -1975,7 +2013,7 @@ ${systemPrompt}
             if (!overwrite)
                 return;
         }
-        const { writeFileSync } = await import("node:fs");
+        const { writeFileSync } = await Promise.resolve().then(() => __importStar(require("node:fs")));
         writeFileSync(targetPath, content, "utf-8");
         reloadCustomAgents();
         ctx.ui.notify(`Created ${targetPath}`, "info");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esso0428/pi-subagents",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "A pi extension that brings smart Claude Code-style autonomous sub-agents to pi, with npm:pi-subagents-style JSON agent overrides.",
   "author": "ESSO0428",
   "repository": {

package/src/agent-manager.ts

@@ -23,6 +23,13 @@ export type CompactionInfo = { reason: "manual" | "threshold" | "overflow"; toke
 
 /** Default max concurrent background agents. */
 const DEFAULT_MAX_CONCURRENT = 4;
+const TERMINAL_STATUSES = new Set<AgentRecord["status"]>([
+  "completed",
+  "steered",
+  "aborted",
+  "stopped",
+  "error",
+]);
 
 /**
  * Validate a caller-supplied SpawnOptions.cwd. `undefined`/`null` mean "unset"
@@ -97,6 +104,37 @@ interface SpawnOptions {
   onCompaction?: (info: CompactionInfo) => void;
 }
 
+const RESTORABLE_STATUSES = new Set<AgentRecord["status"]>([
+  "completed",
+  "steered",
+  "aborted",
+  "stopped",
+  "error",
+]);
+
+type PersistedAgentRecord = Pick<
+  AgentRecord,
+  "id" | "type" | "description" | "status" | "result" | "error" | "startedAt" | "completedAt"
+>;
+
+function isRestorableRecord(value: unknown): value is PersistedAgentRecord {
+  if (!value || typeof value !== "object") return false;
+  const record = value as Record<string, unknown>;
+  return (
+    typeof record.id === "string" &&
+    record.id.length > 0 &&
+    typeof record.type === "string" &&
+    typeof record.description === "string" &&
+    RESTORABLE_STATUSES.has(record.status as AgentRecord["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")
+  );
+}
+
 export class AgentManager {
   private agents = new Map<string, AgentRecord>();
   private cleanupInterval: ReturnType<typeof setInterval>;
@@ -510,6 +548,40 @@ export class AgentManager {
     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.
+   */
+  restoreCompleted(records: readonly unknown[]): void {
+    const restoredIds = new Set<string>();
+    // 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)) 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,
+        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,
+      });
+    }
+  }
+
   listAgents(): AgentRecord[] {
     return [...this.agents.values()].sort(
       (a, b) => b.startedAt - a.startedAt,

package/src/index.ts

@@ -571,6 +571,11 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     currentCtx = ctx;
     manager.clearCompleted(true);
+    const historicalRecords = ctx.sessionManager
+      .getBranch()
+      .filter((entry: any) => entry?.type === "custom" && entry.customType === "subagents:record")
+      .map((entry: any) => entry.data);
+    manager.restoreCompleted(historicalRecords);
     // Guard mirrors the `!scheduler.isActive()` pattern below: session_start
     // fires once per activation, but a double-bind must not leak listeners.
     if (!rpcHandle) {

package/test/agent-manager-history.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { AgentManager } from "../src/agent-manager.js";
+
+type PersistedRecord = {
+  id: string;
+  type: string;
+  description: string;
+  status: string;
+  result?: unknown;
+  error?: unknown;
+  startedAt: number;
+  completedAt: number;
+};
+
+function persisted(overrides: Partial<PersistedRecord> = {}): PersistedRecord {
+  return {
+    id: "agent-1",
+    type: "general-purpose",
+    description: "history test",
+    status: "completed",
+    result: "restored result",
+    startedAt: 100,
+    completedAt: 200,
+    ...overrides,
+  };
+}
+
+describe("AgentManager.restoreCompleted", () => {
+  let manager: AgentManager | undefined;
+
+  afterEach(() => {
+    manager?.dispose();
+    manager = undefined;
+  });
+
+  it("restores terminal records without creating live runtime state", () => {
+    manager = new AgentManager();
+
+    manager.restoreCompleted([
+      persisted(),
+      persisted({ id: "agent-error", status: "error", error: "failed" }),
+      persisted({ id: "agent-running", status: "running" }),
+      persisted({ id: "agent-queued", status: "queued" }),
+      persisted({ id: "agent-invalid", completedAt: Number.NaN }),
+    ]);
+
+    expect(manager.listAgents().map((record) => record.id).sort()).toEqual([
+      "agent-1",
+      "agent-error",
+    ]);
+    const restored = manager.getRecord("agent-1");
+    expect(restored).toMatchObject({
+      status: "completed",
+      result: "restored result",
+      toolUses: 0,
+      lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
+      compactionCount: 0,
+      isBackground: true,
+    });
+    expect(restored?.session).toBeUndefined();
+    expect(restored?.promise).toBeUndefined();
+    expect(restored?.abortController).toBeUndefined();
+  });
+
+  it("uses the newest branch entry when an id appears more than once", () => {
+    manager = new AgentManager();
+
+    manager.restoreCompleted([
+      persisted({ result: "old", completedAt: 200 }),
+      persisted({ result: "new", completedAt: 300 }),
+    ]);
+
+    expect(manager.getRecord("agent-1")?.result).toBe("new");
+  });
+
+  it("does not overwrite a record already held by the manager", () => {
+    manager = new AgentManager();
+
+    manager.restoreCompleted([persisted({ result: "first" })]);
+    manager.restoreCompleted([persisted({ result: "second" })]);
+
+    expect(manager.getRecord("agent-1")?.result).toBe("first");
+  });
+});