@hheei/pi-subagents 0.3.0 → 0.4.0

package/README.md

@@ -16,7 +16,7 @@ children and `/subagents stop [id]` to stop one without conflicting with other e
 | Tool | Purpose |
 | --- | --- |
 | `agent_spawn({ task, agent, cwd?, title? })` | Spawn an independent background subagent task. Runs in a new Herdr tab (or cmux surface) targeting the parent's workspace when a host is available, and headless in the background otherwise. **Prefer reusing existing subagents** via `agent_send` for related/follow-up work to maintain context and maximize prompt cache and memory efficiency. Tool description lists available agent names and roles, excluding disabled or hidden definitions. Deferred by default; discover via `tool_search({ query: "agent" })`. Do not poll for completion; results return automatically. |
-| `agent_send({ id, message, mode? })` | Send `steer`, `follow_up`, or `auto` input to a specific child. **Primary tool for assigning follow-up or functionally related tasks** to existing subagents: idle, blocked, done, or errored children resume their existing session automatically with historical context intact. Deferred by default; discover via `tool_search({ query: "agent" })`. |
+| `agent_send({ id, message, mode? })` | Send `steer`, `follow_up`, or `auto` input to a specific child. **Primary tool for assigning follow-up or functionally related tasks** to existing subagents: idle, blocked, done, or errored children resume their existing session automatically with historical context intact. A child whose runtime has ended is resumed the same way; spawn a new child only for new work. Stop first only when send says the previous process is still running. Deferred by default; discover via `tool_search({ query: "agent" })`. |
 | `agent_get({ id, keys? })` | Inspect one subagent by id. `keys` is a comma-separated selection of `status` (default), `progress` (default), and `diagnostic`; unknown keys fail. The view never returns the child's task parameters or terminal result, which arrive automatically as reports. From the second successful inspection of the same child in this parent runtime, the result adds a short reminder that results return automatically and must not be polled. Deferred by default; discover via `tool_search({ query: "agent" })`. |
 | `agent_stop({ id })` | Stop one subagent's runtime by id. The child keeps its session, so a later `agent_send` can resume it. Deferred by default; discover via `tool_search({ query: "agent" })`. |
 
@@ -28,16 +28,16 @@ assigned by Pi; its first write may still be pending. `agent_get` exposes the sa
 sentence. Failures return only their reason. Operation results omit session IDs, presentation, and
 state snapshots; use `agent_get` for runtime inspection.
 
-Subagent execution tasks register with ext-core's `TaskRegistry` when pi-ext-tools provides it, alongside background Bash jobs. Child reports arrive automatically; do not poll status to detect completion. Bash uses separate `bg_bash_*` tools. Deferred subagent tools are loaded via `tool_search`; activation supplies `subagent_guidance`. Both get tools return the same `status`, `progress`, and optional `diagnostic` envelope. Diagnostics describe blockers, failed turns, or uncertain runtime state.
+SubagentManager and its SQLite ledger own child conversation state, runtime leases, recovery, and reports. No pi-ext-tools task service is required. Only delivery batching is shared through ext-core BackgroundDelivery. Child reports arrive automatically; do not poll status to detect completion. Bash uses separate `bg_bash_*` tools. Deferred subagent tools are loaded via `tool_search`; `before_agent_start` writes the `subagents` bullet into the structured prompt's `optional_tools` section. Both get tools return the same `status`, `progress`, and optional `diagnostic` envelope. Diagnostics describe blockers, failed turns, or uncertain runtime state.
 
 ## Child execution and reporting
 
-Subagents communicate with the parent over a dedicated Unix domain socket bridge:
+Subagents communicate with the parent through the `commands` table in `state.sqlite`, with each child holding a SQLite process lock that proves its writer is alive:
 
 - **Completion by Direct Output**: Subagents do **not** need to call any reporting tool upon successful completion. The subagent simply outputs its final answer as normal assistant text.
