@esso0428/pi-subagents 0.15.0 → 0.15.2

package/src/index.ts

@@ -48,6 +48,7 @@ import {
   type UICtx,
 } from "./ui/agent-widget.js";
 import { FleetList, type FleetUICtx } from "./ui/fleet-list.js";
+import { createMarkdownResult } from "./ui/markdown-result.js";
 import { showSchedulesMenu } from "./ui/schedule-menu.js";
 import { addUsage, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage } from "./usage.js";
 
@@ -240,6 +241,9 @@ function buildDetails(
   };
 }
 
+/** Maximum expanded notification body retained in message details. */
+const MAX_NOTIFICATION_RESULT_TEXT_LENGTH = 20_000;
+
 /** Build notification details for the custom message renderer. */
 function buildNotificationDetails(record: AgentRecord, resultMaxLen: number, activity?: AgentActivity): NotificationDetails {
   const totalTokens = getLifetimeTotal(record.lifetimeUsage);
@@ -255,6 +259,11 @@ function buildNotificationDetails(record: AgentRecord, resultMaxLen: number, act
     durationMs: record.completedAt ? record.completedAt - record.startedAt : 0,
     outputFile: record.outputFile,
     error: record.error,
+    resultText: record.result
+      ? record.result.length > MAX_NOTIFICATION_RESULT_TEXT_LENGTH
+        ? record.result.slice(0, MAX_NOTIFICATION_RESULT_TEXT_LENGTH) + "…"
+        : record.result
+      : undefined,
     resultPreview: record.result
       ? record.result.length > resultMaxLen
         ? record.result.slice(0, resultMaxLen) + "…"
@@ -271,7 +280,7 @@ export default function (pi: ExtensionAPI) {
       const d = message.details;
       if (!d) return undefined;
 
-      function renderOne(d: NotificationDetails): string {
+      function renderOne(d: NotificationDetails): string | Container {
         const isError = d.status === "error" || d.status === "stopped" || d.status === "aborted";
         const icon = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
         const statusText = isError ? d.status
@@ -291,25 +300,34 @@ export default function (pi: ExtensionAPI) {
           line += "\n  " + parts.map(p => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
         }
 
-        // Line 3: result preview (collapsed) or full (expanded)
-        if (expanded) {
-          const lines = d.resultPreview.split("\n").slice(0, 30);
-          for (const l of lines) line += "\n" + theme.fg("dim", `  ${l}`);
-        } else {
+        if (!expanded) {
+          // Collapsed previews intentionally remain compact plain text.
           const preview = d.resultPreview.split("\n")[0]?.slice(0, 80) ?? "";
           line += "\n  " + theme.fg("dim", `⎿  ${preview}`);
+          if (d.outputFile) {
+            line += "\n  " + theme.fg("muted", `transcript: ${d.outputFile}`);
+          }
+          return line;
         }
 
-        // Line 4: output file link (if present)
+        const container = new Container();
+        container.addChild(new Text(line, 0, 0));
+        container.addChild(createMarkdownResult(d.resultText ?? d.resultPreview, theme, 30));
         if (d.outputFile) {
-          line += "\n  " + theme.fg("muted", `transcript: ${d.outputFile}`);
+          container.addChild(new Text(theme.fg("muted", `  transcript: ${d.outputFile}`), 0, 0));
         }
-
-        return line;
+        return container;
       }
 
       const all = [d, ...(d.others ?? [])];
-      return new Text(all.map(renderOne).join("\n"), 0, 0);
+      if (!expanded) return new Text(all.map(renderOne).join("\n"), 0, 0);
+
+      const container = new Container();
+      all.forEach((item, index) => {
+        if (index > 0) container.addChild(new Spacer(1));
+        container.addChild(renderOne(item) as Container);
+      });
+      return container;
     }
   );
 
@@ -553,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) {
@@ -1024,15 +1047,15 @@ Terse command-style prompts produce shallow, generic work.
 
         if (expanded) {
           const resultText = result.content[0]?.type === "text" ? result.content[0].text : "";
+          const container = new Container();
+          container.addChild(new Text(line, 0, 0));
           if (resultText) {
-            const lines = resultText.split("\n").slice(0, 50);
-            for (const l of lines) {
-              line += "\n" + theme.fg("dim", `  ${l}`);
-            }
+            container.addChild(createMarkdownResult(resultText, theme, 50));
             if (resultText.split("\n").length > 50) {
-              line += "\n" + theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)");
+              container.addChild(new Text(theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)"), 0, 0));
             }
           }
+          return container;
         } else {
           const doneText = isSteered ? "Wrapped up (turn limit)" : "Done";
           line += "\n" + theme.fg("dim", `  ⎿  ${doneText}`);

package/src/types.ts

@@ -154,6 +154,7 @@ export interface NotificationDetails {
   outputFile?: string;
   error?: string;
   resultPreview: string;
+  resultText?: string;
   /** Additional agents in a group notification. */
   others?: NotificationDetails[];
 }

package/src/ui/markdown-result.ts

@@ -0,0 +1,56 @@
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Markdown, Text, type Component } from "@earendil-works/pi-tui";
+import type { Theme } from "./agent-widget.js";
+
+const TRUNCATION_MARKER = "… (more output available)";
+
+/**
+ * Render a child result as Markdown while keeping notification output bounded.
+ *
+ * Markdown is rendered at paint time so the TUI's current width controls wrapping.
+ * If the host's Markdown implementation is unavailable or throws, the original
+ * text is rendered through Text instead of making the result disappear.
+ */
+class CappedMarkdownResult implements Component {
+  private readonly text: string;
+  private readonly theme: Theme;
+  private readonly maxLines: number;
+  private markdown: Component | undefined;
+
+  constructor(text: string, theme: Theme, maxLines: number) {
+    this.text = text;
+    this.theme = theme;
+    this.maxLines = Math.max(0, Math.floor(maxLines));
+
+    try {
+      this.markdown = new Markdown(text, 0, 0, getMarkdownTheme());
+    } catch {
+      // A mismatched host Pi version should still leave the child output visible.
+    }
+  }
+
+  invalidate(): void {
+    this.markdown?.invalidate();
+  }
+
+  render(width: number): string[] {
+    let lines: string[];
+    try {
+      lines = this.markdown?.render(width) ?? new Text(this.text, 0, 0).render(width);
+    } catch {
+      lines = new Text(this.text, 0, 0).render(width);
+    }
+
+    if (lines.length <= this.maxLines) return lines;
+    if (this.maxLines === 0) return [];
+
+    return [
+      ...lines.slice(0, this.maxLines - 1),
+      this.theme.fg("muted", TRUNCATION_MARKER),
+    ];
+  }
+}
+
+export function createMarkdownResult(text: string, theme: Theme, maxLines: number): Component {
+  return new CappedMarkdownResult(text, theme, maxLines);
+}

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");
+  });
+});

