@fitchmultz/pi-subagents 0.44.4 → 0.44.6

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/queries.ts

@@ -11,7 +11,9 @@ interface Cursor { generation: string; owner: string; version: number; query: st
 export class HistoryQueries {
 	private store: HistoryStore;
 	private info: () => HistoryVersion;
+	private configurations = new Map<string, HistoryConfiguration>();
 	constructor(store: HistoryStore, info: () => HistoryVersion) { this.store = store; this.info = info; }
+	sourcesRemoved(): void { this.configurations.clear(); }
 	private cursor(query: string, keys: (string | number)[], offset: number): string {
 		return Buffer.from(JSON.stringify({ generation: this.store.generation, owner: this.store.owner, version: this.info().version, query, keys, offset } satisfies Cursor)).toString("base64url");
 	}
@@ -80,6 +82,12 @@ export class HistoryQueries {
 		if (input.leaf === null) return {};
 		let boundary: ReturnType<HistoryQueries["boundary"]>;
 		try { boundary = this.boundary(source, input); } catch (error) { if (!strict && error instanceof HistoryIndexError && error.code === "BOUNDARY_UNAVAILABLE") return {}; throw error; }
+		// Only committed source changes invalidate ancestry, not unrelated run projections.
+		// Validate boundaries before reuse; explicit null leaves returned above remain empty.
+		const leafKey = input.leaf === undefined ? null : [typeof input.leaf, String(input.leaf)];
+		const key = JSON.stringify([source.id, source.generation, source.cursor, source.stamp, input.terminalEntryId || null, input.terminalEntryId ? null : input.endedAt ?? null, leafKey, strict]);
+		const cached = this.configurations.get(key);
+		if (cached) return { ...cached };
 		const leaf = input.leaf ?? this.store.get(`SELECT id FROM entries WHERE ${boundary.clauses.join(" AND ")} ORDER BY start DESC LIMIT 1`, ...boundary.params)?.id;
 		if (!leaf) return {};
 		// Fix recursive loop order: look up each child's parent by ID instead of
@@ -93,7 +101,11 @@ export class HistoryQueries {
 			(SELECT configuration_thinking FROM branch WHERE configuration_thinking IS NOT NULL ORDER BY start DESC LIMIT 1) AS thinking`, ...boundary.params, leaf);
 		if (!facts.count && input.leaf && strict) throw new HistoryIndexError("BOUNDARY_UNAVAILABLE", "Selected configuration leaf is not available in the indexed generation.");
 		if (facts.count && !facts.rooted) { if (!strict) return {}; throw new HistoryIndexError("MALFORMED_ANCESTRY", "Selected native configuration has cyclic ancestry."); }
-		return { ...(facts.model ? { model: facts.model, modelRecordedAt: facts.recorded_at ?? undefined } : {}), ...(facts.thinking ? { thinking: facts.thinking } : {}) };
+		const configuration = { ...(facts.model ? { model: facts.model, modelRecordedAt: facts.recorded_at ?? undefined } : {}), ...(facts.thinking ? { thinking: facts.thinking } : {}) };
+		// Bound memory across arbitrary sources, boundaries and pages. Eviction only recomputes.
+		if (this.configurations.size >= 128) this.configurations.delete(this.configurations.keys().next().value!);
+		this.configurations.set(key, configuration);
+		return { ...configuration };
 	}
 	historyPage(input: HistoryPageInput): HistoryPage {
 		const { source } = this.child(input.runId, input.index);
@@ -149,6 +161,12 @@ export class HistoryQueries {
 		if (input.runId) { clauses.push("c.run_id=?"); params.push(input.runId); }
 		if (input.index !== undefined) { clauses.push("c.child_index=?"); params.push(input.index); }
 		if (input.agent) { if (input.agent.length > 256) throw new HistoryIndexError("INVALID", "Agent filter is too long."); clauses.push("c.agent=?"); params.push(input.agent); }
+		const joins = "JOIN sources s ON s.id=e.source_id JOIN children c ON c.source_id=s.id LEFT JOIN entries terminal ON terminal.source_id=s.id AND terminal.generation=s.generation AND terminal.id=c.terminal_entry_id AND terminal.published=1";
+		// Scope records before materializing/grouping hits, while bm25 still sees the
+		// complete corpus. Scan each linked source once, not once per continuation.
+		// Attempt boundaries, attribution and seek filtering remain in the final join.
+		const eligible = input.runId || input.agent ? `eligible AS MATERIALIZED (SELECT e.rowid FROM entries e JOIN sources s ON s.id=e.source_id WHERE e.published=1 AND e.generation=s.generation AND e.source_id IN (SELECT c.source_id FROM children c WHERE ${clauses.slice(4).join(" AND ")})),` : "";
+		const eligibleParams = eligible ? params.slice(expression.length) : [];
 		// Ordering/filters apply globally before limit. Common terms may still require an FTS
 		// scan/sort; the parent enforces a hard deadline by killing this separate process.
 		const score = sort === "relevance" ? "matched.score" : "-COALESCE(e.timestamp,0)";
@@ -158,8 +176,8 @@ export class HistoryQueries {
 		}
 		// Match words across all visible fields/windows of one native record. A quoted
 		// phrase remains a single FTS expression, so it cannot span unrelated fields.
-		const rows = this.store.all(`WITH hits AS MATERIALIZED (
-			${expression.map((_term, index) => `SELECT d.id,d.entry_rowid,bm25(corpus) AS score,${index} AS term FROM corpus JOIN documents d ON d.id=corpus.rowid WHERE corpus MATCH ?`).join(" UNION ALL ")}
+		const rows = this.store.all(`WITH ${eligible} hits AS MATERIALIZED (
+			${expression.map((_term, index) => `SELECT d.id,d.entry_rowid,bm25(corpus) AS score,${index} AS term FROM corpus JOIN documents d ON d.id=corpus.rowid WHERE corpus MATCH ?${eligible ? " AND d.entry_rowid IN (SELECT rowid FROM eligible)" : ""}`).join(" UNION ALL ")}
 		), terms AS (
 			SELECT entry_rowid,term,MIN(score) AS score FROM hits GROUP BY entry_rowid,term
 		), matched AS (
@@ -167,7 +185,7 @@ export class HistoryQueries {
 		), excerpts AS (
 			SELECT id,entry_rowid,ROW_NUMBER() OVER (PARTITION BY entry_rowid ORDER BY score,id) AS choice FROM hits
 		)
-		SELECT d.*,${score} AS score,e.*,d.id AS document_id,s.path,s.session_id,c.run_id,c.child_index,c.agent,d.preview AS document_preview FROM matched JOIN excerpts ON excerpts.entry_rowid=matched.entry_rowid AND excerpts.choice=1 JOIN documents d ON d.id=excerpts.id JOIN entries e ON e.rowid=matched.entry_rowid JOIN sources s ON s.id=e.source_id JOIN children c ON c.source_id=s.id LEFT JOIN entries terminal ON terminal.source_id=s.id AND terminal.generation=s.generation AND terminal.id=c.terminal_entry_id AND terminal.published=1 WHERE ${clauses.join(" AND ")} ORDER BY score,d.id,c.run_id,c.child_index LIMIT ?`, ...params, limit + 1);
+		SELECT d.*,${score} AS score,e.*,d.id AS document_id,s.path,s.session_id,c.run_id,c.child_index,c.agent,d.preview AS document_preview FROM matched JOIN excerpts ON excerpts.entry_rowid=matched.entry_rowid AND excerpts.choice=1 JOIN documents d ON d.id=excerpts.id JOIN entries e ON e.rowid=matched.entry_rowid ${joins} WHERE ${clauses.join(" AND ")} ORDER BY score,d.id,c.run_id,c.child_index LIMIT ?`, ...eligibleParams, ...params, limit + 1);
 		const more = rows.length > limit, page = rows.slice(0, limit);
 		return { ...this.info(), matches: page.map((row) => ({ id: row.document_id, runId: row.run_id, index: row.child_index, agent: row.agent, entryId: row.id, nativeId: row.native_id, sessionId: row.session_id, sessionFile: row.path, timestamp: row.timestamp,
 			ref: { sourceId: row.source_id, generation: row.generation, start: row.start, end: row.end, digest: row.digest }, preview: row.document_preview, field: row.field, textStart: row.text_start, textEnd: row.text_end, score: row.score })),

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";
@@ -21,6 +21,8 @@ const sourceWatchers = new Map<string, fs.FSWatcher>();
 const watchIdentities = new WeakMap<fs.FSWatcher, string>();
 const watchedSources = new Map<string, Map<string, string>>();
 let job: SourceIngest | undefined, scheduled = false, closed = false;
+let sourceObservation: { state: string; error: string | null } | undefined;
+let notifiedVersion: string | undefined;
 let retryTimer: ReturnType<typeof setTimeout> | undefined;
 let runErrors = new Set<string>();
 const barriers: Array<{ id: number; runId?: string }> = [];
@@ -28,8 +30,18 @@ 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 changed(): void { send({ changed: true }); }
+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(observationChanged = false): void {
+	const version = store?.get("SELECT value FROM meta WHERE key='version'").value;
+	// Unchanged census projections need only one final freshness notification.
+	// Non-versioned errors/recovery and real commits still publish immediately.
+	if (observationChanged || version !== notifiedVersion || !hasPending()) {
+		notifiedVersion = version; send({ changed: true });
+	}
+}
 function errorReply(id: number, error: unknown): void {
 	const code = error instanceof HistoryIndexError ? error.code : "UNAVAILABLE";
 	// Parser errors can include fragments from the malformed body. IPC/logs must never carry them.
@@ -43,10 +55,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,
@@ -161,7 +173,11 @@ function prune(previousSources?: string[]): void {
 			store!.deleteDocuments(source.id);
 			store!.run("DELETE FROM entries WHERE source_id=?", source.id); store!.run("DELETE FROM sources WHERE id=?", source.id); removed = true;
 		}
-		if (removed) store!.bump();
+		if (removed) {
+			store!.bump();
+			// A later admission of the same path can recreate source generation 1.
+			queries?.sourcesRemoved();
+		}
 	});
 }
 function admit(run: OwnedRun): void {
@@ -198,23 +214,25 @@ function pump(): void {
 	try {
 		if (dirtyRuns.size) {
 			const id = dirtyRuns.values().next().value!; dirtyRuns.delete(id);
+			const failed = runErrors.has(id);
 			installWatches(id);
 			const previousSources = store.all("SELECT source_id FROM children WHERE run_id=? AND source_id IS NOT NULL", id).map((child) => child.source_id);
 			try { store.operations.runProjections++; const view = projection(runs.get(id)!); store.putView(compactView(view), view); runErrors.delete(id); }
 			catch { const view = unknown(runs.get(id)!, "Canonical owner summary is unavailable. Completion remains unconfirmed."); store.putView(compactView(view), view); runErrors.add(id); }
 			prune(previousSources);
 			for (const child of store.all("SELECT source_id FROM children WHERE run_id=? AND source_id IS NOT NULL", id)) if (child.source_id !== job?.id) dirtySources.set(child.source_id, dirtySources.get(child.source_id) ?? false);
-			installWatches(id); changed();
+			installWatches(id); changed(failed !== runErrors.has(id));
 		} else if (job) {
 			if (job.step()) {
 				const source = store.source(job.id);
 				if (source) watchSources(path.dirname(source.path));
-				job = undefined; changed();
+				job = undefined; changed(source?.state !== sourceObservation?.state || source?.error !== sourceObservation?.error);
+				sourceObservation = undefined;
 			}
 		} else if (dirtySources.size) {
 			const [id, force] = dirtySources.entries().next().value!; dirtySources.delete(id);
 			const source = store.source(id);
-			if (source) { activeSource = id; job = new SourceIngest(store, source, force); }
+			if (source) { activeSource = id; sourceObservation = source; job = new SourceIngest(store, source, force); }
 		}
 	} catch (error) {
 		const id = job?.id ?? activeSource;
@@ -227,7 +245,11 @@ function pump(): void {
 			else if ((error as NodeJS.ErrnoException).code === "ENOENT") store.resetSource(id, "missing", "Linked native conversation is missing.");
 			else store.run("UPDATE sources SET state='error',error=?,checked_at=? WHERE id=?", "Linked native conversation could not be indexed.", Date.now(), id);
 		}
-		if (!(error instanceof HistoryIndexError && error.code === "INDEX_BUSY")) changed();
+		if (!(error instanceof HistoryIndexError && error.code === "INDEX_BUSY")) {
+			const source = id ? store.source(id) : undefined;
+			changed(Boolean(source && (source.state !== sourceObservation?.state || source.error !== sourceObservation?.error)));
+		}
+		sourceObservation = undefined;
 	}
 	activeSource = undefined;
 	finishBarriers();
@@ -244,6 +266,7 @@ const timer = setInterval(census, 30_000); timer.unref();
 function clear(): void {
 	clearTimeout(retryTimer); retryTimer = undefined;
 	job?.close(); job = undefined;
+	sourceObservation = undefined; notifiedVersion = undefined;
 	for (const watcher of watchers.values()) watcher.close(); watchers.clear(); watchedSources.clear();
 	for (const watcher of sourceWatchers.values()) watcher.close(); sourceWatchers.clear();
 	dirtyRuns.clear(); dirtySources.clear(); runs.clear(); foreground.clear(); runErrors = new Set();
@@ -314,4 +337,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);