pi-daddy 0.48.1 → 0.48.3

package/src/executors/herdr-owned.ts

@@ -24,6 +24,8 @@ export interface HerdrOwnedOptions {
   onDisplay?: (display: (text: string) => void) => void;
   /** Tests may select a freshly built launcher. Production always uses the packaged build. */
   launcherPath?: string;
+  /** Human-readable role; display only, never a dispatch selector. */
+  displayName?: string;
 }
 export async function runHerdrOwned(
   request: OwnedChildRunRequest,
@@ -33,11 +35,16 @@ export async function runHerdrOwned(
   const directory = await mkdtemp(join(tmpdir(), "pd-herdr-"));
   const path = join(directory, "owner.sock"),
     token = randomUUID();
+  const role = (options.displayName ?? "child").replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 48) || "child";
+  const display = { source: "pi-daddy:" + randomUUID(), role };
   const launcher =
     options.launcherPath ?? fileURLToPath(new URL("../../dist/executors/herdr-launcher.js", import.meta.url));
   const helper = fileURLToPath(new URL("../../native/linux-x64/worker", import.meta.url));
   let socket: Socket | undefined, send: ((value: unknown) => void) | undefined;
   let identity: CapturedWorkerIdentity | undefined, outcome: OwnedChildRunResult | undefined, error: string | undefined;
+  let paneId: string | undefined,
+    settled = false,
+    displayReleased = false;
   let tabId: string | undefined,
     entered = false,
     done = false,
@@ -86,7 +93,7 @@ export async function runHerdrOwned(
             activityProbe: _probe,
             ...serializable
           } = request;
-          send!({ type: "request", request: serializable });
+          send!({ type: "request", request: serializable, display });
           return;
         }
         if (message?.type === "ownership") {
@@ -142,6 +149,7 @@ export async function runHerdrOwned(
         }
         if (message?.type === "result" && !outcome) {
           outcome = message.result;
+          displayReleased = message.displayReleased === true;
           return;
         }
         if (message?.type === "failure") {
@@ -190,7 +198,7 @@ export async function runHerdrOwned(
         "--cwd",
         request.cwd,
         "--label",
-        "pi-daddy governed child",
+        "pi-daddy " + role,
         "--no-focus",
         ...(options.workspace ? ["--workspace", options.workspace] : []),
       ]),
@@ -199,7 +207,8 @@ export async function runHerdrOwned(
     const pane = created.result?.root_pane as { pane_id?: string; tab_id?: string } | undefined;
     tabId = pane?.tab_id;
     if (!pane?.pane_id || !tabId) throw Error("Herdr creation returned no exact pane/tab identity");
-    options.onPane?.(pane.pane_id, tabId);
+    paneId = pane.pane_id;
+    options.onPane?.(paneId, tabId);
     if (error || request.signal?.aborted) throw Error(error ?? "cancelled before Herdr command launch");
     entered = true;
     const launchReply = await exec([
@@ -218,6 +227,7 @@ export async function runHerdrOwned(
     if (!outcome || !identity) throw Error(error ?? "Herdr launcher closed without a complete result/ownership");
     const receipt = await readCapturedWorkerReceipt(identity);
     if (!receipt) throw Error("Herdr worker supplied no independently verified cleanup receipt");
+    settled = true;
     return { ...outcome, cleanup: { state: "settled", identity, receipt }, ...(error ? { spawnError: error } : {}) };
   } catch (cause) {
     fail(cause);
@@ -229,6 +239,7 @@ export async function runHerdrOwned(
       await new Promise((resolve) => setTimeout(resolve, 50));
       receipt = await readCapturedWorkerReceipt(identity);
     }
+    settled = Boolean(receipt);
     return {
       code: receipt?.workerCode ?? null,
       text: "",
@@ -250,6 +261,28 @@ export async function runHerdrOwned(
     request.signal?.removeEventListener("abort", abort);
     socket?.destroy();
     await new Promise<void>((resolve) => server.close(() => resolve()));
+    // Launcher SIGKILL can bypass its display release. Only the exact native receipt permits this fallback.
+    // Sequence ordering applies to an existing source; UI delivery remains best effort and never changes native results.
+    if (paneId && identity && !(settled && displayReleased)) {
+      try {
+        const reply = await exec([
+          "pane",
+          settled ? "release-agent" : "report-agent",
+          paneId,
+          "--source",
+          display.source,
+          "--agent",
+          "pi",
+          "--seq",
+          "3",
+          ...(settled ? [] : ["--state", "unknown", "--message", "Native cleanup is unverified"]),
+        ]);
+        if (reply.code !== 0 || (reply.stdout.trim() && parseReply(reply).error))
+          console.error("pi-daddy: Herdr agent sidebar cleanup report unavailable");
+      } catch {
+        console.error("pi-daddy: Herdr agent sidebar cleanup report unavailable");
+      }
+    }
     if (tabId && !options.keepPane) {
       const closed = parseReply(await exec(["tab", "close", tabId]));
       if (closed.error && !/tab .* not found|tab_not_found/.test(closed.error))

package/src/executors/owned-pi-ui.ts

@@ -0,0 +1,116 @@
+/** Install LAST: observe final extension-transformed Pi events through the private inherited pipe. */
+import { fstatSync } from "node:fs";
+import { Socket } from "node:net";
+import { getAgentDir, ProjectTrustStore, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, MessageUpdateEvent } from "@earendil-works/pi-coding-agent";
+
+import { OWNED_PI_VIEW_READY, failOwnedPiUi as fail } from "./owned-pi-view.ts";
+
+const EVENT_FD = 6;
+
+export default function ownedPiUi(pi: ExtensionAPI): void {
+  try {
+    const channel = fstatSync(EVENT_FD);
+    if (!channel.isFIFO() && !channel.isSocket()) throw Error("fd 6 is not an inherited event pipe");
+    const output = new Socket({ fd: EVENT_FD, readable: false, writable: true });
+    output.on("error", fail);
+    let pending = Promise.resolve();
+    const send = (event: unknown): Promise<void> => {
+      let record: string;
+      try {
+        record = JSON.stringify(event) + "\n";
+      } catch (error) {
+        return fail(error);
+      }
+      pending = pending
+        .then(
+          () =>
+            new Promise<void>((resolve) => {
+              output.write(record, (error) => (error ? fail(error) : resolve()));
+            }),
+        )
+        .catch(fail);
+      return pending;
+    };
+    // Keep the previous noninteractive trust policy; native UI must not introduce a blocking trust dialog.
+    pi.on("project_trust", (event) => {
+      try {
+        const agentDir = getAgentDir();
+        const remembered = new ProjectTrustStore(agentDir).get(event.cwd);
+        const trusted =
+          remembered ??
+          SettingsManager.create(event.cwd, agentDir, { projectTrusted: false }).getDefaultProjectTrust() === "always";
+        return { trusted: trusted ? "yes" : "no", remember: false };
+      } catch (error) {
+        return fail(error);
+      }
+    });
+    let guardedSession: { sessionManager: unknown; sessionId: unknown } | undefined;
+    pi.events.on(OWNED_PI_VIEW_READY, (ready) => {
+      if (ready && typeof ready === "object" && "sessionManager" in ready && "sessionId" in ready)
+        guardedSession = { sessionManager: ready.sessionManager, sessionId: ready.sessionId };
+    });
+    let started = false;
+    pi.on("session_start", (_event, ctx) => {
+      try {
+        if (started) throw Error("the owned session cannot be replaced");
+        if (
+          ctx.mode !== "tui" ||
+          guardedSession?.sessionManager !== ctx.sessionManager ||
+          guardedSession.sessionId !== ctx.sessionManager.getSessionId()
+        )
+          throw Error("the native Pi view guard is not ready for this session");
+        const header = ctx.sessionManager.getHeader();
+        if (
+          !header ||
+          header.type !== "session" ||
+          header.version !== 3 ||
+          header.id !== ctx.sessionManager.getSessionId()
+        )
+          throw Error("missing or mismatched actual Pi session header");
+        started = true;
+        return send(header);
+      } catch (error) {
+        return fail(error);
+      }
+    });
+    const forward = (event: unknown): Promise<void> => {
+      if (!started) fail("Pi event arrived before the guarded session");
+      return send(event);
+    };
+    pi.on("agent_start", forward);
+    pi.on("agent_end", forward);
+    pi.on("turn_start", forward);
+    pi.on("turn_end", forward);
+    pi.on("message_start", forward);
+    pi.on("message_end", forward);
+    pi.on("tool_execution_start", forward);
+    pi.on("tool_execution_update", forward);
+    pi.on("tool_execution_end", forward);
+    pi.on("message_update", (event: MessageUpdateEvent) => {
+      // Match Pi's JSON delta projection without copying growing partial-message snapshots.
+      if (event.message.role !== "assistant") fail("message_update is not an assistant message");
+      const usage = event.message.usage,
+        update = event.assistantMessageEvent;
+      if (!("partial" in update)) return forward({ type: event.type, usage, assistantMessageEvent: update });
+      const { partial, ...delta } = update;
+      if (update.type === "toolcall_start") {
+        const tool = partial.content[update.contentIndex];
+        if (tool?.type !== "toolCall") fail("toolcall_start lacks its actual tool call");
+        return forward({
+          type: event.type,
+          usage,
+          assistantMessageEvent: { ...delta, id: tool.id, toolName: tool.name },
+        });
+      }
+      return forward({ type: event.type, usage, assistantMessageEvent: delta });
+    });
+    pi.on("agent_settled", async (event, ctx) => {
+      await forward(event);
+      // The pipe has flushed before orderly shutdown; native receipt/session checks remain authoritative.
+      ctx.shutdown();
+    });
+  } catch (error) {
+    fail(error);
+  }
+}

package/src/executors/owned-pi-view.ts

@@ -0,0 +1,58 @@
+/** Install FIRST: native Pi remains observable, but only its parent can control work. */
+import { writeSync } from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export const OWNED_PI_VIEW_READY = "pi-daddy:owned-pi-view-ready";
+export function failOwnedPiUi(error: unknown): never {
+  try {
+    writeSync(2, "pi-daddy: owned Pi UI refused: " + String(error) + "\n");
+  } finally {
+    process.exit(70);
+  }
+}
+
+export default function ownedPiView(pi: ExtensionAPI): void {
+  try {
+    if (typeof pi.registerMarkdownTransformer !== "function") throw Error("Pi lacks its public markdown renderer hook");
+    pi.registerMarkdownTransformer((markdown, context) =>
+      context.messageType === "assistant-thinking" ? "Thinking hidden" : markdown,
+    );
+    let guarded = false;
+    // No await here: the first session handler installs the guard before another handler can yield.
+    pi.on("session_start", (_event, ctx) => {
+      try {
+        if (guarded) throw Error("the owned session cannot be replaced");
+        if (
+          ctx.mode !== "tui" ||
+          typeof ctx.ui.onTerminalInput !== "function" ||
+          typeof ctx.ui.getToolsExpanded !== "function" ||
+          typeof ctx.ui.setToolsExpanded !== "function"
+        )
+          throw Error("Pi lacks the required native TUI controls");
+        const unsubscribe = ctx.ui.onTerminalInput((data) => {
+          // The renderer consumes this exact terminal response before dispatching any user action.
+          if (/^\x1b\[6;\d+;\d+t$/.test(data)) return;
+          try {
+            if (["\x0f", "\x1b[111;5u", "\x1b[111;5:1u", "\x1b[111;5:2u", "\x1b[27;5;111~"].includes(data))
+              ctx.ui.setToolsExpanded(!ctx.ui.getToolsExpanded());
+          } catch (error) {
+            failOwnedPiUi(error);
+          }
+          return { consume: true };
+        });
+        if (typeof unsubscribe !== "function") throw Error("Pi did not install the terminal input guard");
+        ctx.ui.setEditorText("");
+        ctx.ui.setStatus("pi-daddy-owned", "View only · parent controls the task · Ctrl+O expands tools");
+        guarded = true;
+        pi.events.emit(OWNED_PI_VIEW_READY, {
+          sessionManager: ctx.sessionManager,
+          sessionId: ctx.sessionManager.getSessionId(),
+        });
+      } catch (error) {
+        failOwnedPiUi(error);
+      }
+    });
+  } catch (error) {
+    failOwnedPiUi(error);
+  }
+}

package/src/executors/owned-worker.ts

@@ -25,6 +25,8 @@ export interface OwnedChildRunRequest extends ChildRunRequest {
   onOwnership?: (identity: CapturedWorkerIdentity) => Promise<void> | void;
   /** JSON protocol consumers observe all bytes without capturing enormous replay streams as answer text. */
   captureStdout?: boolean;
+  /** Actual pane terminal for Pi's native view. Protocol events arrive separately on fd 6. */
+  terminalUi?: boolean;
   /** Bounded diagnostics may truncate without stopping independently captured primary output. */
   stopOnOutputLimit?: boolean;
 }
@@ -46,6 +48,8 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
   if (request.signal?.aborted) return notStarted("cancelled before helper launch", true);
   if (process.platform !== "linux" || process.arch !== "x64")
     return notStarted("captured worker requires qualified Linux x64 helper");
+  if (request.terminalUi && (!process.stdin.isTTY || !process.stdout.isTTY || !process.stderr.isTTY))
+    return notStarted("native Pi view requires a real pane terminal on stdin, stdout and stderr");
   let helper: string, root: string, hash: string;
   const nonce = randomUUID();
   let binary: import("node:fs/promises").FileHandle | undefined;
@@ -95,13 +99,26 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       {
         cwd: root,
         env: request.env,
-        stdio: ["ignore", "pipe", "pipe", "pipe", "pipe", binary!.fd],
-        detached: true,
+        stdio: request.terminalUi
+          ? ["inherit", "inherit", "inherit", "pipe", "pipe", binary!.fd, "pipe"]
+          : ["ignore", "pipe", "pipe", "pipe", "pipe", binary!.fd],
+        // The UI shares the pane's foreground process group for raw input and SIGWINCH.
+        // Cleanup still targets owned descendants by pidfd, never by process group.
+        detached: !request.terminalUi,
       },
     );
     void binary!.close();
     const control = child.stdio[3] as import("node:stream").Duplex;
     const status = child.stdio[4] as import("node:stream").Readable;
+    const streams = {
+      stdout: request.terminalUi ? (child.stdio.at(6) as import("node:stream").Readable) : child.stdout,
+      stderr: child.stderr,
+    };
+    const closeObservations = () => {
+      streams.stdout?.destroy();
+      streams.stderr?.destroy();
+      status.destroy();
+    };
     let identity: CapturedWorkerIdentity | undefined;
     let text = "",
       count = 0,
@@ -146,9 +163,7 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       stopWatchdog = setTimeout(() => {
         failure ??= "worker helper failed to establish cleanup before its bound";
         child.kill("SIGKILL");
-        child.stdout?.destroy();
-        child.stderr?.destroy();
-        status.destroy();
+        closeObservations();
       }, cleanupCeiling + 1000);
     };
     function armIdle() {
@@ -160,10 +175,15 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
         stop();
       }, request.idleTimeoutMs);
     }
-    child.stdout?.on("data", (bytes) => observe("stdout", bytes));
-    child.stderr?.on("data", (bytes) => observe("stderr", bytes));
+    streams.stdout?.on("data", (bytes: Buffer) => observe("stdout", bytes));
+    streams.stderr?.on("data", (bytes: Buffer) => observe("stderr", bytes));
+    for (const stream of Object.values(streams))
+      stream?.on("error", (error) => {
+        failure ??= "child event channel failed: " + String(error);
+        stop();
+      });
     for (const stream of ["stdout", "stderr"] as const)
-      child[stream]?.on("end", () => {
+      streams[stream]?.on("end", () => {
         const tail = decoders[stream].end();
         if (tail && !(stream === "stdout" && request.captureStdout === false)) {
           const kept = takeBytes(tail, Math.max(0, (request.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES) - count));
@@ -276,9 +296,7 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       void (async () => {
         if (!identity || !(await readCapturedWorkerReceipt(identity))) {
           failure ??= "helper exited without an independent settlement receipt";
-          child.stdout?.destroy();
-          child.stderr?.destroy();
-          status.destroy();
+          closeObservations();
         }
       })();
     });

package/src/governance/approval-prompt.ts

@@ -80,7 +80,7 @@ export interface PromptOutcome {
 
 export interface ApprovalGateOptions {
   ui: ApprovalUI;
-  /** pi's `ctx.hasUI` — false in print/json mode, and therefore in every governed child. */
+  /** Whether a human can answer here. False in print/json mode and view-only child tabs. */
   hasUI: boolean;
   /** pi's `ctx.mode`, quoted back in the refusal so an operator can see why. */
   mode: string;