@esso0428/pi-subagents 0.15.2 → 0.15.4

package/dist/ui/fleet-list.js

@@ -16,6 +16,7 @@ exports.FleetList = void 0;
 exports.formatFleetElapsed = formatFleetElapsed;
 exports.formatFleetTokens = formatFleetTokens;
 const pi_tui_1 = require("@earendil-works/pi-tui");
+const agent_history_js_1 = require("../agent-history.js");
 const usage_js_1 = require("../usage.js");
 const agent_widget_js_1 = require("./agent-widget.js");
 const conversation_viewer_js_1 = require("./conversation-viewer.js");
@@ -57,6 +58,7 @@ function rightAlign(left, right, width) {
 class FleetList {
     manager;
     agentActivity;
+    getCwd;
     ui;
     tui;
     inputUnsub;
@@ -70,9 +72,10 @@ class FleetList {
     /** Set while a conversation overlay is open; calling it closes the overlay. */
     viewerClose;
     viewingAgentId;
-    constructor(manager, agentActivity) {
+    constructor(manager, agentActivity, getCwd = () => undefined) {
         this.manager = manager;
         this.agentActivity = agentActivity;
+        this.getCwd = getCwd;
     }
     // ---- Lifecycle ----
     setEnabled(enabled) {
@@ -163,18 +166,25 @@ class FleetList {
     // ---- Roster ----
     /**
      * Agents shown in the list, ordered earliest-launched first so the ones you
-     * started sooner sit at the top. Every row is openable (has a session), so Enter
-     * never dead-ends. Included: running/queued, plus the agent currently being
-     * viewed, plus recently-finished ones (they linger briefly before dropping out).
+     * started sooner sit at the top. Live rows are openable through their session;
+     * terminal rows are included only when their durable transcript exists. This
+     * prevents Enter from dead-ending on stale rehydrated metadata.
+     * Included: running/queued, plus the agent currently being viewed, plus
+     * recently-finished ones (they linger briefly before dropping out).
      * Pending agents with no session yet are hidden until they start.
      * (`listAgents()` is newest-first, so we re-sort.)
      */
     agentRecords() {
         const now = Date.now();
         return this.manager.listAgents()
-            .filter(a => a.session && (a.status === "running" || a.status === "queued"
-            || a.id === this.viewingAgentId
-            || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS)))
+            .filter(a => {
+            const live = a.session && (a.status === "running" || a.status === "queued"
+                || a.id === this.viewingAgentId
+                || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS));
+            const cwd = this.getCwd();
+            const history = cwd !== undefined && (0, agent_history_js_1.hasAgentHistory)(cwd, a.transcriptPath);
+            return !!live || history;
+        })
             .sort((a, b) => a.startedAt - b.startedAt);
     }
     roster() {
@@ -275,19 +285,25 @@ class FleetList {
         const record = entry.record;
         if (!this.ui)
             return;
-        if (!record.session) {
-            this.ui.notify(`Agent is ${record.status} — no session available.`, "info");
+        const session = record.session ?? (record.transcriptPath && this.getCwd()
+            ? (() => {
+                const messages = (0, agent_history_js_1.readAgentHistory)(this.getCwd(), record.transcriptPath);
+                return messages ? (0, conversation_viewer_js_1.createStaticConversationSource)(messages) : undefined;
+            })()
+            : undefined);
+        if (!session) {
+            this.ui.notify(`Agent is ${record.status} — no history available.`, "info");
             return;
         }
-        const session = record.session;
         const activity = this.agentActivity.get(record.id);
+        const isLive = record.session !== undefined;
         this.viewingAgentId = record.id;
         void this.ui.custom((tui, theme, keybindings, done) => {
             this.viewerClose = () => done(undefined);
-            return new conversation_viewer_js_1.ConversationViewer(tui, session, record, activity, theme, done, () => {
+            return new conversation_viewer_js_1.ConversationViewer(tui, session, record, activity, theme, done, isLive ? () => {
                 if (this.manager.abort(record.id))
                     this.ui?.notify(`Stopped "${record.description}".`, "info");
-            }, keybindings, (message) => this.manager.steer(record.id, message));
+            } : undefined, keybindings, isLive ? (message) => this.manager.steer(record.id, message) : undefined);
         }, {
             overlay: true,
             overlayOptions: { anchor: "center", width: "90%", maxHeight: `${conversation_viewer_js_1.VIEWPORT_HEIGHT_PCT}%` },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esso0428/pi-subagents",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "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-history.ts

@@ -0,0 +1,107 @@
+/** Durable, project-local transcript storage for subagents. */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+
+const SUBAGENTS_DIR = ".pi-subagents";
+const TRANSCRIPTS_DIR = "agent-transcripts";
+const MAX_HISTORY_BYTES = 20 * 1024 * 1024;
+
+/**
+ * Ensure project-local subagent artifacts are ignored by git.
+ *
+ * The rule is appended instead of rewriting the file. This preserves any
+ * existing user-owned rules and makes concurrent callers harmless (duplicate
+ * `*` rules are semantically equivalent).
+ */
+export function ensureSubagentsGitignore(cwd: string): string {
+  const directory = join(cwd, SUBAGENTS_DIR);
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, ".gitignore");
+
+  let content = "";
+  try {
+    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" : "";
+    appendFileSync(path, `${separator}*\n`, "utf8");
+  }
+  return path;
+}
+
+/** Return the durable transcript path for an agent. */
+export function createAgentHistoryPath(
+  cwd: string,
+  agentId: string,
+  agentType = "agent",
+): string {
+  ensureSubagentsGitignore(cwd);
+  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 join(directory, `${safeId}_${safeType}_transcript.jsonl`);
+}
+
+/** Return the project-relative path stored in the parent session record. */
+export function agentHistoryLocator(cwd: string, historyPath: string): string {
+  return relative(cwd, historyPath).split(sep).join("/");
+}
+
+/** Resolve only paths in this package's project-local transcript namespace. */
+export function resolveAgentHistoryPath(cwd: string, locator: string): string | undefined {
+  if (!locator || isAbsolute(locator)) 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. */
+export function hasAgentHistory(cwd: string, locator: string | undefined): boolean {
+  if (!locator) return false;
+  const path = resolveAgentHistoryPath(cwd, locator);
+  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.
+ */
+export function readAgentHistory(
+  cwd: string,
+  locator: string,
+): AgentSession["messages"] | undefined {
+  const path = resolveAgentHistoryPath(cwd, locator);
+  if (!path) return undefined;
+
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return undefined;
+  }
+  if (raw.length > MAX_HISTORY_BYTES) raw = raw.slice(0, MAX_HISTORY_BYTES);
+
+  const messages: AgentSession["messages"] = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line) as { message?: unknown };
+      const message = entry.message;
+      if (!message || typeof message !== "object") continue;
+      const role = (message as { role?: unknown }).role;
+      if (typeof role !== "string") continue;
+      messages.push(message as AgentSession["messages"][number]);
+    } catch {
+      // Ignore malformed/truncated JSONL records.
+    }
+  }
+  return messages.length > 0 ? messages : undefined;
+}

package/src/agent-manager.ts

@@ -114,12 +114,19 @@ const RESTORABLE_STATUSES = new Set<AgentRecord["status"]>([
 
 type PersistedAgentRecord = Pick<
   AgentRecord,
-  "id" | "type" | "description" | "status" | "result" | "error" | "startedAt" | "completedAt"
+  "id" | "type" | "description" | "status" | "result" | "error" | "startedAt" | "completedAt" | "transcriptPath"
 >;
 
 function isRestorableRecord(value: unknown): value is PersistedAgentRecord {
   if (!value || typeof value !== "object") return false;
   const record = value as Record<string, unknown>;
+  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 &&
@@ -131,7 +138,8 @@ function isRestorableRecord(value: unknown): value is PersistedAgentRecord {
     typeof record.completedAt === "number" &&
     Number.isFinite(record.completedAt) &&
     (record.result === undefined || typeof record.result === "string") &&
-    (record.error === undefined || typeof record.error === "string")
+    (record.error === undefined || typeof record.error === "string") &&
+    validTranscriptPath
   );
 }
 
@@ -570,6 +578,7 @@ export class AgentManager {
         status: value.status,
         result: value.result,
         error: value.error,
+        transcriptPath: value.transcriptPath,
         toolUses: 0,
         startedAt: value.startedAt,
         completedAt: value.completedAt,

package/src/index.ts

@@ -24,6 +24,7 @@ import { isModelInScope, readEnabledModels, resolveEnabledModels } from "./enabl
 import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
+import { agentHistoryLocator, createAgentHistoryPath, ensureSubagentsGitignore, hasAgentHistory, readAgentHistory } from "./agent-history.js";
 import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "./output-file.js";
 import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
@@ -462,11 +463,14 @@ export default function (pi: ExtensionAPI) {
       pi.events.emit("subagents:completed", eventData);
     }
 
-    // Persist final record for cross-extension history reconstruction
+    // Persist final record for cross-extension history reconstruction. Keep
+    // the transcript body in a project-local file rather than inflating the
+    // parent session JSONL; only its project-relative locator is persisted.
     pi.appendEntry("subagents:record", {
       id: record.id, type: record.type, description: record.description,
       status: record.status, result: record.result, error: record.error,
       startedAt: record.startedAt, completedAt: record.completedAt,
+      transcriptPath: record.transcriptPath,
     });
 
     // Skip notification if result was already consumed via get_subagent_result
@@ -570,12 +574,22 @@ export default function (pi: ExtensionAPI) {
   // bound session_start, so a filtered-out activation never advertises (#142).
   pi.on("session_start", async (_event, ctx) => {
     currentCtx = ctx;
+    try {
+      ensureSubagentsGitignore(ctx.cwd);
+    } catch (err) {
+      console.warn("[pi-subagents] Failed to protect project-local history:", err);
+    }
     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);
+    // Bind the UI here as well as on tool execution so rehydrated terminal
+    // records are immediately visible and openable from FleetView after reload.
+    widget.setUICtx(ctx.ui as UICtx);
+    fleet.setUICtx(ctx.ui as unknown as FleetUICtx);
+    fleet.update();
     // Guard mirrors the `!scheduler.isActive()` pattern below: session_start
     // fires once per activation, but a double-bind must not leak listeners.
     if (!rpcHandle) {
@@ -626,11 +640,11 @@ export default function (pi: ExtensionAPI) {
   // everything else; "off" = hide the widget entirely. Read live at render time.
   let widgetMode: WidgetMode = "background";
   function getWidgetMode(): WidgetMode { return widgetMode; }
-  const widget = new AgentWidget(manager, agentActivity, getWidgetMode);
+  const widget = new AgentWidget(manager, agentActivity, getWidgetMode, () => currentCtx?.cwd);
   function setWidgetMode(m: WidgetMode): void { widgetMode = m; widget.update(); }
 
   // Claude Code-style FleetView: navigable list of main + subagents below the editor.
-  const fleet = new FleetList(manager, agentActivity);
+  const fleet = new FleetList(manager, agentActivity, () => currentCtx?.cwd);
   let fleetViewEnabled = true;
   function isFleetViewEnabled(): boolean { return fleetViewEnabled; }
   function setFleetViewEnabled(b: boolean): void { fleetViewEnabled = b; fleet.setEnabled(b); }
@@ -1161,6 +1175,19 @@ Terse command-style prompts produce shallow, generic work.
         if (!rec || !outputTranscript) return;
         rec.outputFile = createOutputFilePath(ctx.cwd, agentId, ctx.sessionManager.getSessionId());
         writeInitialEntry(rec.outputFile, agentId, params.prompt, ctx.cwd);
+
+        // Keep the existing /tmp output for compatibility, while also writing a
+        // durable project-local copy for reload-safe, read-only history viewing.
+        try {
+          rec.historyFile = createAgentHistoryPath(ctx.cwd, agentId, subagentType);
+          rec.transcriptPath = agentHistoryLocator(ctx.cwd, rec.historyFile);
+          writeInitialEntry(rec.historyFile, agentId, params.prompt, ctx.cwd);
+        } catch (err) {
+          // History is best effort; never disable the existing output transcript.
+          rec.historyFile = undefined;
+          rec.transcriptPath = undefined;
+          console.warn("[pi-subagents] Failed to create durable transcript:", err);
+        }
       };
 
       const parentModelId = ctx.model?.id;
@@ -1270,7 +1297,7 @@ Terse command-style prompts produce shallow, generic work.
           origBgOnSession(session);
           const rec = manager.getRecord(id);
           if (rec?.outputFile) {
-            rec.outputCleanup = streamToOutputFile(session, rec.outputFile, id, ctx.cwd);
+            rec.outputCleanup = streamToOutputFile(session, rec.outputFile, id, ctx.cwd, rec.historyFile);
           }
         };
 
@@ -1386,7 +1413,7 @@ Terse command-style prompts produce shallow, generic work.
         if (fgId) {
           const rec = manager.getRecord(fgId);
           if (rec?.outputFile) {
-            rec.outputCleanup = streamToOutputFile(session, rec.outputFile, fgId, ctx.cwd);
+            rec.outputCleanup = streamToOutputFile(session, rec.outputFile, fgId, ctx.cwd, rec.historyFile);
           }
         }
       };
@@ -1762,7 +1789,9 @@ Terse command-style prompts produce shallow, generic work.
   }
 
   async function showRunningAgents(ctx: ExtensionCommandContext) {
-    const agents = manager.listAgents();
+    const agents = manager.listAgents().filter((record) =>
+      record.session !== undefined || hasAgentHistory(ctx.cwd, record.transcriptPath),
+    );
     if (agents.length === 0) {
       ctx.ui.notify("No agents.", "info");
       return;
@@ -1793,17 +1822,30 @@ Terse command-style prompts produce shallow, generic work.
       return;
     }
 
-    const { ConversationViewer, VIEWPORT_HEIGHT_PCT } = await import("./ui/conversation-viewer.js");
-    const session = record.session;
+    const { ConversationViewer, VIEWPORT_HEIGHT_PCT, createStaticConversationSource } = await import("./ui/conversation-viewer.js");
+    const session = record.session ?? (record.transcriptPath
+      ? (() => {
+          const messages = readAgentHistory(ctx.cwd, record.transcriptPath!);
+          return messages ? createStaticConversationSource(messages) : undefined;
+        })()
+      : undefined);
+    if (!session) {
+      ctx.ui.notify(`Agent is ${record.status === "queued" ? "queued" : "expired"} — no history available.`, "info");
+      return;
+    }
     const activity = agentActivity.get(record.id);
+    const isLive = record.session !== undefined;
 
     await ctx.ui.custom<undefined>(
       (tui, theme, keybindings, done) => {
-        return new ConversationViewer(tui, session, record, activity, theme, done, () => {
-          if (manager.abort(record.id)) {
-            ctx.ui.notify(`Stopped "${record.description}".`, "info");
-          }
-        }, keybindings, (message: string) => manager.steer(record.id, message));
+        return new ConversationViewer(tui, session, record, activity, theme, done,
+          isLive ? () => {
+            if (manager.abort(record.id)) {
+              ctx.ui.notify(`Stopped "${record.description}".`, "info");
+            }
+          } : undefined,
+          keybindings,
+          isLive ? (message: string) => manager.steer(record.id, message) : undefined);
       },
       {
         overlay: true,

package/src/output-file.ts

@@ -63,7 +63,9 @@ export function streamToOutputFile(
   path: string,
   agentId: string,
   cwd: string,
+  historyPath?: string,
 ): () => void {
+  const outputPaths = historyPath && historyPath !== path ? [path, historyPath] : [path];
   let writtenCount = 1; // initial user prompt already written
 
   const flush = () => {
@@ -78,9 +80,11 @@ export function streamToOutputFile(
         timestamp: new Date().toISOString(),
         cwd,
       };
-      try {
-        appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
-      } catch { /* ignore write errors */ }
+      for (const outputPath of outputPaths) {
+        try {
+          appendFileSync(outputPath, JSON.stringify(entry) + "\n", "utf-8");
+        } catch { /* ignore write errors */ }
+      }
       writtenCount++;
     }
   };

package/src/types.ts

@@ -105,6 +105,10 @@ export interface AgentRecord {
   toolCallId?: string;
   /** Path to the streaming output transcript file. */
   outputFile?: string;
+  /** Absolute path to the durable project-local transcript while live. */
+  historyFile?: string;
+  /** Project-relative durable transcript path persisted in the parent session. */
+  transcriptPath?: string;
   /** Cleanup function for the output file stream subscription. */
   outputCleanup?: () => void;
   /**

package/src/ui/agent-widget.ts

@@ -6,6 +6,7 @@
  */
 
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { hasAgentHistory } from "../agent-history.js";
 import type { AgentManager } from "../agent-manager.js";
 import { getConfig } from "../agent-types.js";
 import type { AgentInvocation, SubagentType, WidgetMode } from "../types.js";
@@ -237,6 +238,8 @@ export class AgentWidget {
      * extension supplies one defaulting to `"background"`.
      */
     private mode: () => WidgetMode = () => "all",
+    /** Current project cwd used to validate reload-restored transcripts. */
+    private getCwd: () => string | undefined = () => undefined,
   ) {}
 
   /**
@@ -251,7 +254,11 @@ export class AgentWidget {
    *   - `all`: every agent.
    */
   private widgetAgents() {
-    const all = this.manager.listAgents();
+    const all = this.manager.listAgents().filter((record) => {
+      if (record.status === "running" || record.status === "queued") return true;
+      const cwd = this.getCwd();
+      return cwd !== undefined && hasAgentHistory(cwd, record.transcriptPath);
+    });
     switch (this.mode()) {
       case "off": return [];
       case "background": return all.filter(a => a.isBackground !== false);

package/src/ui/conversation-viewer.ts

@@ -20,6 +20,15 @@ const MIN_VIEWPORT = 3;
 /** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
 export const VIEWPORT_HEIGHT_PCT = 70;
 
+/** The live fields needed by the viewer; historical viewers use a static source. */
+export type ConversationSource = Pick<AgentSession, "messages" | "subscribe">;
+
+export function createStaticConversationSource(
+  messages: AgentSession["messages"],
+): ConversationSource {
+  return { messages, subscribe: () => () => {} };
+}
+
 export class ConversationViewer implements Component {
   private scrollOffset = 0;
   private autoScroll = true;
@@ -34,7 +43,7 @@ export class ConversationViewer implements Component {
 
   constructor(
     private tui: TUI,
-    private session: AgentSession,
+    private session: ConversationSource,
     private record: AgentRecord,
     private activity: AgentActivity | undefined,
     private theme: Theme,

package/src/ui/fleet-list.ts

@@ -13,10 +13,11 @@
 
 import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
+import { hasAgentHistory, readAgentHistory } from "../agent-history.js";
 import type { AgentRecord } from "../types.js";
 import { getLifetimeTotal } from "../usage.js";
 import { type AgentActivity, getDisplayName, type Theme } from "./agent-widget.js";
-import { ConversationViewer, VIEWPORT_HEIGHT_PCT } from "./conversation-viewer.js";
+import { ConversationViewer, createStaticConversationSource, VIEWPORT_HEIGHT_PCT } from "./conversation-viewer.js";
 
 /** Widget key for the below-editor fleet list. */
 const FLEET_KEY = "fleet";
@@ -93,6 +94,7 @@ export class FleetList {
   constructor(
     private manager: AgentManager,
     private agentActivity: Map<string, AgentActivity>,
+    private getCwd: () => string | undefined = () => undefined,
   ) {}
 
   // ---- Lifecycle ----
@@ -179,20 +181,27 @@ export class FleetList {
 
   /**
    * Agents shown in the list, ordered earliest-launched first so the ones you
-   * started sooner sit at the top. Every row is openable (has a session), so Enter
-   * never dead-ends. Included: running/queued, plus the agent currently being
-   * viewed, plus recently-finished ones (they linger briefly before dropping out).
+   * started sooner sit at the top. Live rows are openable through their session;
+   * terminal rows are included only when their durable transcript exists. This
+   * prevents Enter from dead-ending on stale rehydrated metadata.
+   * Included: running/queued, plus the agent currently being viewed, plus
+   * recently-finished ones (they linger briefly before dropping out).
    * Pending agents with no session yet are hidden until they start.
    * (`listAgents()` is newest-first, so we re-sort.)
    */
   private agentRecords(): AgentRecord[] {
     const now = Date.now();
     return this.manager.listAgents()
-      .filter(a => a.session && (
-        a.status === "running" || a.status === "queued"
-        || a.id === this.viewingAgentId
-        || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS)
-      ))
+      .filter(a => {
+        const live = a.session && (
+          a.status === "running" || a.status === "queued"
+          || a.id === this.viewingAgentId
+          || (a.completedAt != null && now - a.completedAt < FINISHED_LINGER_MS)
+        );
+        const cwd = this.getCwd();
+        const history = cwd !== undefined && hasAgentHistory(cwd, a.transcriptPath);
+        return !!live || history;
+      })
       .sort((a, b) => a.startedAt - b.startedAt);
   }
 
@@ -287,12 +296,18 @@ 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");
+    const session = record.session ?? (record.transcriptPath && this.getCwd()
+      ? (() => {
+          const messages = readAgentHistory(this.getCwd()!, record.transcriptPath!);
+          return messages ? createStaticConversationSource(messages) : undefined;
+        })()
+      : undefined);
+    if (!session) {
+      this.ui.notify(`Agent is ${record.status} — no history available.`, "info");
       return;
     }
-    const session = record.session;
     const activity = this.agentActivity.get(record.id);
+    const isLive = record.session !== undefined;
     this.viewingAgentId = record.id;
 
     void this.ui.custom<undefined>(
@@ -305,11 +320,11 @@ export class FleetList {
           activity,
           theme,
           done,
-          () => {
+          isLive ? () => {
             if (this.manager.abort(record.id)) this.ui?.notify(`Stopped "${record.description}".`, "info");
-          },
+          } : undefined,
           keybindings,
-          (message: string) => this.manager.steer(record.id, message),
+          isLive ? (message: string) => this.manager.steer(record.id, message) : undefined,
         );
       },
       {

package/test/agent-history.test.ts

@@ -0,0 +1,63 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  agentHistoryLocator,
+  createAgentHistoryPath,
+  ensureSubagentsGitignore,
+  hasAgentHistory,
+  readAgentHistory,
+  resolveAgentHistoryPath,
+} from "../src/agent-history.js";
+import { writeInitialEntry } from "../src/output-file.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+function tempProject(): string {
+  const path = mkdtempSync(join(tmpdir(), "pi-subagents-history-test-"));
+  tempDirectories.push(path);
+  return path;
+}
+
+describe("project-local subagent history", () => {
+  it("creates a gitignore rule and preserves existing rules", () => {
+    const cwd = tempProject();
+    const root = join(cwd, ".pi-subagents");
+    const gitignore = join(root, ".gitignore");
+    const path = ensureSubagentsGitignore(cwd);
+
+    expect(path).toBe(gitignore);
+    expect(readFileSync(gitignore, "utf8")).toBe("*\n");
+
+    writeFileSync(gitignore, "keep-this\n", "utf8");
+    ensureSubagentsGitignore(cwd);
+    ensureSubagentsGitignore(cwd);
+    expect(readFileSync(gitignore, "utf8")).toBe("keep-this\n*\n");
+  });
+
+  it("creates a bounded project-relative transcript locator", () => {
+    const cwd = tempProject();
+    const historyPath = createAgentHistoryPath(cwd, "agent-1", "Explore");
+    const locator = agentHistoryLocator(cwd, historyPath);
+
+    expect(locator).toBe(".pi-subagents/agent-transcripts/agent-1_Explore_transcript.jsonl");
+    expect(resolveAgentHistoryPath(cwd, locator)).toBe(historyPath);
+    expect(hasAgentHistory(cwd, locator)).toBe(false);
+    expect(hasAgentHistory(cwd, ".pi-subagents/other.jsonl")).toBe(false);
+    expect(resolveAgentHistoryPath(cwd, ".pi-subagents/other.jsonl")).toBeUndefined();
+    expect(resolveAgentHistoryPath(cwd, ".pi-subagents/agent-transcripts/../other.jsonl")).toBeUndefined();
+
+    writeInitialEntry(historyPath, "agent-1", "hello", cwd);
+    expect(hasAgentHistory(cwd, locator)).toBe(true);
+    const messages = readAgentHistory(cwd, locator);
+    expect(messages).toHaveLength(1);
+    expect(messages?.[0]).toMatchObject({ role: "user", content: "hello" });
+  });
+});