@fitchmultz/pi-subagents 0.44.4 → 0.44.5

package/scripts/intercom-remote.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import https from "node:https";
+import { lstatSync, readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+
+function help() {
+  console.log(`Usage: node intercom-remote.mjs <register|list|inbox|send|ask|reply|ack> [options] [IDs...]
+
+Environment (required):
+  INTERCOM_BRIDGE_CA    Path to trusted bridge CA certificate
+  INTERCOM_BRIDGE_CERT  Path to your client certificate
+  INTERCOM_BRIDGE_KEY   Path to your private client key (owned, mode 0600)
+  INTERCOM_BRIDGE_URL   HTTPS origin (default: https://127.0.0.1:9443)
+
+Options:
+  --to PEER            Recipient name or ID for send/ask
+  --message TEXT       Message for send/ask/reply
+  --reply-to ID        Inbound ask ID from inbox, for reply
+  --timeout-ms MS      Ask timeout (100..120000, default: 120000)
+  -h, --help           Show help
+
+Examples:
+  node intercom-remote.mjs list
+  node intercom-remote.mjs ask --to planner --message 'What is the current status?'
+  node intercom-remote.mjs inbox
+  node intercom-remote.mjs reply --reply-to QUESTION_ID --message 'Proceed.'
+  node intercom-remote.mjs ack MESSAGE_ID
+
+Outputs JSON. Exit: 0 success, 1 API/TLS/transport failure, 2 invalid arguments.
+No automatic retries: a lost response does not prove a message was unsent.`);
+}
+
+let options, body, action, origin, timeout;
+try {
+  const parsed = parseArgs({ allowPositionals: true, options: {
+    help: { type: "boolean", short: "h" }, to: { type: "string" }, message: { type: "string" },
+    "reply-to": { type: "string" }, "timeout-ms": { type: "string" },
+  } });
+  if (parsed.values.help) { help(); process.exit(0); }
+  options = parsed.values;
+  [action] = parsed.positionals;
+  if (!["register", "list", "inbox", "send", "ask", "reply", "ack"].includes(action)) throw new Error("Choose an action; use --help.");
+  const allowed = ["send", "ask"].includes(action) ? ["to", "message", ...(action === "ask" ? ["timeout-ms"] : [])] : action === "reply" ? ["reply-to", "message"] : [];
+  if (Object.keys(options).some((key) => !allowed.includes(key)) ||
+      (action !== "ack" && parsed.positionals.length !== 1)) throw new Error("Unexpected arguments for this action.");
+  timeout = options["timeout-ms"] === undefined ? 120000 : Number(options["timeout-ms"]);
+  if (!Number.isInteger(timeout) || timeout < 100 || timeout > 120000) throw new Error("--timeout-ms must be 100..120000.");
+  body = ["send", "ask"].includes(action) ? { to: options.to, message: options.message, ...(action === "ask" ? { timeoutMs: timeout } : {}) }
+    : action === "reply" ? { replyTo: options["reply-to"], message: options.message }
+    : action === "ack" ? { ids: parsed.positionals.slice(1) } : {};
+  if (["send", "ask", "reply"].includes(action) && (!body.message?.trim() || !(action === "reply" ? body.replyTo : body.to)?.trim())) throw new Error("Recipient/ask ID and message are required.");
+  if (action === "ack" && body.ids.length === 0) throw new Error("ack needs at least one message ID.");
+  origin = new URL(process.env.INTERCOM_BRIDGE_URL || "https://127.0.0.1:9443");
+  if (origin.protocol !== "https:" || origin.username || origin.password || origin.pathname !== "/" || origin.search || origin.hash) throw new Error("INTERCOM_BRIDGE_URL must be an HTTPS origin, without credentials or a path.");
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, error: { code: "invalid_arguments", message: error.message } }));
+  process.exit(2);
+}
+
+try {
+  const files = {};
+  for (const field of ["CA", "CERT", "KEY"]) {
+    const path = process.env[`INTERCOM_BRIDGE_${field}`];
+    if (!path) throw new Error(`INTERCOM_BRIDGE_${field} is required.`);
+    if (field === "KEY") {
+      const st = lstatSync(path);
+      if (!st.isFile() || st.uid !== process.getuid() || (st.mode & 0o077)) throw new Error("Client key must be an owned private regular file (0600).");
+    }
+    files[field] = readFileSync(path);
+  }
+  origin.pathname = `/v1/${action}`;
+  const payload = JSON.stringify(body);
+  const get = ["list", "inbox"].includes(action);
+  const result = await new Promise((resolve, reject) => {
+    const req = https.request(origin, {
+      method: get ? "GET" : "POST", ca: files.CA, cert: files.CERT, key: files.KEY,
+      rejectUnauthorized: true, minVersion: "TLSv1.2", agent: false,
+      headers: get ? {} : { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) },
+    }, (res) => {
+      const chunks = [];
+      let bytes = 0;
+      res.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > 16 * 1024 * 1024) { req.destroy(new Error("Bridge response exceeds 16 MiB.")); return; }
+        chunks.push(chunk);
+      });
+      res.on("error", reject);
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, value: JSON.parse(Buffer.concat(chunks).toString("utf8")) }); }
+        catch { reject(new Error("Bridge returned invalid JSON.")); }
+      });
+    });
+    const timer = setTimeout(() => req.destroy(new Error("Bridge request deadline exceeded; delivery may be unknown.")), (action === "ask" ? timeout : 0) + 15000);
+    req.once("close", () => clearTimeout(timer));
+    req.once("error", reject);
+    req.end(get ? undefined : payload);
+  });
+  console.log(JSON.stringify(result.value, null, 2));
+  if (result.status < 200 || result.status >= 300 || result.value?.ok !== true) process.exitCode = 1;
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, error: { code: "transport_error", message: error.message, delivery: "unknown; do not blindly retry mutations" } }));
+  process.exitCode = 1;
+}

