@hheei/pi-subagents 0.4.0 → 0.5.1

package/dist/host-adapter.d.ts

@@ -36,6 +36,8 @@ export interface HostObservation {
     readonly identity: HostAttachmentIdentity;
     readonly alive: boolean;
     readonly known: boolean;
+    /** True when the underlying host container (tab, pane, or surface) no longer exists. */
+    readonly containerGone?: boolean;
     /**
      * Whether a human is looking at this panel. Absent when the host cannot say, which includes
      * both hosts without the capability and a lookup that failed just now; the caller must treat

package/dist/host-adapter.js

@@ -138,10 +138,13 @@ export function createHerdrHostAdapter(options) {
                     const listed = herdrListingSucceeded(tabs) && herdrListingSucceeded(workspaces)
                         ? herdrPanelFocused(tabs.stdout, workspaces.stdout, target.tabId)
                         : undefined;
+                    const code = herdrErrorCode(process.stderr) ?? herdrErrorCode(process.stdout);
+                    const containerGone = code === "pane_not_found" || code === "tab_not_found";
                     const alive = herdrPaneAlive(process);
                     return {
                         process,
                         ...(alive === undefined ? {} : { alive }),
+                        ...(containerGone ? { containerGone: true } : {}),
                         ...(listed === undefined ? {} : { focused: listed }),
                     };
                 },
@@ -187,7 +190,12 @@ export function createCmuxHostAdapter(options) {
                     const process = await runner.run("cmux", ["--json", "list-panels"], { timeoutMs });
                     if (process.timedOut || process.exitCode !== 0)
                         return { process };
-                    return { process, alive: containsString(process.stdout, attachmentId) };
+                    const alive = containsString(process.stdout, attachmentId);
+                    return {
+                        process,
+                        alive,
+                        ...(!alive ? { containerGone: true } : {}),
+                    };
                 },
                 close: () => runner.run("cmux", ["--json", "close-surface", "--surface", attachmentId], {
                     timeoutMs,
@@ -207,6 +215,7 @@ function hostAttachment(options) {
             // the caller drop the panel and the runtime evidence, so it is only ever said on purpose.
             alive: result.alive === true,
             known: result.alive !== undefined,
+            ...(result.containerGone ? { containerGone: true } : {}),
             ...(focused === undefined ? {} : { focused }),
             detail: result.process.stderr || result.process.stdout,
         };

package/dist/runtime.d.ts

@@ -46,19 +46,9 @@ export declare function launchChild(options: LaunchChildOptions): Promise<Launch
 export interface OpenChildPanelOptions extends LaunchChildOptions {
     readonly host: HostAdapter;
 }
-/**
- * What a launch left behind. `failure` is what the caller reports. A handle is kept when the host
- * still has a tab, so stop can close it. It does not by itself forbid another send.
- */
 export interface LaunchOutcome<T> {
     readonly handle?: T;
     readonly failure?: string;
 }
-/**
- * Opens one child in a host panel and waits for it to connect. The host owns this process, so the
- * parent holds no runtime handle for it; a panel that never yields a bridge is closed again instead
- * of being left as a process nobody can control.
- */
 export declare function openChildPanel(options: OpenChildPanelOptions): Promise<LaunchOutcome<HostAttachment>>;
-/** Creates the runtime directory if needed; the socket itself is 0600 in a 0700 directory. */
 export declare function prepareRuntimeDirectory(diagnose?: (message: string) => void): Promise<string>;

package/dist/runtime.js

@@ -127,8 +127,6 @@ export async function launchChild(options) {
     }
     await runtime.terminate();
     if (runtime.alive) {
-        // The process outlived termination, so it is not gone and the caller keeps the handle: it is
-        // the only thing that can try again.
         await bindProcess(options.registry, record.subagentId, runtime.pid);
         return {
             handle: runtime,
@@ -139,11 +137,6 @@ export async function launchChild(options) {
     await commitLease(options.registry, record.subagentId, { type: "runtime-gone", outcome: "clear" }, undefined, plan.runtimeIdentity);
     return { failure: `Child ${record.subagentId} never connected to the parent bridge` };
 }
-/**
- * Opens one child in a host panel and waits for it to connect. The host owns this process, so the
- * parent holds no runtime handle for it; a panel that never yields a bridge is closed again instead
- * of being left as a process nobody can control.
- */
 export async function openChildPanel(options) {
     const record = options.record;
     const plan = planChildRuntime(record, options.tokens, "panel");
@@ -153,28 +146,51 @@ export async function openChildPanel(options) {
         attachment = await options.host.open(plan.spec);
     }
     catch (error) {
-        // Opening is not atomic: the host may have created the panel and started the process before
-        // failing to report it. The token is kept so a child that does come up can still be adopted,
-        // and the caller is told the runtime is unconfirmed instead of that nothing was started.
         return {
             failure: `Child ${record.subagentId} could not be opened in a ${options.host.kind} panel (${errorMessage(error)}); a panel may have been created, so close it if it is still there`,
         };
     }
+    const earlyExitAbort = new AbortController();
+    const combinedSignal = options.signal
+        ? AbortSignal.any([options.signal, earlyExitAbort.signal])
+        : earlyExitAbort.signal;
+    let childAppeared = false;
+    let earlyExitObserved;
+    const probeInterval = setInterval(async () => {
+        try {
+            const obs = await attachment.observe();
+            if (!obs.known)
+                return;
+            if (obs.containerGone) {
+                earlyExitObserved = obs;
+                earlyExitAbort.abort();
+                return;
+            }
+            if (obs.alive) {
+                childAppeared = true;
+            }
+            else if (childAppeared) {
+                earlyExitObserved = obs;
+                earlyExitAbort.abort();
+            }
+        }
+        catch { }
+    }, 200);
     let connected;
     try {
-        connected = await options.waitForBridge(record.subagentId, options.signal);
+        connected = await options.waitForBridge(record.subagentId, combinedSignal);
     }
     catch (error) {
         options.diagnose?.(`bridge wait failed: ${errorMessage(error)}`);
         connected = false;
     }
+    finally {
+        clearInterval(probeInterval);
+    }
     if (connected) {
         await bindPanel(options.registry, record.subagentId, options.host.kind, attachment.identity.attachmentId);
         return { handle: attachment };
     }
-    // The child never dialed in, so the panel is closed again. A host that cannot confirm it is gone
-    // keeps the handle, so stop can try the close again, and the token, so a child that does come up
-    // can still be adopted. The handle does not block a later send.
     const cleanup = await attachment.cleanup();
     const observed = await attachment.observe();
     if (!(observed.known && !observed.alive)) {
@@ -186,9 +202,9 @@ export async function openChildPanel(options) {
     }
     options.tokens.forget(plan.runtimeIdentity);
     await commitLease(options.registry, record.subagentId, { type: "runtime-gone", outcome: "clear" }, undefined, plan.runtimeIdentity);
-    return { failure: `Child ${record.subagentId} never connected to the parent bridge` };
+    const detail = earlyExitObserved?.detail ? ` (${earlyExitObserved.detail.trim()})` : "";
+    return { failure: `Child ${record.subagentId} never connected to the parent bridge${detail}` };
 }
-/** Creates the runtime directory if needed; the socket itself is 0600 in a 0700 directory. */
 export async function prepareRuntimeDirectory(diagnose) {
     const directory = runtimeDirectory();
     await mkdir(directory, { recursive: true, mode: 0o700 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hheei/pi-subagents",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Independent background Pi subagent sessions with durable identity and RPC control.",
   "type": "module",
   "main": "dist/index.js",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@hheei/pi-ext-core": "^0.5.0"
+    "@hheei/pi-ext-core": "^0.6.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=1.3.0",