pi-crew 0.9.16 → 0.9.18

package/src/runtime/crew-agent-records.ts

@@ -1,14 +1,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { atomicWriteJson, atomicWriteJsonCoalesced, flushPendingAtomicWrites, readJsonFile } from "../state/atomic-write.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
-import type { CrewAgentProgress, CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
-import { taskStatusToAgentStatus } from "./crew-agent-runtime.ts";
 import { logInternalError } from "../utils/internal-error.ts";
-import { assertSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { redactSecretString, redactSecrets } from "../utils/redaction.ts";
+import { assertSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { sleepSync } from "../utils/sleep.ts";
+import type { CrewAgentProgress, CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { taskStatusToAgentStatus } from "./crew-agent-runtime.ts";
 
 export function agentsPath(manifest: TeamRunManifest): string {
 	return path.join(manifest.stateRoot, "agents.json");
@@ -65,7 +65,14 @@ const AGENT_READER_TTL_MS = 200;
 const ASYNC_AGENT_READER_CACHE_MAX_ENTRIES = 128;
 const AGENTS_LOCK_STALE_MS = 30_000;
 
-const asyncAgentReaderCache = new Map<string, { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }>();
+const asyncAgentReaderCache = new Map<
+	string,
+	{
+		expiresAt: number;
+		records: CrewAgentRecord[];
+		inFlight?: Promise<CrewAgentRecord[]>;
+	}
+>();
 
 function agentsLockPath(manifest: TeamRunManifest): string {
 	return `${agentsPath(manifest)}.lock`;
@@ -76,12 +83,20 @@ function removeStaleAgentsLock(lockPath: string, staleMs: number): boolean {
 		const stat = fs.statSync(lockPath);
 		if (stat.size > 1024) return false;
 		const raw = fs.readFileSync(lockPath, "utf-8");
-		const parsed = JSON.parse(raw) as { createdAt?: unknown; pid?: unknown };
+		const parsed = JSON.parse(raw) as {
+			createdAt?: unknown;
+			pid?: unknown;
+		};
 		const createdAt = typeof parsed.createdAt === "string" ? Date.parse(parsed.createdAt) : NaN;
 		if (Number.isFinite(createdAt) && Date.now() - createdAt <= staleMs) return false;
 		const pid = typeof parsed.pid === "number" ? parsed.pid : undefined;
 		if (pid && pid !== process.pid) {
-			try { process.kill(pid, 0); return false; } catch { /* owner dead */ }
+			try {
+				process.kill(pid, 0);
+				return false;
+			} catch {
+				/* owner dead */
+			}
 		}
 		fs.rmSync(lockPath, { force: true });
 		return true;
@@ -99,7 +114,13 @@ function withAgentsLock<T>(manifest: TeamRunManifest, fn: () => T): T {
 		try {
 			const fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
 			try {
-				fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+				fs.writeSync(
+					fd,
+					JSON.stringify({
+						pid: process.pid,
+						createdAt: new Date().toISOString(),
+					}),
+				);
 			} finally {
 				fs.closeSync(fd);
 			}
@@ -108,10 +129,15 @@ function withAgentsLock<T>(manifest: TeamRunManifest, fn: () => T): T {
 			const code = (error as NodeJS.ErrnoException).code;
 			if (code !== "EEXIST" && code !== "EISDIR") throw error;
 			if (code === "EISDIR") {
-				try { fs.rmSync(filePath, { recursive: true, force: true }); } catch { /* ignore */ }
+				try {
+					fs.rmSync(filePath, { recursive: true, force: true });
+				} catch {
+					/* ignore */
+				}
 				continue;
 			}
-			if (!removeStaleAgentsLock(filePath, AGENTS_LOCK_STALE_MS) && Date.now() > deadline) throw new Error(`Crew agents file is locked by another operation: ${agentsPath(manifest)}`);
+			if (!removeStaleAgentsLock(filePath, AGENTS_LOCK_STALE_MS) && Date.now() > deadline)
+				throw new Error(`Crew agents file is locked by another operation: ${agentsPath(manifest)}`);
 			sleepSync(Math.min(250, 25 * 2 ** attempt));
 			attempt += 1;
 		}
@@ -119,11 +145,22 @@ function withAgentsLock<T>(manifest: TeamRunManifest, fn: () => T): T {
 	try {
 		return fn();
 	} finally {
-		try { fs.rmSync(filePath, { force: true }); } catch { /* best-effort */ }
+		try {
+			fs.rmSync(filePath, { force: true });
+		} catch {
+			/* best-effort */
+		}
 	}
 }
 
-function setAsyncAgentReaderCache(filePath: string, entry: { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }): void {
+function setAsyncAgentReaderCache(
+	filePath: string,
+	entry: {
+		expiresAt: number;
+		records: CrewAgentRecord[];
+		inFlight?: Promise<CrewAgentRecord[]>;
+	},
+): void {
 	const now = Date.now();
 	for (const [key, cached] of asyncAgentReaderCache) {
 		if (cached.expiresAt <= now && !cached.inFlight) asyncAgentReaderCache.delete(key);
@@ -143,7 +180,11 @@ export function readCrewAgents(manifest: TeamRunManifest): CrewAgentRecord[] {
 	// after at most one coalesce window (250 ms).
 	flushPendingAtomicWrites();
 	try {
-		const records = readJsonFileCoalesced(agentsPath(manifest), AGENT_READER_TTL_MS, () => readJsonFile<CrewAgentRecord[]>(agentsPath(manifest)) ?? []);
+		const records = readJsonFileCoalesced(
+			agentsPath(manifest),
+			AGENT_READER_TTL_MS,
+			() => readJsonFile<CrewAgentRecord[]>(agentsPath(manifest)) ?? [],
+		);
 		// Validate schema and deduplicate by id to handle concurrent write conflicts
 		const seen = new Set<string>();
 		const deduped = records.filter((r) => {
@@ -171,7 +212,7 @@ export async function readCrewAgentsAsync(manifest: TeamRunManifest): Promise<Cr
 	const inFlight = (async (): Promise<CrewAgentRecord[]> => {
 		try {
 			const parsed = JSON.parse(await fs.promises.readFile(filePath, "utf-8")) as unknown;
-			const raw = Array.isArray(parsed) ? redactSecrets(parsed) as CrewAgentRecord[] : [];
+			const raw = Array.isArray(parsed) ? (redactSecrets(parsed) as CrewAgentRecord[]) : [];
 			// Deduplicate by id to handle concurrent write conflicts
 			const seen = new Set<string>();
 			const deduped = raw.filter((r) => {
@@ -181,16 +222,30 @@ export async function readCrewAgentsAsync(manifest: TeamRunManifest): Promise<Cr
 				return true;
 			});
 			if (deduped.length !== raw.length) {
-				try { saveCrewAgents(manifest, deduped); } catch { /* best-effort */ }
+				try {
+					saveCrewAgents(manifest, deduped);
+				} catch {
+					/* best-effort */
+				}
 			}
-			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records: deduped });
+			setAsyncAgentReaderCache(filePath, {
+				expiresAt: Date.now() + AGENT_READER_TTL_MS,
+				records: deduped,
+			});
 			return deduped;
 		} catch {
-			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records: [] });
+			setAsyncAgentReaderCache(filePath, {
+				expiresAt: Date.now() + AGENT_READER_TTL_MS,
+				records: [],
+			});
 			return [];
 		}
 	})();
-	setAsyncAgentReaderCache(filePath, { expiresAt: now + AGENT_READER_TTL_MS, records: cached?.records ?? [], inFlight });
+	setAsyncAgentReaderCache(filePath, {
+		expiresAt: now + AGENT_READER_TTL_MS,
+		records: cached?.records ?? [],
+		inFlight,
+	});
 	return inFlight;
 }
 
@@ -210,9 +265,7 @@ const TERMINAL_AGENT_STATUSES = new Set(["completed", "failed", "cancelled", "bl
  * User policy (v0.9.16): cancelled / stopped crew-agent records leave NO trace.
  * `failed` records keep their audit trail (different from cancel — agent errored).
  */
-export function shouldDeleteCrewAgentOnTerminalStatus(
-	record: Pick<CrewAgentRecord, "status">,
-): boolean {
+export function shouldDeleteCrewAgentOnTerminalStatus(record: Pick<CrewAgentRecord, "status">): boolean {
 	const s = record.status;
 	return s === "cancelled" || s === "stopped";
 }
@@ -222,10 +275,7 @@ export function shouldDeleteCrewAgentOnTerminalStatus(
  * and the per-task `status.json`. Called on cancellation to wipe the trace.
  * Safe-fail: missing files are treated as success (already removed).
  */
-export function removeCrewAgent(
-	manifest: TeamRunManifest,
-	taskId: string,
-): { removedIndex: boolean; removedStatus: boolean } {
+export function removeCrewAgent(manifest: TeamRunManifest, taskId: string): { removedIndex: boolean; removedStatus: boolean } {
 	let removedIndex = false;
 	let removedStatus = false;
 	// 1. Remove from agents.json index
@@ -254,7 +304,11 @@ export function removeCrewAgent(
 
 export function upsertCrewAgent(manifest: TeamRunManifest, record: CrewAgentRecord): void {
 	// Guard: skip if run state has been deleted (prune/forget/cleanup)
-	try { fs.statSync(manifest.stateRoot); } catch { return; }
+	try {
+		fs.statSync(manifest.stateRoot);
+	} catch {
+		return;
+	}
 	// User policy (v0.9.16): cancelled / stopped crew agents leave NO trace.
 	// We delete BOTH the index entry (agents.json) and the per-task status.json
 	// immediately so the UI dashboard/widget never see the cancelled agent again.
@@ -268,7 +322,7 @@ export function upsertCrewAgent(manifest: TeamRunManifest, record: CrewAgentReco
 	const existing = readCrewAgents(manifest);
 	// Deduplicate by id: keep newer record when same id appears
 	const idIndex = new Map(existing.map((item, i) => [item.id, i]));
-	const merged: CrewAgentRecord[] = existing.map((item) => item.id === record.id ? record : item);
+	const merged: CrewAgentRecord[] = existing.map((item) => (item.id === record.id ? record : item));
 	if (!idIndex.has(record.id)) merged.push(record);
 	// 2.5 caller migration: coalesce non-terminal progress writes; flush
 	// terminal statuses (completed/failed/cancelled/blocked) durably so
@@ -363,7 +417,9 @@ function writeSeqToSidecar(filePath: string, seq: number): void {
 function nextAgentEventSeq(filePath: string): number {
 	if (!fs.existsSync(filePath)) {
 		// Clean up stale sidecar when main file is gone.
-		try { fs.unlinkSync(`${filePath}.${AGENT_EVENT_SEQ_SIDECAR}`); } catch {}
+		try {
+			fs.unlinkSync(`${filePath}.${AGENT_EVENT_SEQ_SIDECAR}`);
+		} catch {}
 		return 1;
 	}
 	const stat = fs.statSync(filePath);
@@ -372,7 +428,11 @@ function nextAgentEventSeq(filePath: string): number {
 	// FIX: Try sidecar file for O(1) lookup before falling back to O(n) scan.
 	const sidecarSeq = readSeqFromSidecar(filePath);
 	if (sidecarSeq !== undefined) {
-		setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: sidecarSeq });
+		setAgentEventSeqCache(filePath, {
+			size: stat.size,
+			mtimeMs: stat.mtimeMs,
+			seq: sidecarSeq,
+		});
 		return sidecarSeq + 1;
 	}
 	let max = 0;
@@ -386,7 +446,11 @@ function nextAgentEventSeq(filePath: string): number {
 			max += 1;
 		}
 	}
-	setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: max });
+	setAgentEventSeqCache(filePath, {
+		size: stat.size,
+		mtimeMs: stat.mtimeMs,
+		seq: max,
+	});
 	writeSeqToSidecar(filePath, max);
 	return max + 1;
 }
@@ -398,7 +462,11 @@ export function appendCrewAgentEvent(manifest: TeamRunManifest, taskId: string,
 	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ seq, time: new Date().toISOString(), event }))}\n`, "utf-8");
 	try {
 		const stat = fs.statSync(filePath);
-		setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
+		setAgentEventSeqCache(filePath, {
+			size: stat.size,
+			mtimeMs: stat.mtimeMs,
+			seq,
+		});
 		writeSeqToSidecar(filePath, seq);
 	} catch (error) {
 		logInternalError("crew-agent-records.stat", error, `filePath=${filePath}`);
@@ -415,34 +483,64 @@ function readCrewAgentEvents(manifest: TeamRunManifest, taskId: string): unknown
 	return readCrewAgentEventsCursor(manifest, taskId).events;
 }
 
-export function readCrewAgentEventsCursor(manifest: TeamRunManifest, taskId: string, options: CrewAgentEventCursorOptions = {}): { path: string; events: unknown[]; nextSeq: number; total: number } {
+export function readCrewAgentEventsCursor(
+	manifest: TeamRunManifest,
+	taskId: string,
+	options: CrewAgentEventCursorOptions = {},
+): { path: string; events: unknown[]; nextSeq: number; total: number } {
 	let filePath: string;
 	try {
 		filePath = agentEventsPath(manifest, taskId);
 	} catch {
-		return { path: "", events: [], nextSeq: options.sinceSeq ?? 0, total: 0 };
+		return {
+			path: "",
+			events: [],
+			nextSeq: options.sinceSeq ?? 0,
+			total: 0,
+		};
 	}
-	if (!fs.existsSync(filePath)) return { path: filePath, events: [], nextSeq: options.sinceSeq ?? 0, total: 0 };
+	if (!fs.existsSync(filePath))
+		return {
+			path: filePath,
+			events: [],
+			nextSeq: options.sinceSeq ?? 0,
+			total: 0,
+		};
 	try {
 		filePath = safeExistingAgentFile(manifest, taskId, "events.jsonl");
 	} catch {
-		return { path: "", events: [], nextSeq: options.sinceSeq ?? 0, total: 0 };
+		return {
+			path: "",
+			events: [],
+			nextSeq: options.sinceSeq ?? 0,
+			total: 0,
+		};
 	}
-	const sinceSeq = typeof options.sinceSeq === "number" && Number.isInteger(options.sinceSeq) && options.sinceSeq >= 0 ? options.sinceSeq : 0;
+	const sinceSeq =
+		typeof options.sinceSeq === "number" && Number.isInteger(options.sinceSeq) && options.sinceSeq >= 0 ? options.sinceSeq : 0;
 	const limit = typeof options.limit === "number" && Number.isInteger(options.limit) && options.limit >= 0 ? options.limit : undefined;
-	const parsed = fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).map((line, index) => {
-		try {
-			const event = JSON.parse(line) as Record<string, unknown>;
-			if (typeof event.seq !== "number") event.seq = index + 1;
-			return event;
-		} catch {
-			return { seq: index + 1, raw: line };
-		}
-	});
+	const parsed = fs
+		.readFileSync(filePath, "utf-8")
+		.split(/\r?\n/)
+		.filter(Boolean)
+		.map((line, index) => {
+			try {
+				const event = JSON.parse(line) as Record<string, unknown>;
+				if (typeof event.seq !== "number") event.seq = index + 1;
+				return event;
+			} catch {
+				return { seq: index + 1, raw: line };
+			}
+		});
 	const filtered = parsed.filter((event) => typeof event.seq === "number" && event.seq > sinceSeq);
 	const events = limit !== undefined ? filtered.slice(0, limit) : filtered;
-	const returnedMaxSeq = events.reduce((max, event) => typeof event.seq === "number" ? Math.max(max, event.seq) : max, sinceSeq);
-	return { path: filePath, events, nextSeq: returnedMaxSeq, total: filtered.length };
+	const returnedMaxSeq = events.reduce((max, event) => (typeof event.seq === "number" ? Math.max(max, event.seq) : max), sinceSeq);
+	return {
+		path: filePath,
+		events,
+		nextSeq: returnedMaxSeq,
+		total: filtered.length,
+	};
 }
 
 export function appendCrewAgentOutput(manifest: TeamRunManifest, taskId: string, text: string): void {

package/src/runtime/crew-hooks.ts

@@ -25,12 +25,7 @@
 import { logInternalError } from "../utils/internal-error.ts";
 
 /** Valid hook event types in the crew lifecycle. */
-export type CrewHookEventType =
-	| 'task_started'
-	| 'task_completed'
-	| 'task_failed'
-	| 'run_completed'
-	| 'run_failed';
+export type CrewHookEventType = "task_started" | "task_completed" | "task_failed" | "run_completed" | "run_failed";
 
 /**
  * A hook event emitted by the crew runtime.
@@ -59,11 +54,7 @@ export type CrewHook = (event: CrewHookEvent) => void | Promise<void>;
  */
 export function isValidEventType(type: string): type is CrewHookEventType {
 	return (
-		type === 'task_started' ||
-		type === 'task_completed' ||
-		type === 'task_failed' ||
-		type === 'run_completed' ||
-		type === 'run_failed'
+		type === "task_started" || type === "task_completed" || type === "task_failed" || type === "run_completed" || type === "run_failed"
 	);
 }
 
@@ -71,15 +62,15 @@ export function isValidEventType(type: string): type is CrewHookEventType {
  * Type guard to check if an object is a valid CrewHookEvent.
  */
 export function isHookEvent(obj: unknown): obj is CrewHookEvent {
-	if (typeof obj !== 'object' || obj === null) return false;
+	if (typeof obj !== "object" || obj === null) return false;
 	const event = obj as Record<string, unknown>;
 	return (
-		typeof event.type === 'string' &&
+		typeof event.type === "string" &&
 		isValidEventType(event.type) &&
-		typeof event.timestamp === 'string' &&
-		typeof event.runId === 'string' &&
-		(event.taskId === undefined || typeof event.taskId === 'string') &&
-		(event.data === undefined || typeof event.data === 'object')
+		typeof event.timestamp === "string" &&
+		typeof event.runId === "string" &&
+		(event.taskId === undefined || typeof event.taskId === "string") &&
+		(event.data === undefined || typeof event.data === "object")
 	);
 }
 
@@ -96,13 +87,7 @@ export class HookRegistry {
 	constructor() {
 		this.hooks = new Map();
 		// Initialize with empty Sets for all event types
-		const eventTypes: CrewHookEventType[] = [
-			'task_started',
-			'task_completed',
-			'task_failed',
-			'run_completed',
-			'run_failed',
-		];
+		const eventTypes: CrewHookEventType[] = ["task_started", "task_completed", "task_failed", "run_completed", "run_failed"];
 		for (const type of eventTypes) {
 			this.hooks.set(type, new Set());
 		}

package/src/runtime/cross-extension-rpc.ts

@@ -5,9 +5,7 @@ export interface EventBus {
 	emit(event: string, data: unknown): void;
 }
 
-export type RpcReply<T = void> =
-	| { success: true; data?: T }
-	| { success: false; error: string };
+export type RpcReply<T = void> = { success: true; data?: T } | { success: false; error: string };
 
 export const PROTOCOL_VERSION = 1;
 
@@ -84,39 +82,43 @@ export function registerCrewRpcHandlers(deps: RpcDeps): RpcHandle {
 		if (params.token !== EXPECTED_TOKEN) {
 			console.warn(
 				`[pi-crew SECURITY] RPC invocation rejected: missing/invalid token (source=${params.source ?? "(none)"}). ` +
-				`Privileged RPC requires the in-process token. Request may be from an untrusted extension.`,
+					`Privileged RPC requires the in-process token. Request may be from an untrusted extension.`,
 			);
 			return false;
 		}
 		if (!params.source || params.source !== CREW_RPC_SOURCE) {
 			console.warn(
 				`[pi-crew SECURITY] RPC invocation from unexpected source: ${params.source ?? "(none)"}. ` +
-				`Expected '${CREW_RPC_SOURCE}'. Request may be from an untrusted extension.`,
+					`Expected '${CREW_RPC_SOURCE}'. Request may be from an untrusted extension.`,
 			);
 			return false;
 		}
 		return true;
 	}
 
-	const unsubSpawn = handleRpc<{ requestId: string; type: string; prompt: string; options?: Record<string, unknown>; source?: string; token?: string }>(
-		events,
-		"crew:rpc:spawn",
-		(params) => {
-			if (!validateRpcSource(params)) throw new Error("Unauthorized: RPC spawn requires valid token and source='pi-crew'");
-			const ctx = getCtx();
-			if (!ctx) throw new Error("No active session");
-			return { id: spawn(params.type, params.prompt, params.options ?? {}) };
-		},
-	);
+	const unsubSpawn = handleRpc<{
+		requestId: string;
+		type: string;
+		prompt: string;
+		options?: Record<string, unknown>;
+		source?: string;
+		token?: string;
+	}>(events, "crew:rpc:spawn", (params) => {
+		if (!validateRpcSource(params)) throw new Error("Unauthorized: RPC spawn requires valid token and source='pi-crew'");
+		const ctx = getCtx();
+		if (!ctx) throw new Error("No active session");
+		return { id: spawn(params.type, params.prompt, params.options ?? {}) };
+	});
 
-	const unsubStop = handleRpc<{ requestId: string; agentId: string; source?: string; token?: string }>(
-		events,
-		"crew:rpc:stop",
-		(params) => {
-			if (!validateRpcSource(params)) throw new Error("Unauthorized: RPC stop requires valid token and source='pi-crew'");
-			if (!abort(params.agentId)) throw new Error("Agent not found");
-		},
-	);
+	const unsubStop = handleRpc<{
+		requestId: string;
+		agentId: string;
+		source?: string;
+		token?: string;
+	}>(events, "crew:rpc:stop", (params) => {
+		if (!validateRpcSource(params)) throw new Error("Unauthorized: RPC stop requires valid token and source='pi-crew'");
+		if (!abort(params.agentId)) throw new Error("Agent not found");
+	});
 
 	return { unsubPing, unsubSpawn, unsubStop };
 }

package/src/runtime/custom-tools/irc-tool.ts

@@ -13,15 +13,19 @@
  */
 
 import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "@sinclair/typebox";
-import { listLiveAgents, sendIrcMessage, broadcastIrcMessage, respondAsBackground } from "../live-agent-manager.ts";
+import { type Static, Type } from "@sinclair/typebox";
+import { broadcastIrcMessage, listLiveAgents, respondAsBackground, sendIrcMessage } from "../live-agent-manager.ts";
 import type { IrcMessage } from "../live-irc.ts";
 
 const IrcParams = Type.Object({
 	op: Type.Union(
 		[
-			Type.Literal("send", { description: "Send a message to one peer or to all peers." }),
-			Type.Literal("list", { description: "List currently visible peers." }),
+			Type.Literal("send", {
+				description: "Send a message to one peer or to all peers.",
+			}),
+			Type.Literal("list", {
+				description: "List currently visible peers.",
+			}),
 		],
 		{ description: "IRC operation." },
 	),
@@ -37,7 +41,8 @@ const IrcParams = Type.Object({
 	),
 	awaitReply: Type.Optional(
 		Type.Boolean({
-			description: "Wait for a prose reply (default: true for DM, false for broadcast). For DMs the recipient receives the message as a non-blocking background turn and its reply is returned to the caller. Broadcast always ignores this flag.",
+			description:
+				"Wait for a prose reply (default: true for DM, false for broadcast). For DMs the recipient receives the message as a non-blocking background turn and its reply is returned to the caller. Broadcast always ignores this flag.",
 		}),
 	),
 });
@@ -74,9 +79,7 @@ interface IrcDetails {
  *
  * @param selfId — This agent's ID (runId:taskId format)
  */
-export function createIrcTool(
-	selfId: string,
-): ToolDefinition<typeof IrcParams, IrcDetails> {
+export function createIrcTool(selfId: string): ToolDefinition<typeof IrcParams, IrcDetails> {
 	return defineTool({
 		name: "irc",
 		label: "IRC",
@@ -95,7 +98,10 @@ export function createIrcTool(
 			_signal: AbortSignal | undefined,
 			_onUpdate: unknown,
 			_ctx: unknown,
-		): Promise<{ content: Array<{ type: "text"; text: string }>; details: IrcDetails }> {
+		): Promise<{
+			content: Array<{ type: "text"; text: string }>;
+			details: IrcDetails;
+		}> {
 			if (params.op === "list") {
 				return executeList(selfId);
 			}
@@ -104,13 +110,20 @@ export function createIrcTool(
 			}
 			return {
 				content: [{ type: "text", text: "Unknown irc op." }],
-				details: { op: params.op, from: selfId, error: "Unknown operation." },
+				details: {
+					op: params.op,
+					from: selfId,
+					error: "Unknown operation.",
+				},
 			};
 		},
 	});
 }
 
-function executeList(selfId: string): { content: Array<{ type: "text"; text: string }>; details: IrcDetails } {
+function executeList(selfId: string): {
+	content: Array<{ type: "text"; text: string }>;
+	details: IrcDetails;
+} {
 	const agents = listLiveAgents();
 	const peers = agents
 		.filter((a) => a.agentId !== selfId && (a.status === "running" || a.status === "queued"))
@@ -135,7 +148,10 @@ function executeList(selfId: string): { content: Array<{ type: "text"; text: str
 async function executeSend(
 	selfId: string,
 	params: IrcParams,
-): Promise<{ content: Array<{ type: "text"; text: string }>; details: IrcDetails }> {
+): Promise<{
+	content: Array<{ type: "text"; text: string }>;
+	details: IrcDetails;
+}> {
 	const to = params.to?.trim();
 	const message = params.message?.trim();
 
@@ -148,13 +164,23 @@ async function executeSend(
 	if (!message) {
 		return {
 			content: [{ type: "text", text: '`message` is required for op="send".' }],
-			details: { op: "send", from: selfId, to, error: "Missing 'message' field." },
+			details: {
+				op: "send",
+				from: selfId,
+				to,
+				error: "Missing 'message' field.",
+			},
 		};
 	}
 	if (to === selfId) {
 		return {
 			content: [{ type: "text", text: "Cannot send a message to yourself." }],
-			details: { op: "send", from: selfId, to, error: "Self-message not allowed." },
+			details: {
+				op: "send",
+				from: selfId,
+				to,
+				error: "Self-message not allowed.",
+			},
 		};
 	}
 
@@ -188,7 +214,9 @@ async function executeSend(
 			if (!target || (target.status !== "running" && target.status !== "queued")) {
 				notFound.push(to);
 			} else {
-				const result = await respondAsBackground(to, selfId, message, { awaitReply: true });
+				const result = await respondAsBackground(to, selfId, message, {
+					awaitReply: true,
+				});
 				if (result.ok) {
 					delivered.push(to);
 					if (result.replyContent) replies.push({ from: to, text: result.replyContent });

package/src/runtime/custom-tools/submit-result-tool.ts

@@ -10,9 +10,9 @@
  */
 
 import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "@sinclair/typebox";
-import type { YieldResult } from "../yield-handler.ts";
+import { type Static, Type } from "@sinclair/typebox";
 import { logInternalError } from "../../utils/internal-error.ts";
+import type { YieldResult } from "../yield-handler.ts";
 
 const SubmitResultParams = Type.Object({
 	summary: Type.String({ description: "Summary of completed work." }),
@@ -64,7 +64,10 @@ export function createSubmitResultTool(
 			_signal: AbortSignal | undefined,
 			_onUpdate: unknown,
 			_ctx: unknown,
-		): Promise<{ content: Array<{ type: "text"; text: string }>; details: SubmitResultDetails }> {
+		): Promise<{
+			content: Array<{ type: "text"; text: string }>;
+			details: SubmitResultDetails;
+		}> {
 			const result: YieldResult = {
 				summary: params.summary,
 				toolCallId,
@@ -72,8 +75,16 @@ export function createSubmitResultTool(
 				...(params.structuredData ? { structuredData: params.structuredData } : {}),
 			};
 			// Build response first so the model always gets confirmation
-			const response: { content: Array<{ type: "text"; text: string }>; details: SubmitResultDetails } = {
-				content: [{ type: "text", text: "Result submitted successfully. Thank you." }],
+			const response: {
+				content: Array<{ type: "text"; text: string }>;
+				details: SubmitResultDetails;
+			} = {
+				content: [
+					{
+						type: "text",
+						text: "Result submitted successfully. Thank you.",
+					},
+				],
 				details: {
 					summary: params.summary,
 					artifacts: params.artifacts,