pi-famulus 0.1.8 → 0.2.0

package/src/subagent/hosted-session.ts

@@ -0,0 +1,268 @@
+/**
+ * ChildSessionAdapter over a daemon-hosted `pi --mode rpc` process.
+ * The runner's timers stay; only the session lives in another process.
+ */
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ManagerClient, ManagerEvent } from "../manager-client";
+import { parentResourceArgs, resolvePiArgv } from "../pi-command";
+import { resolveChildModel, type PiRuntimeDeps } from "./pi-runtime";
+import type {
+  ChildRunRequest,
+  ChildSessionAdapter,
+  ChildSessionEvent,
+  ChildTokenUsage,
+  CreateSessionFn,
+} from "./types";
+
+export interface HostedSessionDeps extends PiRuntimeDeps {
+  getClient: () => ManagerClient | null;
+  getHome: () => string;
+  /** This extension's entry file, passed to the child with -e. */
+  extensionEntry: string;
+  piCommand?: string | null;
+  trustProject?: boolean;
+}
+
+interface HostingView {
+  residency: string;
+  activity: string;
+  driver: string;
+  cacheExpiresAt?: number;
+  sessionFile?: string;
+  sessionId?: string;
+}
+
+export function createHostedSessionFn(deps: HostedSessionDeps): CreateSessionFn {
+  return async (req) => {
+    const client = deps.getClient();
+    if (!client || !client.isAvailable()) {
+      throw new Error("pi-famulus daemon is not connected; a subagent needs it to run pi --mode rpc.");
+    }
+    client.requireHostedProtocol();
+    const pi = resolvePiArgv(deps.piCommand);
+    if ("error" in pi) throw new Error(pi.error);
+    const model = resolveChildModel(deps, req);
+    const thinking =
+      model.thinkingOverride ?? req.agent.thinking ?? deps.getParentThinkingLevel() ?? "off";
+    const cwd = deps.getCwd();
+    const promptPath = join(deps.getHome(), "agents", "prompts");
+    mkdirSync(promptPath, { recursive: true });
+    const promptFile = join(promptPath, `${req.childId}.md`);
+    writeFileSync(promptFile, req.agent.systemPrompt);
+    const inherited = parentResourceArgs();
+    const extensionPaths = inherited.filter((_, i) => inherited[i - 1] === "-e");
+    const alreadyLoadsUs = extensionPaths.some((path) => path === deps.extensionEntry);
+    const trustInherited = inherited.some((arg) => arg === "-a" || arg === "--approve" || arg === "-na" || arg === "--no-approve");
+    const argv = [
+      ...pi.argv,
+      "--mode", "rpc",
+      "--session-id", req.childId,
+      "--name", `${req.agent.name}: ${req.name}`,
+      ...inherited,
+      ...(alreadyLoadsUs ? [] : ["-e", deps.extensionEntry]),
+      ...(model.model ? ["--model", `${model.model.provider}/${model.model.id}`] : []),
+      "--thinking", String(thinking),
+      "--append-system-prompt", promptFile,
+      ...(trustInherited ? [] : [deps.getProjectTrusted?.() ? "-a" : "-na"]),
+      ...(req.agent.tools ? ["--tools", req.agent.tools.join(",")] : []),
+    ];
+    const env = { ...process.env } as Record<string, string>;
+    if (req.agent.tools) env.PI_FAMULUS_CHILD_TOOLS = req.agent.tools.join(",");
+    env.PI_FAMULUS_CHILD_RUN = req.runId;
+    env.PI_FAMULUS_CHILD_NAME = req.name;
+    const spawned = await client.agentSpawn({
+      childId: req.childId,
+      runId: req.runId,
+      name: req.name,
+      argv,
+      cwd,
+      env,
+    });
+    let warning = model.warning;
+    try {
+      await client.agentInput(req.childId, "set_steering_mode", "all", "parent");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const note = `Steering mode was not set (${message}); queued input may wait until the current turn ends.`;
+      warning = warning ? `${warning} ${note}` : note;
+    }
+    await client.agentWatch(req.childId);
+    const session = new HostedRpcSession(client, req.childId, {
+      warning,
+      resolvedModel: model.model ? `${model.model.provider}/${model.model.id}` : undefined,
+      effectiveThinkingLevel: typeof thinking === "string" ? thinking : undefined,
+      sessionFile: typeof spawned.session_file === "string" ? spawned.session_file : undefined,
+      sessionId: typeof spawned.session_id === "string" ? spawned.session_id : req.childId,
+    });
+    return session;
+  };
+}
+
+class HostedRpcSession implements ChildSessionAdapter {
+  readonly warning?: string;
+  readonly resolvedModel?: string;
+  readonly effectiveThinkingLevel?: string;
+  private readonly listeners = new Set<(event: ChildSessionEvent) => void>();
+  private readonly unsubscribe: () => void;
+  private streaming = false;
+  private lastText = "";
+  private turns: { role: string; text: string }[] = [];
+  private usage: ChildTokenUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  private settle: (() => void) | null = null;
+  private hostingView: HostingView;
+  private disposed = false;
+
+  constructor(
+    private readonly client: ManagerClient,
+    private readonly childId: string,
+    init: { warning?: string; resolvedModel?: string; effectiveThinkingLevel?: string; sessionFile?: string; sessionId?: string },
+  ) {
+    this.warning = init.warning;
+    this.resolvedModel = init.resolvedModel;
+    this.effectiveThinkingLevel = init.effectiveThinkingLevel;
+    this.hostingView = {
+      residency: "warm",
+      activity: "starting",
+      driver: "parent",
+      sessionFile: init.sessionFile,
+      sessionId: init.sessionId,
+    };
+    this.unsubscribe = this.client.onEvent((event) => this.onManagerEvent(event as ManagerEvent & Record<string, unknown>));
+  }
+
+  hosting(): HostingView {
+    return { ...this.hostingView };
+  }
+
+  async prompt(text: string): Promise<void> {
+    const done = this.armSettle();
+    const op = this.streaming ? "prompt_steer" : "prompt";
+    await this.client.agentInput(this.childId, op, text, "parent");
+    if (!this.streaming) await done;
+  }
+
+  async steer(text: string): Promise<void> {
+    await this.client.agentInput(this.childId, "prompt_steer", text, "parent");
+  }
+
+  async followUp(text: string): Promise<void> {
+    await this.client.agentInput(this.childId, "prompt_follow", text, "parent");
+  }
+
+  async abort(): Promise<void> {
+    await this.client.agentInput(this.childId, "abort", "", "parent");
+    this.streaming = false;
+    this.settle?.();
+    this.settle = null;
+  }
+
+  async park(): Promise<void> {
+    await this.client.agentPark(this.childId);
+    this.hostingView.residency = "parked";
+  }
+
+  async waitForIdle(): Promise<void> {
+    if (!this.streaming) return;
+    await this.armSettle();
+  }
+
+  getLastAssistantText(): string | undefined {
+    return this.lastText || undefined;
+  }
+
+  getConversation() {
+    return this.turns.map((turn) => ({ ...turn }));
+  }
+
+  tokenUsage(): ChildTokenUsage {
+    return { ...this.usage };
+  }
+
+  isStreaming(): boolean {
+    return this.streaming;
+  }
+
+  subscribe(listener: (event: ChildSessionEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.unsubscribe();
+    this.settle?.();
+    this.settle = null;
+  }
+
+  private armSettle(): Promise<void> {
+    return new Promise((resolve) => {
+      this.settle = resolve;
+    });
+  }
+
+  private onManagerEvent(event: ManagerEvent & Record<string, unknown>): void {
+    if (event.child_id !== this.childId) return;
+    if (event.event === "agent_state") {
+      this.hostingView = {
+        residency: String(event.residency ?? this.hostingView.residency),
+        activity: String(event.activity ?? this.hostingView.activity),
+        driver: String(event.driver ?? this.hostingView.driver),
+        cacheExpiresAt: typeof event.cache_expires_at === "number" ? event.cache_expires_at : this.hostingView.cacheExpiresAt,
+        sessionFile: typeof event.session_file === "string" ? event.session_file : this.hostingView.sessionFile,
+        sessionId: typeof event.session_id === "string" ? event.session_id : this.hostingView.sessionId,
+      };
+      if (event.activity === "running") this.streaming = true;
+      if (event.activity === "idle" || event.activity === "failed") {
+        this.streaming = false;
+        this.settle?.();
+        this.settle = null;
+      }
+      return;
+    }
+    if (event.event !== "agent_rpc" || !event.record || typeof event.record !== "object") return;
+    const record = event.record as { type?: string; message?: { role?: string; content?: { type?: string; text?: string }[]; usage?: Record<string, unknown> }; toolCallId?: string };
+    const type = record.type ?? "";
+    if (type === "agent_start") this.streaming = true;
+    if (type === "agent_settled") {
+      this.streaming = false;
+      this.settle?.();
+      this.settle = null;
+    }
+    if (type === "message_end" && record.message?.role === "assistant") {
+      const text = (record.message.content ?? []).map((part) => part.text ?? "").join("");
+      if (text) {
+        this.lastText = text;
+        this.turns.push({ role: "assistant", text });
+      }
+      const usage = record.message.usage;
+      if (usage) {
+        this.usage.input += num(usage.input);
+        this.usage.output += num(usage.output);
+        this.usage.cacheRead += num(usage.cacheRead);
+        this.usage.cacheWrite += num(usage.cacheWrite);
+      }
+    }
+    if (type === "message_end" && record.message?.role === "user") {
+      const text = (record.message.content ?? []).map((part) => part.text ?? "").join("");
+      if (text) this.turns.push({ role: "user", text });
+    }
+    const adapted: ChildSessionEvent = {
+      type,
+      ...(record.message?.role ? { role: record.message.role } : {}),
+      ...(record.toolCallId ? { toolCallId: record.toolCallId } : {}),
+    };
+    for (const listener of this.listeners) listener(adapted);
+  }
+}
+
+function num(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+/** Request id for a child→parent decision. */
+export function newCommsRequestId(): string {
+  return `rq_${randomUUID().slice(0, 8)}`;
+}

package/src/subagent/overrun.ts

@@ -38,6 +38,17 @@ export class ChildShellTracker {
     this.sizes.delete(taskId);
   }
 
+  /** A hosted child's shell is observed from the parent session's task_exited. */
+  endByTask(taskId: string): void {
+    for (const [childId, shell] of this.shells) {
+      if (shell.taskId === taskId) {
+        this.shells.delete(childId);
+        this.sizes.delete(taskId);
+        return;
+      }
+    }
+  }
+
   current(childId: string): ChildShell | undefined {
     return this.shells.get(childId);
   }

package/src/subagent/pi-runtime.ts

@@ -157,6 +157,10 @@ interface ResolvedModel {
  * falls back to the parent model with a warning (user-authored files must not
  * hard-fail across machines).
  */
+export function resolveChildModel(deps: PiRuntimeDeps, req: ChildRunRequest): ResolvedModel {
+  return resolveModel(deps, req);
+}
+
 function resolveModel(deps: PiRuntimeDeps, req: ChildRunRequest): ResolvedModel {
   const candidates = modelCandidates(deps);
   const findModel = (provider: string, id: string): Model | undefined =>

package/src/subagent/runner.ts

@@ -99,10 +99,10 @@ export interface InProcessRunnerOptions {
   /** Shared time source and scheduler. */
   clock?: Clock;
   /**
-   * Per-generation admission hook. Awaited before each (re)start; the
-   * releaser gets terminal=false for a resumable interruption so its local
-   * slot can be returned while the child-owned machine permit is retained.
-   * Rejecting cancels the generation as {status:"interrupted", error}.
+   * Per-generation admission hook. Awaited before each (re)start. The
+   * releaser is called with terminal=true when the turn settles, including
+   * an interrupted turn: the machine permit is released and the next turn
+   * acquires again. Rejecting cancels the generation as {status:"interrupted", error}.
    */
   acquire?: (req: ChildRunRequest, ticket: AdmissionTicket) => Promise<(terminal?: boolean) => void>;
   /**
@@ -462,8 +462,17 @@ class InProcessChildHandle implements DisposableChildHandle {
     await this.beginGeneration(message, false, false, gen);
   }
 
+  hosting(): { residency?: string; driver?: string; cacheExpiresAt?: number; sessionFile?: string; sessionId?: string } | undefined {
+    const session = this.session as { hosting?: () => { residency?: string; driver?: string; cacheExpiresAt?: number; sessionFile?: string; sessionId?: string } } | null;
+    return session?.hosting?.();
+  }
+
   async interrupt(): Promise<void> {
-    if (this.status_ !== "running" && this.status_ !== "pending") return;
+    if (this.status_ !== "running" && this.status_ !== "pending") {
+      const session = this.session as { park?: () => Promise<void> } | null;
+      if (session?.park) await session.park();
+      return;
+    }
     this.settle(this.generation, {
       status: "interrupted",
       // A pending turn has produced nothing yet; the last assistant text
@@ -563,8 +572,8 @@ class InProcessChildHandle implements DisposableChildHandle {
           signal: admissionAbort.signal,
         });
         if (this.disposed || this.isSettled(gen)) {
-          // A queued interruption is resumable; only disposal is terminal.
-          release(this.disposed);
+          // The turn is over (interrupted or disposed). The next turn acquires again.
+          release(true);
           return;
         }
         this.releaseSlot = release;
@@ -756,8 +765,9 @@ class InProcessChildHandle implements DisposableChildHandle {
       result.warning = this.session.warning;
     }
     this.status_ = result.status;
-    this.terminalSettle = result.status !== "interrupted" || result.error === "disposed";
-    this.release(this.terminalSettle);
+    // Every settled turn releases its machine permit, including an
+    // interrupted one. The next turn (resume, send, user input) acquires again.
+    this.release(true);
     this.notifyActivity();
     this.resolveResult(result);
   }

package/src/subagent/tool.ts

@@ -140,6 +140,8 @@ export interface SubagentToolDeps {
   /** Agent definition resolver (M5 wires the real loader; default: worker). */
   resolveAgent?: (name: string | undefined) => AgentDefinition;
   /** Selectable models for action:"models" (§4.6); absent → action errors. */
+  /** Receives the watcher for turns started by agent_message send. */
+  registerResumeWatch?: (watch: (childId: string) => void) => void;
   listModels?: () => {
     provider: string;
     id: string;
@@ -346,6 +348,20 @@ export function createSubagentTool(
     return true;
   };
 
+  const armResumeWake = (childId: string): void => {
+    const registry = deps.getRegistry();
+    if (!registry) return;
+    const record = registry.list().find((run) => run.children.some((c) => c.childId === childId));
+    if (!record) return;
+    const handedOver = new Set<string>();
+    void registry.getResult(childId)?.then(() => {
+      if (!notifyChildHandover(registry, record.runId, childId, handedOver)) {
+        notifyRunCompleted(registry, record.runId);
+      }
+    });
+  };
+  deps.registerResumeWatch?.(armResumeWake);
+
   const startRun = async (
     params: SubagentParams,
     signal: AbortSignal | undefined,
@@ -547,7 +563,18 @@ export function createSubagentTool(
       };
     }
 
-    const record = requireRun(registry, params.run_id);
+    const record = params.run_id
+      ? requireRun(registry, params.run_id)
+      : params.child_id
+        ? resolveRunByChild(registry, params.child_id)
+        : undefined;
+    if (!record) {
+      if (params.child_id && !params.run_id) {
+        throw new Error(`unknown child "${params.child_id}" (no run in this session holds it)`);
+      }
+      requireRun(registry, params.run_id);
+      throw new Error("run_id is required for this action");
+    }
 
     if (action === "get") {
       return {
@@ -585,18 +612,45 @@ export function createSubagentTool(
         const known = record.children.map((c) => `${c.name} (${c.childId})`).join(", ");
         throw new Error(`no child "${params.child_id}" in run ${record.runId} (children: ${known})`);
       }
+      const idle = record.children.filter((c) => {
+        if (params.child_id && c.childId !== params.child_id && c.name !== params.child_id) return false;
+        return c.status === "completed" || c.status === "failed" || c.status === "interrupted";
+      });
       for (const child of targets) {
         await registry.handle(child.childId)?.interrupt();
       }
-      const scope = params.child_id ? `subagent ${params.child_id}` : `${targets.length} subagent(s)`;
+      for (const child of idle) {
+        await registry.handle(child.childId)?.interrupt();
+      }
+      const interrupted = [...targets, ...idle].map((c) => c.childId);
+      const scope = params.child_id ? `subagent ${params.child_id}` : `${interrupted.length} subagent(s)`;
       return {
         content: [{ type: "text", text: `Interrupted ${scope} in run ${record.runId}.` }],
-        details: { run_id: record.runId, interrupted: targets.map((c) => c.childId) },
+        details: { run_id: record.runId, interrupted },
       };
     }
 
     if (action === "steer") {
       if (!params.message) throw new Error("message is required for steer");
+      const named = params.child_id
+        ? record.children.find((c) => c.childId === params.child_id || c.name === params.child_id)
+        : record.children.length === 1 ? record.children[0] : undefined;
+      if (named && named.status !== "running" && named.status !== "pending") {
+        const { queuedBehind } = await registry.resumeChild(named.childId, params.message);
+        armResumeWake(named.childId);
+        return {
+          content: [{
+            type: "text",
+            text: fill("tools.subagent.result.resumed", {
+              name: named.name,
+              childId: named.childId,
+              runId: record.runId,
+              queued: queuedText(queuedBehind),
+            }),
+          }],
+          details: { run_id: record.runId, child_id: named.childId, queued_behind: queuedBehind },
+        };
+      }
       const handle = resolveSingleActiveChild(registry, record, params.child_id, "steer");
       await handle.steer(params.message);
       return {
@@ -645,12 +699,7 @@ export function createSubagentTool(
     );
     // Resume is asynchronous. If siblings are still running, hand this child
     // back as soon as it finishes; otherwise the run-complete wake covers it.
-    const handedOver = new Set<string>();
-    void registry.getResult(child.childId)?.then(() => {
-      if (!notifyChildHandover(registry, record.runId, child.childId, handedOver)) {
-        notifyRunCompleted(registry, record.runId);
-      }
-    });
+    armResumeWake(child.childId);
     return {
       content: [
         {
@@ -733,6 +782,18 @@ export function createSubagentTool(
   };
 }
 
+function resolveRunByChild(registry: SubagentRegistry, childIdOrName: string) {
+  const runs = registry.list();
+  const byId = runs.filter((run) => run.children.some((c) => c.childId === childIdOrName));
+  if (byId.length === 1) return byId[0];
+  const byName = runs.filter((run) => run.children.some((c) => c.name === childIdOrName));
+  if (byName.length > 1) {
+    const ids = byName.map((run) => run.runId).join(", ");
+    throw new Error(`child name "${childIdOrName}" is in more than one run (${ids}); pass run_id`);
+  }
+  return byName[0];
+}
+
 /** Resume result clause for a turn waiting for an admission slot ("" when it started at once). */
 function queuedText(queuedBehind: number | null): string {
   if (queuedBehind === null) return "";

package/src/subagent/types.ts

@@ -135,6 +135,8 @@ export interface ChildHandle {
   tokenUsage(): ChildTokenUsage;
   /** Cumulative observed LLM, tool, admission-queue and approximate wall time. */
   wallUsage(): ChildWallUsage;
+  /** Hosted-process view, when this child runs as `pi --mode rpc`. */
+  hosting?(): { residency?: string; driver?: string; cacheExpiresAt?: number; sessionFile?: string; sessionId?: string } | undefined;
 }
 
 /**

package/src/tui/attach-command.ts

@@ -0,0 +1,164 @@
+/**
+ * `/attach <child>`: talk to a hosted subagent through the daemon, in the pi TUI.
+ * Lines are the child's transcript; Enter sends a prompt (steered while it runs).
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ManagerClient } from "../manager-client";
+import type { SubagentRegistry } from "../subagent/registry";
+import { fitLines, loadPiTui } from "./pi-tui-load";
+
+export interface AttachCommandDeps {
+  getClient: () => ManagerClient | null;
+  getRegistry: () => SubagentRegistry | null;
+}
+
+export function registerAttachCommand(pi: ExtensionAPI, deps: AttachCommandDeps): void {
+  pi.registerCommand("attach", {
+    description: "Talk to a hosted subagent (child id)",
+    getArgumentCompletions: () => {
+      const children = deps.getRegistry()?.list().flatMap((run) => run.children.map((child) => child.childId)) ?? [];
+      return children.map((id) => ({ value: id, label: id }));
+    },
+    handler: async (args, ctx) => {
+      const childId = args.trim();
+      if (!childId) {
+        ctx.ui.notify("Usage: /attach <child id>", "warning");
+        return;
+      }
+      const client = deps.getClient();
+      if (!client?.isAvailable() || client.protocolLevel() < 6) {
+        ctx.ui.notify("Hosted subagents need a connected pi-famulus daemon (protocol 6).", "error");
+        return;
+      }
+      if (!ctx.hasUI || ctx.mode !== "tui") {
+        ctx.ui.notify(`Attach from a terminal with: pi-famulus attach ${childId}`, "info");
+        return;
+      }
+      await openAttachView(ctx, client, childId);
+    },
+  });
+}
+
+interface EntryMessage {
+  role?: string;
+  content?: string | { text?: string }[];
+  message?: EntryMessage;
+}
+
+function textOf(message: EntryMessage | undefined): string {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => (typeof part === "string" ? part : part?.text ?? "")).join("");
+}
+
+function linesFromEntries(entries: unknown): string[] {
+  if (!Array.isArray(entries)) return [];
+  const out: string[] = [];
+  for (const entry of entries as EntryMessage[]) {
+    const message = entry.message ?? entry;
+    const text = textOf(message);
+    if (!text) continue;
+    if (message.role === "user") out.push(`you: ${text}`);
+    else if (message.role === "assistant") out.push(text);
+  }
+  return out;
+}
+
+/** Live transcript for one hosted child. Closing does not respawn a parked child. */
+export async function openAttachView(ctx: ExtensionContext, client: ManagerClient, childId: string): Promise<void> {
+  const piTui = loadPiTui();
+  if (!piTui) {
+    ctx.ui.notify(`pi-famulus attach ${childId}`, "info");
+    return;
+  }
+  await client.agentWatch(childId).catch((err: unknown) => {
+    throw new Error(err instanceof Error ? err.message : String(err));
+  });
+  const seeded = await client.agentInput(childId, "get_entries", "", "parent").catch(() => null);
+  const state = await client.agentInput(childId, "get_state", "", "parent").catch(() => null);
+  const lines: string[] = [`attached to ${childId}`, ""];
+  lines.push(...linesFromEntries(seeded?.entries));
+  let input = "";
+  let activity = state?.isStreaming === true ? "running" : "idle";
+  let status = activity;
+  let requestRender: (() => void) | null = null;
+  const unsub = client.onEvent((event) => {
+    const hosted = event as {
+      event?: string;
+      child_id?: string;
+      record?: { type?: string; message?: { role?: string; content?: { text?: string }[] } };
+      activity?: string;
+      residency?: string;
+      driver?: string;
+    };
+    if (hosted.child_id !== childId) return;
+    if (hosted.event === "agent_state") {
+      activity = hosted.activity ?? activity;
+      status = `${hosted.activity ?? "?"} · ${hosted.residency ?? "?"} · ${hosted.driver ?? "parent"}`;
+      requestRender?.();
+      return;
+    }
+    if (hosted.event !== "agent_rpc" || !hosted.record) return;
+    const record = hosted.record;
+    if (record.type === "message_end" && record.message?.role === "assistant") {
+      const text = textOf(record.message);
+      if (text) lines.push(text);
+    } else if (record.type === "agent_start") {
+      activity = "running";
+      lines.push("…");
+    }
+    requestRender?.();
+  });
+  try {
+    await ctx.ui.custom<void>((tui, _theme, _kb, done) => {
+      requestRender = () => tui.requestRender();
+      return {
+        render(width: number) {
+          const limit = Math.max(1, width);
+          const rows = Math.max(4, (tui.terminal?.rows ?? 24) - 6);
+          const body = lines.flatMap((line) => fitLines(line, limit)).slice(-rows);
+          return [
+            `◆ ${childId}  ${status}`,
+            ...body,
+            "",
+            `› ${input}`,
+            "enter send   esc close",
+          ];
+        },
+        invalidate() {},
+        handleInput(data: string) {
+          if (data === "\u001b") {
+            done();
+            return;
+          }
+          if (data === "\r" || data === "\n") {
+            const text = input;
+            input = "";
+            if (!text.trim()) return;
+            lines.push(`you: ${text}`);
+            const op = activity === "running" ? "prompt_steer" : "prompt";
+            void client.agentInput(childId, op, text, "user").catch((err: unknown) => {
+              lines.push(err instanceof Error ? err.message : String(err));
+              requestRender?.();
+            });
+            tui.requestRender();
+            return;
+          }
+          if (data === "\u007f" || data === "\b") {
+            input = input.slice(0, -1);
+            tui.requestRender();
+            return;
+          }
+          if (data.length === 1 && data >= " ") {
+            input += data;
+            tui.requestRender();
+          }
+        },
+      };
+    });
+  } finally {
+    unsub();
+    await client.agentUnwatch(childId).catch(() => {});
+  }
+}