-- **Settlement Debounce**: When a subagent finishes a turn and remains idle for 5 seconds (to prevent false idles), the harness automatically captures the trailing assistant text and delivers it to the parent conversation dialog as a completed `subagent-report`.
+- **Settlement Batching**: When a subagent settles, the harness captures the trailing assistant text and delivers it to the parent conversation as a `subagent-report`. Reports flush within 500ms when no other child is working, and are batched for up to 10 seconds while another child is still running.
 - **Blockers & Decisions**: The child registers `contact_parent({ message, reason? })` strictly for reporting when it is blocked or urgently requires a parent decision midway (`reason` defaults to `'blocked'`). Blocked reports wake the parent immediately.
-- **Automatic Retry**: If a subagent encounters a transient error, the harness allows one automatic retry before marking the task failed or delivering a blocked notification.
+- **Automatic Retry**: Pi's own auto-retry is observed, not invented: reports are suppressed while a retry is in flight, and a retry that succeeds clears the previous error instead of reporting it.
 - **Panel Failure Auto-Close**: When a subagent running in a panel encounters a fatal error or reports a blocker, the manager starts a 15-second countdown after notifying the parent, automatically closing the panel tab to avoid workspace clutter unless new instructions are dispatched.
 ## Compact status and reports
 

package/dist/child-control.d.ts

@@ -44,7 +44,7 @@ export declare function promptMessage(payload: unknown): string;
  * Answers a parent request with this child's Pi state. Idleness is the child's own answer: the
  * parent never infers it from how long ago it last heard something.
  */
