@hheei/pi-subagents 0.2.4 → 0.4.0

package/dist/extension.d.ts

@@ -1,6 +1,6 @@
-import type { ExtensionAPI, Skill } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionUIContext, Skill } from "@earendil-works/pi-coding-agent";
 import { type BackgroundDelivery } from "@hheei/pi-ext-core";
-import type { SkillCatalogEntry } from "./agent-resolver.js";
+import { type SkillCatalogEntry } from "./agent-resolver.js";
 import { type ParentChannel } from "./manager.js";
 /** Parent channel plus the teardown its owner must call. */
 export interface ParentChannelHandle extends ParentChannel {
@@ -10,12 +10,13 @@ export interface ParentChannelHandle extends ParentChannel {
 /**
  * How child reports reach the parent conversation.
  *
- * Busy parents receive a steer into the next model step. Idle parents wait until all registered
- * background work finishes; decision requests and blockers bypass that wait. The shared gate
- * coordinates this channel with Task/Bash results so only one message requests a new idle turn.
+ * Busy parents receive a steer into the next model step. Idle parents get one new turn per
+ * microtask batch; the shared coordinator makes this channel and the Bash one agree on which
+ * message requests it.
  */
-export declare function createParentChannel(pi: Pick<ExtensionAPI, "sendMessage" | "on">, deps: {
+export declare function createParentChannel(pi: Pick<ExtensionAPI, "sendMessage" | "on" | "appendEntry">, deps: {
     readonly isIdle: () => boolean;
+    readonly ui: Pick<ExtensionUIContext, "notify">;
     readonly delivery: BackgroundDelivery;
     readonly signal?: AbortSignal;
 }): ParentChannelHandle;

package/dist/extension.js

@@ -1,18 +1,19 @@
-import { errorMessage, getBackgroundDelivery, registerExtensionLifecycle, TASK_REGISTRY_SERVICE_KEY, waitForService, } from "@hheei/pi-ext-core";
-import { ChildBridgeServer } from "./bridge-server.js";
+import { errorMessage, getBackgroundDelivery, registerExtensionLifecycle, } from "@hheei/pi-ext-core";
+import { discoverAgents } from "./agent-resolver.js";
 import { registerChildBridge } from "./child-bridge.js";
-import { bindParentStatus, registerParentCommands } from "./commands.js";
+import { registerParentCommands } from "./commands.js";
 import { BRIDGE_ENVIRONMENT_KEYS, isThinkingLevel } from "./domain.js";
-import { createCmuxHostAdapter, createHerdrHostAdapter, selectHostAdapter, } from "./host-adapter.js";
+import { createCmuxHostAdapter, createHerdrHostAdapter, listCmuxAttachments, listHerdrAttachments, rebindCmuxSurface, rebindHerdrTab, selectHostAdapter, systemHostCommandRunner, } from "./host-adapter.js";
+import { appendSubagentInfo, displaySubagentText, registerSubagentInfo } from "./info.js";
+import { createMailboxTransport } from "./mailbox.js";
 import { SubagentManager } from "./manager.js";
 import { transformSubagentsMarkdown } from "./markdown.js";
 import { createSubagentRegistry } from "./registry.js";
-import { createRuntimeTokenStore, launchChild, openChildPanel, parentBridgeEndpoint, prepareRuntimeDirectory, } from "./runtime.js";
+import { createRuntimeTokenStore, launchChild, openChildPanel, prepareRuntimeDirectory, } from "./runtime.js";
 import { persistSubagentIntent, resolveSubagentLaunch } from "./session-bootstrap.js";
-import { resolveForkSessionReference } from "./session-fork.js";
+import { createSubagentStatus } from "./status.js";
 import { registerInteractiveToolActivation } from "./tool-activation.js";
 import { registerParentTools } from "./tools.js";
-import { createSubagentWidget } from "./widget.js";
 const CHILD_ENV_KEYS = Object.values(BRIDGE_ENVIRONMENT_KEYS);
 /** How long startup waits for a child that survived a parent restart to reconnect its bridge. */
 const ADOPT_WINDOW_MS = 5_000;
@@ -44,26 +45,23 @@ function childIdentityFromEnv(env) {
 /**
  * How child reports reach the parent conversation.
  *
- * Busy parents receive a steer into the next model step. Idle parents wait until all registered
- * background work finishes; decision requests and blockers bypass that wait. The shared gate
- * coordinates this channel with Task/Bash results so only one message requests a new idle turn.
+ * Busy parents receive a steer into the next model step. Idle parents get one new turn per
+ * microtask batch; the shared coordinator makes this channel and the Bash one agree on which
+ * message requests it.
  */
 export function createParentChannel(pi, deps) {
     const held = [];
     let disposed = false;
-    const flush = (triggerTurn, urgentOnly = false) => {
+    const flush = (triggerTurn) => {
         if (held.length === 0)
             return;
-        const reports = urgentOnly ? held.filter((report) => report.reason === "blocked") : [...held];
-        if (reports.length === 0)
-            return;
-        for (const report of reports)
-            held.splice(held.indexOf(report), 1);
+        const reports = [...held];
+        held.length = 0;
         try {
             pi.sendMessage({
                 customType: "subagent-report",
                 content: reports.map(reportText).join("\n\n"),
-                display: true,
+                display: false,
                 details: { reports },
             }, { triggerTurn, deliverAs: "steer" });
         }
@@ -71,6 +69,15 @@ export function createParentChannel(pi, deps) {
             held.unshift(...reports);
             throw error;
         }
+        for (const report of reports) {
+            try {
+                appendSubagentInfo(pi, report);
+            }
+            catch (error) {
+                // The model already received this batch; an entry failure must not resend it.
+                deps.ui.notify(displaySubagentText(`Could not display subagent report for ${report.childId}: ${errorMessage(error)}`), "error");
+            }
+        }
     };
     const registration = deps.delivery.registerChannel({
         isIdle: deps.isIdle,
@@ -84,7 +91,7 @@ export function createParentChannel(pi, deps) {
             if (disposed)
                 throw new Error("Parent report channel is disposed");
             held.push(report);
-            registration.request(report.reason === "blocked");
+            registration.request();
         },
         dispose() {
             disposed = true;
@@ -113,6 +120,7 @@ export default function piSubagentsExtension(pi) {
         registerChildBridge(pi, child);
         return;
     }
+    registerSubagentInfo(pi);
     registerExtensionLifecycle(pi, {
         key: "@hheei/pi-subagents",
         async start(runtime) {
@@ -134,47 +142,27 @@ export default function piSubagentsExtension(pi) {
             const delivery = getBackgroundDelivery(pi);
             const channel = createParentChannel(pi, {
                 isIdle: () => context.isIdle(),
+                ui: context.ui,
                 delivery,
                 signal: runtime.signal,
             });
             runtime.resources.add("parent-channel", () => channel.dispose());
             let manager;
-            // The parent listens; every child dials this socket, so the bridge connection is both the
-            // control plane and the only honest answer to "is this child still running?".
-            const server = new ChildBridgeServer({
-                endpoint: parentBridgeEndpoint(parentSessionId),
+            // One sqlite file is the ledger and the mailbox. Presence is not liveness.
+            const mailbox = createMailboxTransport({
+                filePath: registry.path,
                 parentSessionId,
-                authorize: async (frame) => {
-                    const expected = tokens.get(frame.runtimeIdentity);
-                    if (expected === undefined) {
-                        return `no bridge token is recorded for runtime ${frame.runtimeIdentity}`;
-                    }
-                    if (expected !== frame.token)
-                        return "bridge token mismatch";
-                    // The token says which runtime is calling; the registry says which child that runtime
-                    // belongs to. Without this check a child could name another child's id and take over
-                    // its control channel, so a hello that does not match its record is refused.
-                    const record = await registry.get(frame.subagentId).catch(() => undefined);
-                    if (record === undefined)
-                        return `no recorded child ${frame.subagentId}`;
-                    if (record.runtime?.runtimeIdentity !== frame.runtimeIdentity) {
-                        return `runtime ${frame.runtimeIdentity} is not the recorded runtime of child ${frame.subagentId}`;
-                    }
-                    return undefined;
-                },
                 handleRequest: (request) => manager.handleChildRequest(request.childId, request.operation, request.payload),
                 diagnose,
             });
             await prepareRuntimeDirectory(diagnose);
-            await server.listen();
-            // Closing is awaited: the endpoint is unlinked after the server is closed, so a reload that
-            // started the next server first could have this close unlink the new socket path.
-            runtime.resources.add("subagent-bridge", () => server.close());
+            runtime.resources.add("subagent-bridge", () => mailbox.close());
             // A definition names skills the way Pi lists them, so the parent's loaded skill set is
             // the only name → path catalog; Pi hands it over before every prompt of this session.
             let skillCatalog = [];
             const unsubscribeSkillCatalog = pi.on("before_agent_start", (event) => {
-                skillCatalog = skillCatalogFromLoaded(event.systemPromptOptions.skills);
+                const skills = event.systemPromptOptions?.skills ?? [];
+                skillCatalog = skillCatalogFromLoaded(skills);
             });
             runtime.resources.add("subagent-skill-catalog", unsubscribeSkillCatalog);
             manager = new SubagentManager({
@@ -192,27 +180,6 @@ export default function piSubagentsExtension(pi) {
                     }
                     const records = await registry.list().catch(() => []);
                     const existingSubagentIds = records.map((record) => record.subagentId);
-                    let referencedSessionPath;
-                    const forkTarget = input.forkFrom?.trim();
-                    if (forkTarget !== undefined && forkTarget !== "") {
-                        try {
-                            if (forkTarget === "current") {
-                                throw new Error("forkFrom cannot be 'current'. Use 'parent' to reference the parent session or specify a subagent id like 'agent-1'.");
-                            }
-                            const parentSessionFile = context.sessionManager.getSessionFile();
-                            referencedSessionPath = await resolveForkSessionReference({
-                                forkFrom: forkTarget,
-                                ...(parentSessionFile === undefined
-                                    ? {}
-                                    : { parentSessionPath: parentSessionFile }),
-                                registry,
-                                onWarning: (message) => context.ui.notify(message, "warning"),
-                            });
-                        }
-                        catch (error) {
-                            context.ui.notify(`Referencing session failed: ${errorMessage(error)}; starting fresh session without reference`, "warning");
-                        }
-                    }
                     return resolveSubagentLaunch({
                         input,
                         cwd: context.cwd,
@@ -220,8 +187,6 @@ export default function piSubagentsExtension(pi) {
                         skillCatalog,
                         existingSubagentIds,
                         enforceEnabled: true,
-                        onWarning: (message) => context.ui.notify(message, "warning"),
-                        ...(referencedSessionPath === undefined ? {} : { referencedSessionPath }),
                         parent: {
                             model: { provider: model.provider, id: model.id },
                             thinking,
@@ -231,13 +196,13 @@ export default function piSubagentsExtension(pi) {
                 bootstrap(input) {
                     return persistSubagentIntent({ registry, ...input });
                 },
-                bridge: server,
+                bridge: mailbox,
                 launch(record) {
                     return launchChild({
                         registry,
                         record,
                         tokens,
-                        waitForBridge: (childId, signal) => server.waitForConnection(childId, {
+                        waitForBridge: (childId, signal) => mailbox.waitUntilSeen(childId, {
                             timeoutMs: START_WINDOW_MS,
                             ...(signal === undefined ? {} : { signal }),
                         }),
@@ -254,7 +219,7 @@ export default function piSubagentsExtension(pi) {
                                 record,
                                 tokens,
                                 host: hostSelection.adapter,
-                                waitForBridge: (childId, signal) => server.waitForConnection(childId, {
+                                waitForBridge: (childId, signal) => mailbox.waitUntilSeen(childId, {
                                     timeoutMs: START_WINDOW_MS,
                                     ...(signal === undefined ? {} : { signal }),
                                 }),
@@ -267,35 +232,64 @@ export default function piSubagentsExtension(pi) {
                 // Adoption is a wait, never a spawn: a child that survived this parent reconnects on
                 // its own, and one that did not stays recorded until a send starts it again.
                 connect(record) {
-                    return server.waitForConnection(record.subagentId, {
+                    return mailbox.waitUntilSeen(record.subagentId, {
                         timeoutMs: ADOPT_WINDOW_MS,
                         signal: runtime.signal,
                     });
                 },
+                ...(hostSelection.available
+                    ? {
+                        directory: {
+                            host: hostSelection.selectedHost,
+                            list: () => hostSelection.selectedHost === "herdr"
+                                ? listHerdrAttachments(systemHostCommandRunner, 10_000)
+                                : listCmuxAttachments(systemHostCommandRunner, 10_000),
+                            open: async (record) => {
+                                const launch = await openChildPanel({
+                                    registry,
+                                    record,
+                                    tokens,
+                                    host: hostSelection.adapter,
+                                    waitForBridge: (childId, signal) => mailbox.waitUntilSeen(childId, {
+                                        timeoutMs: START_WINDOW_MS,
+                                        ...(signal === undefined ? {} : { signal }),
+                                    }),
+                                    signal: runtime.signal,
+                                    diagnose,
+                                });
+                                if (launch.handle !== undefined) {
+                                    manager.holdAttachment(record.subagentId, launch.handle);
+                                }
+                                if (launch.handle === undefined || launch.failure !== undefined) {
+                                    return { failure: launch.failure ?? "panel did not open" };
+                                }
+                                return { id: launch.handle.identity.attachmentId };
+                            },
+                            rebind: (attachment) => {
+                                if (attachment.kind !== "panel")
+                                    return undefined;
+                                return attachment.host === "herdr"
+                                    ? rebindHerdrTab({ tabId: attachment.id, ownerId, ownsAttachment })
+                                    : rebindCmuxSurface({ surfaceId: attachment.id, ownerId, ownsAttachment });
+                            },
+                        },
+                    }
+                    : {}),
             });
-            const unregisterWork = delivery.registerSource({
-                activeCount: () => manager.activeCount,
-                onChange: (listener) => manager.onChange(listener),
-            });
-            runtime.resources.add("subagent-background-work", unregisterWork);
             // Recovery must never take the extension down with it: a registry this version cannot
             // read (for example records written by an older release) is reported in the session and
             // the user is told how to reset it.
-            const recovery = await manager.recover().catch((error) => ({
-                recovered: [],
-                failures: [
-                    {
-                        childId: "registry",
-                        reason: `${errorMessage(error)}. Delete the stale records (or the whole registry file) to reset this parent session's subagent state.`,
-                    },
-                ],
-            }));
-            if (recovery.failures.length > 0) {
-                context.ui.notify(`Subagent recovery failed:\n${recovery.failures
-                    .map((failure) => `- ${failure.childId}: ${failure.reason}`)
-                    .join("\n")}`, "error");
+            const recovery = await manager.reconcile().catch((error) => {
+                context.ui.notify(`Subagent recovery failed: ${errorMessage(error)}. Delete the stale records (or the whole registry file) to reset this parent session's subagent state.`, "error");
+                return undefined;
+            });
+            if (recovery?.ok === false) {
+                context.ui.notify("Subagent panels could not be listed, so none were reopened. No second runtime was started.", "warning");
             }
-            registerParentTools(pi, manager);
+            pi.on("before_agent_start", async () => {
+                await manager.ready();
+            });
+            registerParentTools(pi, manager, await discoverAgents(context.cwd));
             if (typeof pi.registerMarkdownTransformer === "function") {
                 pi.registerMarkdownTransformer(transformSubagentsMarkdown);
             }
@@ -306,36 +300,26 @@ export default function piSubagentsExtension(pi) {
             });
             runtime.resources.add("interactive-tool-activation", () => activation.dispose());
             registerParentCommands(pi, manager);
-            void waitForService(pi, TASK_REGISTRY_SERVICE_KEY, { signal: runtime.signal })
-                .then((taskRegistry) => {
-                if (runtime.signal.aborted)
-                    return;
-                const unbind = manager.bindTaskRegistry(taskRegistry);
-                runtime.resources.add("subagent-task-registry", unbind);
-            })
-                .catch((error) => {
-                diagnose(`Task registry service unavailable for subagents: ${errorMessage(error)}`);
-            });
-            const widget = createSubagentWidget(pi, context, runtime.signal);
-            const refreshWidget = () => {
+            const status = createSubagentStatus(context.ui, runtime.signal);
+            let refreshVersion = 0;
+            const refreshStatus = () => {
                 if (runtime.signal.aborted)
                     return;
+                const version = ++refreshVersion;
                 void manager
                     .list()
                     .then((children) => {
-                    if (runtime.signal.aborted)
+                    if (runtime.signal.aborted || version !== refreshVersion)
                         return;
-                    widget?.refresh(children);
+                    status.refresh(children);
                 })
-                    .catch(() => { });
+                    .catch((error) => diagnose(`Subagent status failed: ${errorMessage(error)}`));
             };
-            const unsubscribe = manager.onChange(refreshWidget);
-            const unbindStatus = bindParentStatus(pi, context, manager, runtime.signal);
-            refreshWidget();
-            runtime.resources.add("subagent-widget", () => {
+            const unsubscribe = manager.onChange(refreshStatus);
+            refreshStatus();
+            runtime.resources.add("subagent-status", () => {
                 unsubscribe();
-                unbindStatus();
-                widget?.dispose();
+                status.dispose();
             });
             runtime.resources.add("subagent-manager", () => manager.closeLocalConnections());
         },

package/dist/host-adapter.d.ts

@@ -1,4 +1,5 @@
 import type { LaunchSpec } from "./launch-spec.js";
+import type { HostList } from "./lease.js";
 export type HostKind = "herdr" | "cmux";
 export interface HostCommandResult {
     readonly stdout: string;
@@ -93,6 +94,24 @@ export declare function resolveHerdrProcessWorkspaceId(runner: HostCommandRunner
  * on an unfocused answer.
  */
 export declare function herdrPanelFocused(tabList: string, workspaceList: string, tabId: string): boolean | undefined;
+export declare function listHerdrAttachments(runner: HostCommandRunner, timeoutMs: number): Promise<HostList>;
+export declare function herdrTabIds(output: string): ReadonlySet<string> | undefined;
+export declare function listCmuxAttachments(runner: HostCommandRunner, timeoutMs: number): Promise<HostList>;
+export declare function cmuxSurfaceIds(output: string): ReadonlySet<string> | undefined;
+export declare function rebindHerdrTab(options: {
+    readonly runner?: HostCommandRunner;
+    readonly tabId: string;
+    readonly ownerId: string;
+    readonly timeoutMs?: number;
+    readonly ownsAttachment: (identity: HostAttachmentIdentity) => boolean;
+}): HostAttachment;
+export declare function rebindCmuxSurface(options: {
+    readonly runner?: HostCommandRunner;
+    readonly surfaceId: string;
+    readonly ownerId: string;
+    readonly timeoutMs?: number;
+    readonly ownsAttachment: (identity: HostAttachmentIdentity) => boolean;
+}): HostAttachment;
 /**
  * Reads the pane's process state. A pane that no longer exists is a definite "not alive" — that is
  * how a closed panel looks — while a query that never ran or failed for any other reason is

package/dist/host-adapter.js

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import { errorMessage, runCommand, shellQuote } from "@hheei/pi-ext-core";
 const DEFAULT_HOST_ORDER = ["herdr", "cmux"];
 /** Selects a presentation host visibly; an explicit unavailable host never falls back. */
@@ -180,7 +181,7 @@ export function createCmuxHostAdapter(options) {
                 noun: "surface",
                 // TODO(cmux-focus): cmux does not report which surface a human is looking at, so
                 // observation cannot answer `focused` and idle reclaim fails open here: a cmux child
-                // is only ever closed by stop_agent.
+                // is only ever closed by agent_stop.
                 reportsFocus: false,
                 observe: async () => {
                     const process = await runner.run("cmux", ["--json", "list-panels"], { timeoutMs });
@@ -302,6 +303,144 @@ export function herdrPanelFocused(tabList, workspaceList, tabId) {
     const workspaceFocused = workspace?.focused;
     return typeof workspaceFocused === "boolean" ? workspaceFocused : undefined;
 }
+export async function listHerdrAttachments(runner, timeoutMs) {
+    const status = await runner.run("herdr", ["status", "server"], { timeoutMs });
+    if (status.timedOut || status.exitCode !== 0)
+        return { known: false };
+    const socket = statusField(status.stdout, "socket");
+    if (socket === undefined)
+        return { known: false };
+    let generation;
+    try {
+        const stat = statSync(socket);
+        generation = `${stat.dev}:${stat.ino}`;
+    }
+    catch {
+        return { known: false };
+    }
+    const tabs = await runner.run("herdr", ["tab", "list"], { timeoutMs });
+    if (tabs.timedOut || tabs.exitCode !== 0)
+        return { known: false };
+    const present = herdrTabIds(tabs.stdout);
+    if (present === undefined)
+        return { known: false };
+    return { known: true, generation, present };
+}
+export function herdrTabIds(output) {
+    const entries = herdrCollection(output, "tabs");
+    if (entries === undefined)
+        return undefined;
+    const ids = new Set();
+    for (const entry of entries) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const id = entry.tab_id;
+        if (typeof id === "string" && id !== "")
+            ids.add(id);
+    }
+    return ids;
+}
+export async function listCmuxAttachments(runner, timeoutMs) {
+    const panels = await runner.run("cmux", ["--json", "list-panels"], { timeoutMs });
+    if (panels.timedOut || panels.exitCode !== 0)
+        return { known: false };
+    const present = cmuxSurfaceIds(panels.stdout);
+    if (present === undefined)
+        return { known: false };
+    return { known: true, generation: "cmux", present };
+}
+export function cmuxSurfaceIds(output) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+    const panels = findNamedObject(parsed, "result")?.panels ?? findNamedObject(parsed, "panels");
+    const list = Array.isArray(panels) ? panels : Array.isArray(parsed) ? parsed : undefined;
+    if (list === undefined)
+        return undefined;
+    const ids = new Set();
+    for (const entry of list) {
+        if (typeof entry === "string" && entry !== "")
+            ids.add(entry);
+        else if (typeof entry === "object" && entry !== null) {
+            const id = entry.surface_id;
+            if (typeof id === "string" && id !== "")
+                ids.add(id);
+        }
+    }
+    return ids;
+}
+export function rebindHerdrTab(options) {
+    const runner = options.runner ?? systemHostCommandRunner;
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    return hostAttachment({
+        identity: { host: "herdr", attachmentId: options.tabId, createdBy: options.ownerId },
+        launch: { stdout: "", stderr: "", exitCode: 0, timedOut: false },
+        noun: "tab",
+        reportsFocus: true,
+        observe: async () => {
+            const tabs = await runner.run("herdr", ["tab", "list"], { timeoutMs });
+            if (tabs.timedOut || tabs.exitCode !== 0)
+                return { process: tabs };
+            const ids = herdrTabIds(tabs.stdout);
+            if (ids === undefined)
+                return { process: tabs };
+            return { process: tabs, alive: ids.has(options.tabId) };
+        },
+        close: () => runner.run("herdr", ["tab", "close", options.tabId], { timeoutMs }),
+        ownsAttachment: options.ownsAttachment,
+    });
+}
+export function rebindCmuxSurface(options) {
+    const runner = options.runner ?? systemHostCommandRunner;
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    return hostAttachment({
+        identity: { host: "cmux", attachmentId: options.surfaceId, createdBy: options.ownerId },
+        launch: { stdout: "", stderr: "", exitCode: 0, timedOut: false },
+        noun: "surface",
+        reportsFocus: false,
+        observe: async () => {
+            const process = await runner.run("cmux", ["--json", "list-panels"], { timeoutMs });
+            if (process.timedOut || process.exitCode !== 0)
+                return { process };
+            const ids = cmuxSurfaceIds(process.stdout);
+            if (ids === undefined)
+                return { process };
+            return { process, alive: ids.has(options.surfaceId) };
+        },
+        close: () => runner.run("cmux", ["--json", "close-surface", "--surface", options.surfaceId], {
+            timeoutMs,
+        }),
+        ownsAttachment: options.ownsAttachment,
+    });
+}
+function herdrCollection(output, collection) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+    const list = findNamedObject(parsed, "result")?.[collection];
+    return Array.isArray(list) ? list : undefined;
+}
+function statusField(output, name) {
+    for (const line of output.split("\n")) {
+        const separator = line.indexOf(":");
+        if (separator < 0)
+            continue;
+        if (line.slice(0, separator).trim() !== name)
+            continue;
+        const value = line.slice(separator + 1).trim();
+        if (value !== "")
+            return value;
+    }
+    return undefined;
+}
 function herdrListEntry(output, collection, key, id) {
     let parsed;
     try {

package/dist/info.d.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { ParentChannelReport } from "./manager.js";
+export declare const SUBAGENT_INFO_TYPE = "subagent-info";
+/** Keep line breaks, expand tabs, and remove terminal control characters from child text. */
+export declare function displaySubagentText(text: string): string;
+export declare function renderSubagentInfo(data: unknown, expanded: boolean, theme: Pick<Theme, "fg">): string | undefined;
+/** Native transcript entries survive resume and never enter the model context. */
+export declare function registerSubagentInfo(pi: Pick<ExtensionAPI, "registerEntryRenderer">): void;
+export declare function appendSubagentInfo(pi: Pick<ExtensionAPI, "appendEntry">, report: ParentChannelReport): void;

package/dist/info.js

@@ -0,0 +1,80 @@
+import { stripVTControlCharacters } from "node:util";
+import { Text } from "@earendil-works/pi-tui";
+import { readMessageView } from "@hheei/pi-ext-core";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { VISUAL_SUBAGENT_GLYPH, VISUAL_SUBAGENT_TONE } from "./domain.js";
+import { formatSubagentId } from "./status.js";
+export const SUBAGENT_INFO_TYPE = "subagent-info";
+const infoSchema = Type.Object({
+    id: Type.String(),
+    agent: Type.String(),
+    status: Type.Union([
+        Type.Literal("running"),
+        Type.Literal("done"),
+        Type.Literal("blocked"),
+        Type.Literal("error"),
+    ]),
+    message: Type.String(),
+});
+/** Keep line breaks, expand tabs, and remove terminal control characters from child text. */
+export function displaySubagentText(text) {
+    return stripVTControlCharacters(text)
+        .replaceAll("\t", "    ")
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu, "");
+}
+function shownSubagent(data) {
+    if (!Value.Check(infoSchema, data))
+        return undefined;
+    return {
+        id: formatSubagentId(displaySubagentText(data.id).replace(/\s+/gu, " ")),
+        agent: displaySubagentText(data.agent).replace(/\s+/gu, " "),
+        status: data.status,
+        message: displaySubagentText(data.message),
+    };
+}
+export function renderSubagentInfo(data, expanded, theme) {
+    const shown = shownSubagent(data);
+    if (shown === undefined)
+        return undefined;
+    const heading = theme.fg("dim", "info · agents · ") +
+        theme.fg(VISUAL_SUBAGENT_TONE[shown.status], VISUAL_SUBAGENT_GLYPH[shown.status]) +
+        theme.fg("dim", ` ${shown.id} ${shown.agent} · ${shown.status}`);
+    return expanded ? `${heading}\n${shown.message}` : heading;
+}
+/** Native transcript entries survive resume and never enter the model context. */
+export function registerSubagentInfo(pi) {
+    pi.registerEntryRenderer(SUBAGENT_INFO_TYPE, (entry, options, theme) => {
+        const create = readMessageView(pi);
+        const shown = create === undefined ? undefined : shownSubagent(entry.data);
+        if (create !== undefined && shown !== undefined) {
+            const message = shown.message.trim();
+            return create({
+                theme,
+                header: {
+                    kind: "agents",
+                    summary: `${VISUAL_SUBAGENT_GLYPH[shown.status]} ${shown.id} ${shown.agent} · ${shown.status}`,
+                    tone: VISUAL_SUBAGENT_TONE[shown.status],
+                },
+                ...(message === "" ? {} : { body: shown.message }),
+                stateHolder: entry,
+                forcedExpanded: options.expanded,
+            });
+        }
+        const text = renderSubagentInfo(entry.data, options.expanded, theme);
+        return text === undefined ? undefined : new Text(text, 1, 0);
+    });
+}
+export function appendSubagentInfo(pi, report) {
+    const status = report.reason === "success"
+        ? "done"
+        : report.reason === "blocked" || report.reason === "error"
+            ? report.reason
+            : report.status;
+    pi.appendEntry(SUBAGENT_INFO_TYPE, {
+        id: report.childId,
+        agent: report.agent,
+        status,
+        message: report.message,
+    });
+}

package/dist/launch-spec.d.ts

@@ -16,7 +16,6 @@ export interface LaunchSpec {
     readonly env: Readonly<Record<string, string>>;
     readonly config: EffectiveLaunchConfig;
 }
-export declare const HINDSIGHT_TOOLS: readonly ["hindsight_search_knowledge_pages", "hindsight_list_knowledge_pages", "hindsight_read_knowledge_page", "hindsight_reflect", "hindsight_capture_initiative", "hindsight_ingest_document", "hindsight_sync_status", "hindsight_diagnose"];
 export declare function stripHindsightContent(text: string): string;
 export interface BuildLaunchSpecOptions {
     readonly config: EffectiveLaunchConfig;