package/test/ui/markdown-result.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { createMarkdownResult } from "../../src/ui/markdown-result.js";
+
+const theme = {
+  fg: (_name: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("createMarkdownResult", () => {
+  it("renders headings, lists, inline code, and fenced code", () => {
+    const component = createMarkdownResult(
+      [
+        "# Result",
+        "",
+        "- first",
+        "- `inline()`",
+        "",
+        "```ts",
+        "const answer: number = 42;",
+        "```",
+      ].join("\n"),
+      theme,
+      50,
+    );
+
+    const rendered = component.render(100).join("\n");
+    expect(rendered).toContain("Result");
+    expect(rendered).toContain("first");
+    expect(rendered).toContain("inline()");
+    expect(rendered).toContain("answer");
+  });
+
+  it("caps rendered lines and adds a truncation marker", () => {
+    const component = createMarkdownResult("line\n".repeat(20), theme, 5);
+    const rendered = component.render(80);
+
+    expect(rendered).toHaveLength(5);
+    expect(rendered.at(-1)).toContain("more");
+  });
+
+  it("keeps unlabelled code blocks safe without language guessing", () => {
+    const component = createMarkdownResult("```\nplain text\n```", theme, 20);
+    expect(component.render(80).join("\n")).toContain("plain text");
+  });
+});