-export declare function childState(ctx: ExtensionContext): Record<string, unknown>;
+export declare function childState(ctx: ExtensionContext, isCompacting?: boolean): Record<string, unknown>;
 /**
  * Compacts an advisory event to the telemetry the parent projects before it is serialized and
  * pushed over the bridge. A streaming update carries the whole partial message — text, tool

package/dist/child-control.js

@@ -1,8 +1,8 @@
 import { errorMessage, isRecord } from "@hheei/pi-ext-core";
-import { ChildBridgeClient } from "./bridge-client.js";
-import { BridgeError } from "./protocol.js";
+import { attachChildMailbox } from "./mailbox.js";
+import { BridgeError, CHILD_INPUT_EVENT } from "./protocol.js";
 import { FORWARDED_PI_EVENT_TYPES, shouldForwardPiEvent } from "./rpc-events.js";
-import { assistantUpdatePhase } from "./state.js";
+import { assistantUpdatePhase, transcriptFacts } from "./state.js";
 const CHILD_INPUT_SOURCES = ["interactive", "extension", "rpc"];
 /** The source of a Pi input event, when it is one the parent is allowed to hear about. */
 export function childInputSource(event) {
@@ -23,11 +23,12 @@ export function promptMessage(payload) {
  * Answers a parent request with this child's Pi state. Idleness is the child's own answer: the
  * parent never infers it from how long ago it last heard something.
  */
-export function childState(ctx) {
+export function childState(ctx, isCompacting = false) {
     const path = ctx.sessionManager.getSessionFile();
     return {
         idle: ctx.isIdle(),
         pendingMessages: ctx.hasPendingMessages(),
+        ...(isCompacting ? { compacting: true } : {}),
         sessionId: ctx.sessionManager.getSessionId(),
         ...(path ? { path } : {}),
     };
@@ -160,6 +161,13 @@ export function sanitizeEventForBridge(event) {
             ...(message === undefined ? {} : { message, messages: [message] }),
         };
     }
+    if (event.type === "compaction_start" || event.type === "compaction_end") {
+        return {
+            type: event.type,
+            ...(typeof event.reason === "string" ? { reason: event.reason } : {}),
+            ...(typeof event.aborted === "boolean" ? { aborted: event.aborted } : {}),
+        };
+    }
     return event;
 }
 /**
@@ -169,6 +177,21 @@ export function sanitizeEventForBridge(event) {
 export function registerChildControl(pi, options) {
     const isActive = options.isActive ?? (() => true);
     let ctx;
+    let isCompacting = false;
+    const pendingCompactionDeliveries = [];
+    const flushCompactionQueue = () => {
+        if (pendingCompactionDeliveries.length === 0)
+            return;
+        const queued = pendingCompactionDeliveries.splice(0);
+        for (const item of queued) {
+            if (item.deliverAs !== undefined) {
+                pi.sendUserMessage(item.message, { deliverAs: item.deliverAs });
+            }
+            else {
+                pi.sendUserMessage(item.message);
+            }
+        }
+    };
     const requireContext = () => {
         if (ctx === undefined) {
             throw new BridgeError("session_not_ready", "This child has no active Pi session yet");
@@ -183,12 +206,37 @@ export function registerChildControl(pi, options) {
         if (path === undefined) {
             throw new BridgeError("session_not_ready", "This child has no session file path");
         }
+        if (isCompacting) {
+            pendingCompactionDeliveries.push({ message, deliverAs });
+            return { accepted: true, path, queuedForCompaction: true };
+        }
         if (deliverAs !== undefined)
             pi.sendUserMessage(message, { deliverAs });
         else
             pi.sendUserMessage(message);
         return { accepted: true, path };
     };
+    const currentEntries = () => {
+        const sm = requireContext().sessionManager;
+        const branch = typeof sm.getBranch === "function" ? sm.getBranch() : undefined;
+        return Array.isArray(branch) && branch.length > 0 ? branch : sm.getEntries();
+    };
+    let cachedFacts;
+    const sessionFacts = (expected) => {
+        const sm = requireContext().sessionManager;
+        const leaf = typeof sm.getLeafId === "function" ? sm.getLeafId() : undefined;
+        // Append-only: a new message, compaction, or branch moves the leaf. The same leaf is the
+        // same transcript, so turn_end and agent_end do not each copy and walk it.
+        if (typeof leaf === "string" && leaf.length > 0) {
+            const key = `${leaf}:${expected ?? ""}`;
+            if (cachedFacts?.key === key)
+                return cachedFacts.facts;
+            const facts = transcriptFacts(currentEntries(), expected);
+            cachedFacts = { key, facts };
+            return facts;
+        }
+        return transcriptFacts(currentEntries(), expected);
+    };
     const handleRequest = async (request) => {
         if (!isActive()) {
             // The process serves another session now, so it is not this child's runtime: answering
@@ -203,12 +251,13 @@ export function registerChildControl(pi, options) {
             case "follow_up":
                 return deliverPrompt(request.payload, "followUp");
             case "get_state":
-                return childState(requireContext());
+                return childState(requireContext(), isCompacting);
             case "get_entries": {
-                const sm = requireContext().sessionManager;
-                const branch = typeof sm.getBranch === "function" ? sm.getBranch() : undefined;
-                const entries = Array.isArray(branch) && branch.length > 0 ? branch : sm.getEntries();
-                return { entries };
+                return { entries: currentEntries() };
+            }
+            case "session_facts": {
+                const expected = isRecord(request.payload) ? request.payload.expectedInput : undefined;
+                return sessionFacts(typeof expected === "string" ? expected : undefined);
             }
             case "abort":
                 requireContext().abort();
@@ -223,7 +272,6 @@ export function registerChildControl(pi, options) {
     const dispose = [];
     let currentPhase;
     /** The compact event carrying the current phase, resent when the parent reconnects. */
-    let lastPhaseEvent;
     const phaseResetEvents = [
         "agent_start",
         "agent_end",
@@ -232,25 +280,22 @@ export function registerChildControl(pi, options) {
         "agent_settled",
         "tool_execution_start",
         "tool_execution_end",
+        "compaction_start",
+        "compaction_end",
     ];
-    const client = new ChildBridgeClient({
-        endpoint: options.endpoint,
-        identity: options.identity,
+    const client = attachChildMailbox({
+        filePath: options.endpoint,
+        parentSessionId: options.identity.parentSessionId,
+        subagentId: options.identity.subagentId,
         handleRequest,
         ...(options.diagnose === undefined ? {} : { diagnose: options.diagnose }),
-        onConnect: () => {
-            // A reconnected parent knows nothing of the phase this child reached while the socket was
-            // down, so the current compact phase is resent before new deltas arrive.
-            if (lastPhaseEvent !== undefined)
-                client.sendEvent(lastPhaseEvent);
-        },
     });
     // `pi.on` is declared as literal-name overloads, so a loop over the forwarded event types cannot
     // be typed through them; every name in FORWARDED_PI_EVENT_TYPES is a real Pi event.
     const onPiEvent = pi.on;
     for (const type of FORWARDED_PI_EVENT_TYPES) {
         dispose.push(onPiEvent(type, (event) => {
-            if (!isActive())
+            if (!isActive() || !client.connected)
                 return;
             if (!shouldForwardPiEvent(event))
                 return;
@@ -258,12 +303,10 @@ export function registerChildControl(pi, options) {
             if (isRecord(event)) {
                 if (typeof event.type === "string" && phaseResetEvents.includes(event.type)) {
                     currentPhase = undefined;
-                    lastPhaseEvent = undefined;
                 }
                 else if (event.type === "message_update") {
                     const phase = assistantPhaseKey(event);
                     if (phase !== undefined) {
-                        lastPhaseEvent = compact;
                         // While the parent is listening, repetitive deltas in the same phase are dropped to
                         // prevent socket floods. A disconnected parent suppresses nothing: the phase is
                         // resent from `onConnect` instead, so a dropped delta cannot hide it.
@@ -277,17 +320,37 @@ export function registerChildControl(pi, options) {
         }));
     }
     dispose.push(pi.on("input", (event) => {
-        if (!isActive())
+        if (!isActive() || !client.connected)
             return;
         const source = childInputSource(event);
-        if (source !== undefined)
-            client.sendChildInput(source);
+        if (source !== undefined) {
+            client.sendEvent({
+                type: CHILD_INPUT_EVENT,
+                parentSessionId: options.identity.parentSessionId,
+                childId: options.identity.subagentId,
+                runtimeIdentity: options.identity.runtimeIdentity,
+                source,
+            });
+        }
     }));
     dispose.push(pi.on("session_start", (_event, context) => {
         ctx = context;
     }));
+    dispose.push(onPiEvent("compaction_start", () => {
+        isCompacting = true;
+    }));
+    dispose.push(onPiEvent("compaction_end", () => {
+        isCompacting = false;
+        queueMicrotask(() => {
+            if (!isCompacting) {
+                flushCompactionQueue();
+            }
+        });
+    }));
     dispose.push(pi.on("session_shutdown", () => {
         ctx = undefined;
+        isCompacting = false;
+        pendingCompactionDeliveries.length = 0;
     }));
     let started = false;
     return {
@@ -299,7 +362,7 @@ export function registerChildControl(pi, options) {
             started = true;
             client.start();
         },
-        report: (operation, payload, signal) => client.sendReport(operation, payload, signal),
+        report: (operation, payload, signal) => client.report(operation, payload, signal),
         sendEvent: (event) => client.sendEvent(event),
         dispose: () => {
             for (const off of dispose) {

package/dist/child-process.d.ts

@@ -19,3 +19,5 @@ export interface ChildRuntime {
  * supervisor process, so nothing else can end a background child after its parent is gone.
  */
 export declare function spawnChildRuntime(options: ChildProcessOptions): ChildRuntime;
+/** The process-scoped stdin leash for a background child that survived an extension reload. */
+export declare function attachRetainedChild(pid: number): ChildRuntime | undefined;

package/dist/child-process.js

@@ -18,6 +18,7 @@ function hasExited(child) {
  * would send it an EOF and end a child that only its parent's exit is supposed to end.
  */
 const retained = new Set();
+const retainedRuntimes = new Map();
 /**
  * Starts a detached-from-the-terminal child Pi. The caller keeps the handle: this package has no
  * supervisor process, so nothing else can end a background child after its parent is gone.
@@ -43,22 +44,14 @@ export function spawnChildRuntime(options) {
             resolve(code);
         });
     });
-    if (child.pid === undefined) {
+    const pid = child.pid;
+    if (pid === undefined) {
         child.kill("SIGKILL");
         throw new Error(`Child process ${options.command} did not start`);
     }
     retained.add(child);
-    // stdout is the child's Pi protocol stream and stderr its diagnostics; neither is a control
-    // channel, so they are drained to keep the pipes from filling and reported only as diagnostics.
-    child.stdout.on("data", () => { });
-    child.stderr.on("data", (chunk) => {
-        const text = chunk.toString("utf8").trim();
-        if (text !== "")
-            diagnose(text);
-    });
-    child.stdin.on("error", () => { });
-    return {
-        pid: child.pid,
+    const runtime = {
+        pid,
         get alive() {
             return !hasExited(child);
         },
@@ -76,6 +69,25 @@ export function spawnChildRuntime(options) {
             }
         },
     };
+    retainedRuntimes.set(pid, runtime);
+    void exited.then(() => {
+        retainedRuntimes.delete(pid);
+    });
+    // stdout is the child's Pi protocol stream and stderr its diagnostics; neither is a control
+    // channel, so they are drained to keep the pipes from filling and reported only as diagnostics.
+    child.stdout.on("data", () => { });
+    child.stderr.on("data", (chunk) => {
+        const text = chunk.toString("utf8").trim();
+        if (text !== "")
+            diagnose(text);
+    });
+    child.stdin.on("error", () => { });
+    return runtime;
+}
+/** The process-scoped stdin leash for a background child that survived an extension reload. */
+export function attachRetainedChild(pid) {
+    const runtime = retainedRuntimes.get(pid);
+    return runtime?.alive === true ? runtime : undefined;
 }
 /** True when `work` settled within the window; the child process outlives this wait either way. */
 function settled(work, timeoutMs) {

package/dist/domain.d.ts

@@ -116,9 +116,24 @@ export interface ResolvedAgentPolicy {
  * The runtime attachment a child was last launched with. It is evidence, never a liveness proof:
  * whether that process is still serving this child is answered by the bridge connection.
  */
+export type PanelHost = "herdr" | "cmux";
+/**
+ * The surface that owns a child runtime. A panel id is a host tab or surface. A process id is a
+ * background child. Neither one is liveness by itself: the host list or a pid check says whether
+ * it is still there.
+ */
+export type RuntimeAttachment = {
+    readonly kind: "panel";
+    readonly host: PanelHost;
+    readonly id: string;
+} | {
+    readonly kind: "process";
+    readonly pid: number;
+};
 export interface RuntimeMetadata {
     readonly runtimeIdentity: string;
     readonly endpoint: string;
+    readonly attachment?: RuntimeAttachment;
 }
 export interface UsageSummary {
     readonly inputTokens: number;

package/dist/extension.d.ts

@@ -4,16 +4,15 @@ 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 {
-    dismiss(childId: string): void;
     /** Unregisters delivery and appends anything still held without waking the parent. */
     dispose(): void;
 }
 /**
  * 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" | "appendEntry">, deps: {
     readonly isIdle: () => boolean;

package/dist/extension.js

@@ -1,15 +1,15 @@
-import { errorMessage, getBackgroundDelivery, registerExtensionLifecycle, TASK_REGISTRY_SERVICE_KEY, waitForService, } from "@hheei/pi-ext-core";
+import { errorMessage, getBackgroundDelivery, registerExtensionLifecycle, } from "@hheei/pi-ext-core";
 import { discoverAgents } from "./agent-resolver.js";
-import { ChildBridgeServer } from "./bridge-server.js";
 import { registerChildBridge } from "./child-bridge.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 { createSubagentStatus } from "./status.js";
 import { registerInteractiveToolActivation } from "./tool-activation.js";
@@ -45,23 +45,18 @@ 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" || report.reason === "error")
-            : [...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",
@@ -96,12 +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" || report.reason === "error");
-        },
-        dismiss(childId) {
-            const index = held.findIndex((report) => report.childId === childId);
-            if (index !== -1)
-                held.splice(index, 1);
+            registration.request();
         },
         dispose() {
             disposed = true;
@@ -158,37 +148,15 @@ export default function piSubagentsExtension(pi) {
             });
             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 = [];
@@ -228,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 }),
                         }),
@@ -251,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 }),
                                 }),
@@ -264,34 +232,63 @@ 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");
             }
+            pi.on("before_agent_start", async () => {
+                await manager.ready();
+            });
             registerParentTools(pi, manager, await discoverAgents(context.cwd));
             if (typeof pi.registerMarkdownTransformer === "function") {
                 pi.registerMarkdownTransformer(transformSubagentsMarkdown);
@@ -303,16 +300,6 @@ 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 status = createSubagentStatus(context.ui, runtime.signal);
             let refreshVersion = 0;
             const refreshStatus = () => {

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