package/scripts/package-smoke.mjs

@@ -77,6 +77,10 @@ for (const path of [
 	"dist/extension/index.js",
 	"dist/pi-intercom/index.js",
 	"dist/pi-intercom/broker/broker.js",
+	"dist/pi-intercom/bridge.js",
+	"scripts/intercom-bridge-credentials.mjs",
+	"scripts/intercom-remote.mjs",
+	"docs/intercom-bridge.md",
 	"dist/runs/background/subagent-runner-launcher.js",
 	"src/extension/index.ts",
 	"src/extension/schemas.ts",

package/src/extension/compact-tools.ts

@@ -67,7 +67,7 @@ export function registerCompactSubagentTools(pi: ExtensionAPI, options: {
 		name: "agent_runs",
 		defaultActive: false,
 		label: "Agent Runs",
-		description: `List ${childSafe ? "only this child's directly owned" : "your delegated"} runs across working directories (questions/failures, then live work, then unreviewed results; 20 per page). Filter globally by agent/state/text, sort, and page with the returned cursor. history reads 100 bounded native-entry previews; search finds saved visible text using words or quoted phrases, not operators or prefixes. Browse freshness is not completion or delivery proof. Inspect concise results, paths and continuations; full:true includes the full task/configuration. Answer durable questions, nudge, stop, continue, or save parent-only review. Review notes are not sent to children; put actionable instructions in continue/nudge. Inspect/review/nudge never restart finished work. Continue/answer can launch a saved child; async:false waits for its actual result. Saved continuations keep settings unless agent selects a current profile; model overrides win. Live guidance never mutates model or acceptance. profiles lists roles, sources, context and model/thinking/fallback defaults. History survives reload.`,
+		description: `List ${childSafe ? "only this child's directly owned" : "your delegated"} runs across working directories (questions/failures, then live work, then unreviewed results; 20 per page). Filter globally by agent/state/text, sort, and page with the returned cursor. history reads 100 bounded native-entry previews; search finds saved visible text using words or quoted phrases, not operators or prefixes. questions pages 20 compact previews (offset/limit); questionId selects one, and questionPath/answerPath retain full records. Browse freshness is not completion or delivery proof. Inspect concise results, paths and continuations; full:true includes the full task/configuration. Answer durable questions, nudge, stop, continue, or save parent-only review. Review notes are not sent to children; put actionable instructions in continue/nudge. Inspect/review/nudge never restart finished work. Continue/answer can launch a saved child; async:false waits for its actual result. Saved continuations keep settings unless agent selects a current profile; model overrides win. Live guidance never mutates model or acceptance. profiles lists roles, sources, context and model/thinking/fallback defaults. History survives reload.`,
 		parameters: AgentRunsParams,
 		async execute(id, params, signal, onUpdate, ctx) {
 			const normalized = normalizeEverydayParams(params, true);

package/src/extension/schemas.ts

@@ -279,13 +279,13 @@ const HistoryQueryFields = {
 export const AgentRunsValidationParams = Type.Object({
 	action: Type.Enum(["list", "inspect", "history", "search", "nudge", "stop", "continue", "profiles", "questions", "answer", "review"] as const, { type: "string" }),
 	id: Type.Optional(Type.String({ minLength: 1, description: "Run ID or unambiguous prefix." })),
-	questionId: Type.Optional(Type.String({ minLength: 1, description: "Durable supervisor question ID for answer." })),
+	questionId: Type.Optional(Type.String({ minLength: 1, description: "Durable supervisor question ID for exact questions lookup or answer." })),
 	async: Type.Optional(Type.Boolean({ description: "Continue/answer: false waits for the actual continuation result." })),
 	index: Type.Optional(Type.Integer({ minimum: 0, description: "Child index for a multi-child run." })),
 	message: Type.Optional(Type.String({ minLength: 1, description: "Guidance, follow-up, answer, or optional parent-only review note. Review notes are not sent to the child; put actionable instructions in continue/nudge. Only continue/answer can start a saved child." })),
 	decision: Type.Optional(Type.Enum(["accepted", "needs_changes"] as const, { type: "string", description: "Parent-only review outcome; not sent to the child. Separate from execution and runtime acceptance checks." })),
-	offset: Type.Optional(Type.Integer({ minimum: 0, description: "List offset; history is retained regardless of page size." })),
-	limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, description: "Results per list/search/history page (default 20; history 100)." })),
+	offset: Type.Optional(Type.Integer({ minimum: 0, description: "List/questions offset; history is retained regardless of page size." })),
+	limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, description: "Results per list/questions/search/history page (default 20; history 100)." })),
 	...HistoryQueryFields,
 	full: Type.Optional(Type.Boolean({ description: "Inspect only: include the full task and saved launch configuration. Default is a concise report; stored data is unchanged." })),
 	agent: Type.Optional(Type.String({ minLength: 1, description: "List/search: filter by child agent. Continue/answer: adopt this current profile, including model, thinking and fallbacks; a separate model override wins. Otherwise keep saved settings. Required for old runs without a saved profile." })),
@@ -303,8 +303,8 @@ export const AgentRunsValidationParams = Type.Object({
 		{ if: { properties: { action: { enum: ["review"] } } }, then: requiredObject("decision") },
 		{ if: { anyOf: [requiredObject("async"), requiredObject("model"), requiredObject("cwd"), requiredObject("output"), requiredObject("acceptance")] }, then: { properties: { action: { enum: ["continue", "answer"] } } } },
 		{ if: requiredObject("agent"), then: { properties: { action: { enum: ["list", "search", "continue", "answer"] } } } },
-		{ if: requiredObject("offset"), then: { properties: { action: { enum: ["list"] } } } },
-		{ if: requiredObject("limit"), then: { properties: { action: { enum: ["list", "history", "search"] } } } },
+		{ if: requiredObject("offset"), then: { properties: { action: { enum: ["list", "questions"] } } } },
+		{ if: requiredObject("limit"), then: { properties: { action: { enum: ["list", "questions", "history", "search"] } } } },
 		{ if: requiredObject("cursor"), then: { properties: { action: { enum: ["list", "history", "search"] } } } },
 		{ if: requiredObject("sort"), then: { properties: { action: { enum: ["list", "search"] } } } },
 		{ not: { anyOf: [requiredObject("cursor", "offset"), requiredObject("cursor", "before")] } },
@@ -339,9 +339,9 @@ export const SubagentParams = Type.Object({
 	runId: Type.Optional(Type.String({
 		description: "Target run ID; prefer id. Defaults to the most recently active controllable run for interrupt/extend/nudge."
 	})),
-	questionId: Type.Optional(Type.String({ minLength: 1, description: "Durable supervisor question ID for answer." })),
+	questionId: AgentRunsValidationParams.properties.questionId,
 	decision: Type.Optional(Type.Enum(["accepted", "needs_changes"] as const, { type: "string", description: "Parent-only review decision; not sent to the child. Put actionable instructions in resume/nudge. Does not launch work or change runtime acceptance." })),
-	offset: Type.Optional(Type.Integer({ minimum: 0, description: "Status list offset." })),
+	offset: Type.Optional(Type.Integer({ minimum: 0, description: "Status list/questions offset." })),
 	limit: AgentRunsValidationParams.properties.limit,
 	...HistoryQueryFields,
 	full: Type.Optional(Type.Boolean({ description: "Exact status only: include the full task and saved launch configuration; default is concise." })),
@@ -418,8 +418,8 @@ export const SubagentParams = Type.Object({
 		{ if: requiredObject("decision"), then: { ...requiredObject("action"), properties: { action: { enum: ["review"] } } } },
 		{ if: { ...requiredObject("action"), properties: { action: { enum: ["history"] } } }, then: { anyOf: [requiredObject("id"), requiredObject("runId")] } },
 		{ if: { ...requiredObject("action"), properties: { action: { enum: ["search"] } } }, then: requiredObject("query") },
-		{ if: requiredObject("offset"), then: { ...requiredObject("action"), properties: { action: { enum: ["status"] } } } },
-		{ if: requiredObject("limit"), then: { ...requiredObject("action"), properties: { action: { enum: ["status", "history", "search"] } } } },
+		{ if: requiredObject("offset"), then: { ...requiredObject("action"), properties: { action: { enum: ["status", "questions"] } } } },
+		{ if: requiredObject("limit"), then: { ...requiredObject("action"), properties: { action: { enum: ["status", "questions", "history", "search"] } } } },
 		{ if: requiredObject("cursor"), then: { ...requiredObject("action"), properties: { action: { enum: ["status", "history", "search"] } } } },
 		{ if: requiredObject("sort"), then: { ...requiredObject("action"), properties: { action: { enum: ["status", "search"] } } } },
 		{ if: { allOf: [{ ...requiredObject("action"), properties: { action: { enum: ["search"] } } }, requiredObject("index")] }, then: { anyOf: [requiredObject("id"), requiredObject("runId")] } },

package/src/history/index.ts

@@ -87,6 +87,15 @@ export class SubagentHistoryIndex {
 		}
 		await this.ready;
 	}
+	/** Arms an ordinary deadline only in the continuation that saw the current admission and worker settle, never behind a replacement admission. */
+	private async admitted<T>(method: string, input?: unknown, signal?: AbortSignal, timeout?: number): Promise<T> {
+		await this.ensure();
+		const ready = this.ready, child = this.process;
+		await ready;
+		// setOwner() or a restart may have replaced readiness during either await; wait for the replacement.
+		if (!child || ready !== this.ready || child !== this.process) return this.admitted<T>(method, input, signal, timeout);
+		return this.send<T>(method, input, signal, timeout);
+	}
 	async setOwner(input: HistoryOwner): Promise<void> {
 		if (this.closed) throw new HistoryIndexError("CLOSED", "History index is closed.");
 		if (!this.process) await Promise.all(this.children.values());
@@ -104,20 +113,16 @@ export class SubagentHistoryIndex {
 		await this.ensure();
 		if (run.ownerSessionId !== this.owner!.ownerSessionId || foreground && foreground.runId !== run.runId) throw new HistoryIndexError("OWNERSHIP", "Run does not belong to the current owner.");
 		const copy = structuredClone(run), fg = foreground && structuredClone(foreground);
-		await this.send<void>("updateRun", { run: copy, foreground: fg });
+		await this.admitted<void>("updateRun", { run: copy, foreground: fg });
 		this.owner!.runs = [...this.owner!.runs.filter((entry) => entry.runId !== run.runId), copy];
 		if (fg) this.owner!.foregroundRuns = [...(this.owner!.foregroundRuns ?? []).filter((entry) => entry.runId !== run.runId), fg];
 	}
 	private async query<T>(method: string, input: { signal?: AbortSignal }): Promise<T> {
-		await this.ensure();
 		const { signal, ...wire } = input;
-		return this.send<T>(method, wire, signal);
+		return this.admitted<T>(method, wire, signal);
 	}
 	/** Tool discovery waits for run metadata only, not transcript backfill. */
-	async needsControls(): Promise<boolean> {
-		await this.ensure();
-		return this.send("needsControls", undefined, undefined, 15_000);
-	}
+	needsControls(): Promise<boolean> { return this.admitted("needsControls", undefined, undefined, 15_000); }
 	listRuns(options: HistoryRunOptions = {}): Promise<HistoryRunPage> { return this.query("listRuns", options); }
 	historyPage(input: HistoryPageInput): Promise<HistoryPage> { return this.query("historyPage", input); }
 	search(input: HistorySearchInput): Promise<HistorySearchPage> { return this.query("search", input); }
@@ -130,8 +135,7 @@ export class SubagentHistoryIndex {
 	result(input: Pick<HistoryEntryInput, "runId" | "index" | "signal">): Promise<HistoryResult | null> { return this.query("result", input); }
 	async refresh(runId?: string, options: { signal?: AbortSignal } = {}): Promise<void> {
 		if (!this.closed) this.unavailable = undefined;
-		await this.ensure();
-		return this.send("refresh", { runId }, options.signal, 120_000);
+		return this.admitted("refresh", { runId }, options.signal, 120_000);
 	}
 	onChanged(listener: () => void): () => void { this.listeners.add(listener); return () => this.listeners.delete(listener); }
 	/** Hard cancellation affects this instance's outstanding work, not native sessions or other indexers. */

package/src/history/ingest.ts

@@ -175,8 +175,13 @@ export class SourceIngest {
 	private fd: number;
 	private initial: fs.BigIntStats;
 	private source: SourceRow;
-	private prefix: Hash = createHash("sha256");
 	private recordDigest: Hash = createHash("sha256");
+	/** prefix_digest is "start:sha256" of the last indexed line; earlier releases hashed the whole prefix. */
+	private legacy = false;
+	private expected: string | null = null;
+	private verified: Hash = createHash("sha256");
+	private line: Hash = createHash("sha256");
+	private lineStart = 0;
 	private verifyAt = 0;
 	private position: number;
 	private frames: JournalFrames;
@@ -208,6 +213,10 @@ export class SourceIngest {
 			this.headerSeen = source.cursor > 0;
 			store.clearUnpublished(source.id);
 			store.run("DELETE FROM pending_text");
+			// Appends re-hash only the last indexed line, so live sources cost their new bytes, not their size.
+			const anchor = /^(\d+):([0-9a-f]{64})$/.exec(source.prefix_digest ?? "");
+			this.legacy = !anchor; this.expected = anchor ? anchor[2] : source.prefix_digest;
+			this.verifyAt = this.lineStart = anchor ? Number(anchor[1]) : 0;
 			this.phase = !force && source.stamp === stamp(this.initial) ? "done" : source.cursor ? "verify" : "read";
 			if (this.phase !== "done") store.run("UPDATE sources SET state='indexing',error=NULL WHERE id=?", source.id);
 			this.frames = new JournalFrames(previewProjection, (record) => {
@@ -224,7 +233,7 @@ export class SourceIngest {
 			const current = this.store.source(this.id)!;
 			if (!current || current.generation !== this.source.generation || current.cursor !== this.source.cursor) throw new HistoryIndexError("SOURCE_CHANGED", "Another writer advanced this source; reconcile before replaying.");
 			work?.();
-			this.store.run("UPDATE sources SET cursor=?,prefix_digest=?,identity=? WHERE id=?", end, this.prefix.copy().digest("hex"), identity(this.initial), this.id);
+			this.store.run("UPDATE sources SET cursor=?,prefix_digest=?,identity=? WHERE id=?", end, `${this.source.cursor}:${this.recordDigest.copy().digest("hex")}`, identity(this.initial), this.id);
 			this.store.bump();
 		});
 		this.source.cursor = end;
@@ -293,11 +302,19 @@ export class SourceIngest {
 			const count = fs.readSync(this.fd, bytes, 0, bytes.length, this.verifyAt);
 			if (count !== bytes.length) throw new Error("Journal truncated during prefix verification.");
 			this.store.operations.sourceBytesRead += count;
-			this.prefix.update(bytes); this.verifyAt += count;
+			this.verified.update(bytes);
+			if (this.legacy) {
+				// A whole-prefix check also finds the last indexed line, which anchors every later check.
+				const before = this.source.cursor - 2 - this.verifyAt, lf = before < 0 ? -1 : bytes.lastIndexOf(10, before);
+				if (lf < 0) this.line.update(bytes);
+				else { this.lineStart = this.verifyAt + lf + 1; this.line = createHash("sha256").update(bytes.subarray(lf + 1)); }
+			}
+			this.verifyAt += count;
 			if (this.verifyAt === this.source.cursor) {
-				if (this.prefix.copy().digest("hex") !== this.source.prefix_digest) {
+				if (this.verified.digest("hex") !== this.expected) {
 					this.store.resetSource(this.id); throw new HistoryIndexError("SOURCE_CHANGED", "Journal prefix changed; a new physical generation was scheduled.");
 				}
+				if (this.legacy) this.store.run("UPDATE sources SET prefix_digest=? WHERE id=?", `${this.lineStart}:${this.line.digest("hex")}`, this.id);
 				this.phase = "read";
 			}
 			return false;
@@ -313,7 +330,7 @@ export class SourceIngest {
 		}
 		const newline = this.buffer.indexOf(10);
 		const bytes = newline < 0 ? this.buffer : this.buffer.subarray(0, newline + 1);
-		this.recordDigest.update(bytes); this.prefix.update(bytes); this.frames.write(bytes); this.text.flush(this.store);
+		this.recordDigest.update(bytes); this.frames.write(bytes); this.text.flush(this.store);
 		this.buffer = this.buffer.subarray(bytes.length);
 		if (newline >= 0) this.finishRecord(this.frames.offset);
 		return false;

package/src/history/worker.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { ownedRunView } from "../runs/shared/run-records.ts";
 import { acceptanceHumanAction } from "../runs/shared/acceptance-evaluation.ts";
-import { getRunMetadataDir, listRunQuestions } from "../runs/shared/supervisor-questions.ts";
+import { getRunMetadataDir, listRunQuestions, summarizeSupervisorQuestion } from "../runs/shared/supervisor-questions.ts";
 import { HistoryIndexError } from "./types.ts";
 import type { ForegroundResumeRun, HistoryOwner, HistoryRunRow, OwnedRun, Request, Response } from "./types.ts";
 import type { SubagentState } from "../shared/types.ts";
@@ -28,7 +28,10 @@ const controlQueries: number[] = [];
 function replyControls(id: number): void {
 	send({ id, value: Boolean(store!.get("SELECT id FROM runs WHERE attention<4 OR state='live' LIMIT 1")) });
 }
-function send(response: Response): void { if (process.connected) process.send!(response); }
+function send(response: Response): void {
+	// The parent can disconnect after process.connected was read; then this and later replies are undeliverable, so stop as on disconnect.
+	if (process.connected) process.send!(response, undefined, undefined, (error) => { if (error) shutdown(); });
+}
 function changed(): void { send({ changed: true }); }
 function errorReply(id: number, error: unknown): void {
 	const code = error instanceof HistoryIndexError ? error.code : "UNAVAILABLE";
@@ -43,10 +46,10 @@ function compactView(view: HistoryRunRow): HistoryRunRow {
 	return {
 		...view, task: safeText(view.task, 2048), error: view.error && safeText(view.error), diagnosis: view.diagnosis && safeText(view.diagnosis), recoveryError: view.recoveryError && safeText(view.recoveryError),
 		review: view.review && { ...view.review, message: view.review.message && safeText(view.review.message) }, continuations: [],
-		questions: view.questions?.map((question) => ({ questionId: question.questionId, runId: question.runId, ownerSessionId: question.ownerSessionId, ownerTarget: question.ownerTarget,
-			agent: question.agent, index: question.index, childSessionId: question.childSessionId, childTarget: question.childTarget, sessionFile: question.sessionFile,
-			cwd: question.cwd, pid: question.pid, processIdentity: question.processIdentity, createdAt: question.createdAt, reason: question.reason, message: safeText(question.message, 2048), state: question.state,
-			answer: question.answer && { ...question.answer, message: safeText(question.answer.message, 2048) }, delivery: question.delivery, revival: question.revival })),
+		questions: view.questions?.map((question) => {
+			const summary = summarizeSupervisorQuestion(question);
+			return { ...summary, message: safeText(question.message, 2048), answer: summary.answer && { ...summary.answer, message: safeText(question.answer?.message, 2048) } };
+		}),
 		children: view.children.map((child) => ({
 			agent: child.agent, index: child.index, workflowNodeId: child.workflowNodeId, sessionFile: child.sessionFile, task: child.task && safeText(child.task), label: child.label && safeText(child.label, 256),
 			state: child.state, configuration: child.configuration, missingSession: child.missingSession, identityUnavailable: child.identityUnavailable, modelSelection: child.modelSelection,
@@ -314,4 +317,5 @@ async function handle(request: Request): Promise<void> {
 	} catch (error) { errorReply(request.id, error); }
 }
 process.on("message", (request: Request) => { void handle(request); });
-process.on("disconnect", () => { closed = true; clearInterval(timer); clear(); process.exit(0); });
+function shutdown(): void { closed = true; clearInterval(timer); clear(); process.exit(0); }
+process.on("disconnect", shutdown);