@zetaloop/chappie 0.3.2 → 0.4.1

package/src/broker.ts

@@ -1,7 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import type { ToolCall, ToolResultMessage } from "@earendil-works/pi-ai";
+import { type Activity, chatLabel, source } from "./activity.ts";
 import { readConfig } from "./config.ts";
 import type { DeliveryRecord } from "./delivery.ts";
+import { type HistoryRange, historyInstructions } from "./history.ts";
 import {
 	type BrokerMessage,
 	IpcServer,
@@ -23,6 +25,9 @@ import { type ResourceData, resourceSessionId } from "./resources.ts";
 import { State } from "./state.ts";
 import type { ToolInput } from "./tools.ts";
 
+const coordinationInstructions =
+	"Report your goal and progress through chat using your initialization name. The coordinator decides who continues, their tasks, and who exits. Follow the decision through chat and history; if asked to exit, leave a handoff and end this response.";
+
 interface RegisteredSession {
 	description: SessionDescription;
 	peer: JsonLinePeer<SessionMessage, BrokerMessage>;
@@ -36,9 +41,21 @@ interface PendingRequest {
 	onAbort(): void;
 }
 
-interface Workflow {
-	id: string;
+interface InitializationGrant {
+	sessionId: string;
+	code: string;
+	previousCode: string | undefined;
+	committed: boolean;
+}
+
+interface Operation {
+	chatId: string;
+	sessionId: string | undefined;
 	controller: AbortController;
+	communication: boolean;
+	coordinating: boolean;
+	revisions: Map<string, number>;
+	initialization?: InitializationGrant;
 }
 
 interface ChangeWaiter {
@@ -48,28 +65,35 @@ interface ChangeWaiter {
 	onAbort(): void;
 }
 
+export interface Initialization {
+	name?: string;
+	code?: string;
+	sessionId: string;
+	instructions: string;
+}
+
 export interface InitializedSession extends Omit<SessionInspection, "tools"> {
 	selection: "existing" | "explicit" | "automatic";
+	initialization?: Initialization;
 	globalAgents?: string;
 	inputs: SessionInput[];
 	tools: { name: string; description: string }[];
 }
 
 export interface InspectedSession extends SessionInspection {
+	initialization?: Initialization;
 	inputs: SessionInput[];
 }
 
 export interface ChatResult {
+	initialization?: Initialization;
 	sessionId: string;
 	cwd: string;
 	inputs: SessionInput[];
 }
 
-export interface CallResult {
-	sessionId: string;
-	cwd: string;
+export interface CallResult extends ChatResult {
 	toolResults: ToolResultMessage[];
-	inputs: SessionInput[];
 }
 
 export class Broker {
@@ -79,9 +103,12 @@ export class Broker {
 	readonly #sessions = new Map<string, RegisteredSession>();
 	readonly #pending = new Map<number, PendingRequest>();
 	readonly #waiters = new Set<ChangeWaiter>();
-	readonly #workflows = new Map<string, Workflow>();
+	readonly #operations = new Map<AbortSignal, Operation>();
+	readonly #locks = new Map<string, boolean>();
+	readonly #startingLocks = new Set<string>();
+	readonly #syncRevisions = new Map<string, number>();
 	#ask = true;
-	#latestWorkflow = false;
+	#sync = false;
 	#nextRequestId = 1;
 
 	constructor(agentDir: string) {
@@ -97,17 +124,20 @@ export class Broker {
 	async start(): Promise<void> {
 		const config = await readConfig(this.#agentDir);
 		this.#ask = config.ask ?? true;
-		this.#latestWorkflow = config.latestWorkflow ?? false;
+		this.#sync = config.sync ?? false;
 		await this.#state.load();
 		await this.#ipc.start(config.listen ?? false);
 	}
 
 	async close(): Promise<void> {
 		const error = new Error("Chappie broker ended");
-		for (const workflow of this.#workflows.values()) {
-			workflow.controller.abort(error);
+		for (const operation of this.#operations.values()) {
+			operation.controller.abort(error);
 		}
-		this.#workflows.clear();
+		this.#operations.clear();
+		this.#locks.clear();
+		this.#startingLocks.clear();
+		this.#syncRevisions.clear();
 		for (const [id, pending] of this.#pending) {
 			this.#finishRequest(id, pending);
 			pending.reject(error);
@@ -121,43 +151,213 @@ export class Broker {
 		await this.#ipc.close();
 	}
 
-	async workflow(
-		chatId: string | undefined,
+	async run<T>(
+		chatId: string,
+		sessionId: string | undefined,
+		signal: AbortSignal,
+		callback: (signal: AbortSignal) => Promise<T>,
+		communication = false,
+	): Promise<T> {
+		if (!communication) this.#requireUnlocked(chatId, sessionId, signal);
+		if (!this.#sync) return callback(signal);
+		const controller = new AbortController();
+		const combined = AbortSignal.any([signal, controller.signal]);
+		const operation: Operation = {
+			chatId,
+			sessionId,
+			controller,
+			communication,
+			coordinating: false,
+			revisions: new Map(),
+		};
+		this.#operations.set(combined, operation);
+		this.#observe(operation, this.#state.binding(chatId));
+		this.#observe(operation, sessionId);
+		try {
+			const result = await callback(combined);
+			combined.throwIfAborted();
+			const initialization = operation.initialization;
+			if (initialization) {
+				initialization.previousCode = this.#state.code(
+					initialization.sessionId,
+				);
+				initialization.committed = true;
+				await this.#state.setCode(
+					initialization.sessionId,
+					initialization.code,
+				);
+				combined.throwIfAborted();
+			}
+			return result;
+		} catch (error) {
+			await this.#rollbackInitialization(operation);
+			throw error;
+		} finally {
+			this.#operations.delete(combined);
+		}
+	}
+
+	deliveryAllowed(signal: AbortSignal): boolean {
+		const operation = this.#operations.get(signal);
+		if (!operation?.communication) return true;
+		if (operation.coordinating) return false;
+		for (const [sessionId, revision] of operation.revisions) {
+			if (
+				this.#locks.has(sessionId) ||
+				(this.#syncRevisions.get(sessionId) ?? 0) !== revision
+			)
+				return false;
+		}
+		return true;
+	}
+
+	get syncEnabled(): boolean {
+		return this.#sync;
+	}
+
+	syncState(sessionId: string) {
+		return {
+			locked: this.#locks.has(sessionId),
+			verified: this.#locks.get(sessionId) ?? false,
+		};
+	}
+
+	synchronizing(chatId?: string, sessionId?: string): string | undefined {
+		const boundId = chatId ? this.#state.binding(chatId) : undefined;
+		if (boundId && this.#locks.has(boundId)) return boundId;
+		if (sessionId && this.#locks.has(sessionId)) return sessionId;
+		return undefined;
+	}
+
+	async sync(
+		chatId: string,
+		sessionId: string | undefined,
+		action: "start" | "verify" | "release",
+		code: string | undefined,
 		requestId: unknown,
 		signal: AbortSignal,
-	): Promise<AbortSignal> {
-		if (!this.#latestWorkflow || !chatId) return signal;
-		const id = workflowId(requestId);
-		if (!id) return signal;
+	) {
+		if (!this.#sync) throw new Error("Session synchronization is disabled");
 		signal.throwIfAborted();
-		const latest = this.#state.workflow(chatId);
-		const superseded = new Error(
-			"A newer workflow is handling this chat. Stop this workflow.",
-		);
-		// UUIDv7 puts the creation timestamp first, including across broker restarts.
-		if (latest && id < latest) throw superseded;
-		let workflow = this.#workflows.get(chatId);
-		if (!workflow || workflow.id !== id) {
-			const previous = workflow;
-			workflow = { id, controller: new AbortController() };
-			this.#workflows.set(chatId, workflow);
-			previous?.controller.abort(superseded);
-			if (latest !== id) await this.#state.setWorkflow(chatId, id);
+		const target = sessionId ?? this.#state.binding(chatId);
+		if (!target) throw new Error("Specify a Pi sessionId to synchronize");
+		const locked = this.synchronizing(chatId);
+		if (locked && locked !== target) throw new Error(syncMessage(locked));
+		const activity = source(chatId, requestId);
+		const result = { sessionId: target };
+		if (action === "start") {
+			if (!this.#locks.has(target)) {
+				this.#locks.set(target, false);
+				this.#startingLocks.add(target);
+				this.#syncRevisions.set(
+					target,
+					(this.#syncRevisions.get(target) ?? 0) + 1,
+				);
+				const error = new Error(syncMessage(target));
+				const rollbacks: Promise<void>[] = [];
+				for (const operation of this.#operations.values()) {
+					if (
+						operation.sessionId !== target &&
+						this.#state.binding(operation.chatId) !== target
+					)
+						continue;
+					if (operation.initialization)
+						rollbacks.push(this.#rollbackInitialization(operation));
+					if (!operation.communication || operation.initialization)
+						operation.controller.abort(error);
+				}
+				this.#notifyChange();
+				try {
+					await Promise.all(rollbacks);
+					if (!this.#state.code(target)) {
+						this.#locks.delete(target);
+						this.#notifyChange();
+						throw new Error(
+							"Initialize this Pi session before starting synchronization",
+						);
+					}
+					await this.#notify(
+						target,
+						`${chatLabel(activity)} started synchronization`,
+						{ ...activity, event: "sync_started" },
+					);
+				} finally {
+					this.#startingLocks.delete(target);
+				}
+			}
+			return {
+				...result,
+				...this.syncState(target),
+				instructions: syncMessage(target),
+			};
+		}
+		if (this.#startingLocks.has(target))
+			throw new Error("Synchronization is still starting; retry this action");
+		if (!this.#locks.has(target))
+			throw new Error("This Pi session is not synchronizing");
+		const current = this.#state.code(target);
+		if (!current)
+			throw new Error("This Pi session has no synchronization code");
+		if (code !== current) {
+			await this.#notify(
+				target,
+				`${chatLabel(activity)} could not verify synchronization`,
+				{ ...activity, event: "sync_rejected" },
+			);
+			throw new Error(
+				`Invalid sync code. Ordinary tools remain locked. ${coordinationInstructions}`,
+			);
 		}
-		const combined = AbortSignal.any([signal, workflow.controller.signal]);
-		combined.throwIfAborted();
-		return combined;
+		if (action === "verify") {
+			let renewed: string | undefined;
+			if (!this.#locks.get(target)) {
+				this.#locks.set(target, true);
+				renewed = randomBytes(6).toString("hex");
+				await this.#state.setCode(target, renewed);
+				await this.#notify(
+					target,
+					`${chatLabel(activity)} verified synchronization`,
+					{ ...activity, event: "sync_verified" },
+				);
+			}
+			return {
+				...result,
+				...this.syncState(target),
+				...(renewed ? { code: renewed } : {}),
+				instructions:
+					"You are the coordinator. Decide who continues, their tasks, and who exits; you may retain only one execution. Keep this code private. Release after your decisions are acknowledged and requested exits are complete.",
+			};
+		}
+		if (!this.#locks.get(target))
+			throw new Error(
+				"Verify the initialization code before releasing synchronization",
+			);
+		this.#locks.delete(target);
+		this.#notifyChange();
+		await this.#notify(
+			target,
+			`${chatLabel(activity)} released synchronization`,
+			{ ...activity, event: "sync_released" },
+		);
+		return {
+			...result,
+			...this.syncState(target),
+			instructions:
+				"Synchronization released. Continue as directed by the coordinator.",
+		};
 	}
 
-	listSessions(
-		sessionId?: string,
-	): (SessionDescription & { bindingCount: number })[] {
+	listSessions(sessionId?: string): (SessionDescription & {
+		bindingCount: number;
+		sync?: { locked: boolean; verified: boolean };
+	})[] {
 		const counts = this.#state.bindingCounts();
 		return [...this.#sessions.values()]
 			.filter(({ description }) => !sessionId || description.id === sessionId)
 			.map(({ description }) => ({
 				...description,
 				bindingCount: counts.get(description.id) ?? 0,
+				...(this.#sync ? { sync: this.syncState(description.id) } : {}),
 			}));
 	}
 
@@ -175,20 +375,19 @@ export class Broker {
 		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<InitializedSession> {
-		const { sessionId: target, selection } = await this.#selectSession(
-			chatId,
-			sessionId,
-			requestId,
-			signal,
-			true,
-		);
+		const {
+			sessionId: target,
+			selection,
+			initialization,
+		} = await this.#selectSession(chatId, sessionId, requestId, signal, true);
 		const { inspection, inputs, globalAgents } = await this.#inspect(
 			target,
 			signal,
 		);
-		await this.#ackInputs(target, inputs);
+		await this.#ackInputs(target, inputs, signal);
 		return {
 			selection,
+			...(initialization ? { initialization } : {}),
 			...inspection,
 			tools: inspection.tools.map(({ name, description }) => ({
 				name,
@@ -206,20 +405,34 @@ export class Broker {
 		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<ChatResult> {
-		const { sessionId: target } = await this.#selectSession(
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
 			requestId,
 			signal,
+			false,
+			true,
 		);
 		const result = await this.#request(
 			target,
-			(id) => ({ type: "chat", id, chatId, sessionId: target, text }),
+			(id) => ({
+				type: "chat",
+				id,
+				...source(chatId, requestId),
+				sessionId: target,
+				text,
+			}),
 			signal,
 		);
 		if ("message" in result) {
-			await this.#ackInputs(target, result.inputs);
-			return { sessionId: target, cwd: result.cwd, inputs: result.inputs };
+			const inputs = this.deliveryAllowed(signal) ? result.inputs : [];
+			await this.#ackInputs(target, inputs, signal);
+			return {
+				sessionId: target,
+				cwd: result.cwd,
+				inputs,
+				...(initialization ? { initialization } : {}),
+			};
 		}
 		throw new Error("Pi session returned no assistant message");
 	}
@@ -231,17 +444,18 @@ export class Broker {
 		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<InspectedSession> {
-		const { sessionId: target } = await this.#selectSession(
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
 			requestId,
 			signal,
 		);
 		const { inspection, inputs } = await this.#inspect(target, signal);
-		await this.#ackInputs(target, inputs);
+		await this.#ackInputs(target, inputs, signal);
 		const selected = names ? new Set(names) : undefined;
 		return {
 			...inspection,
+			...(initialization ? { initialization } : {}),
 			tools: selected
 				? inspection.tools.filter(({ name }) => selected.has(name))
 				: inspection.tools,
@@ -256,7 +470,7 @@ export class Broker {
 		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<CallResult> {
-		const { sessionId: target } = await this.#selectSession(
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
 			requestId,
@@ -273,16 +487,17 @@ export class Broker {
 			(id) => ({
 				type: "call",
 				id,
-				chatId,
+				...source(chatId, requestId),
 				sessionId: target,
 				calls: toolCalls,
 			}),
 			signal,
 		);
 		if ("toolResults" in result) {
-			await this.#ackInputs(target, result.inputs);
+			await this.#ackInputs(target, result.inputs, signal);
 			return {
 				sessionId: target,
+				...(initialization ? { initialization } : {}),
 				cwd: result.cwd,
 				toolResults: result.toolResults,
 				inputs: result.inputs,
@@ -291,19 +506,42 @@ export class Broker {
 		throw new Error("Pi session returned no tool results");
 	}
 
-	async inputs(
+	async history(
 		chatId: string,
 		sessionId: string | undefined,
+		range: HistoryRange,
 		requestId: unknown,
 		signal: AbortSignal,
+	) {
+		const target = sessionId ?? this.#state.binding(chatId);
+		if (!target) throw new Error("Specify a Pi sessionId to read history");
+		await this.#waitForSession(target, signal);
+		const result = await this.#request(
+			target,
+			(id) => ({
+				type: "history",
+				id,
+				sessionId: target,
+				range,
+				...source(chatId, requestId),
+			}),
+			signal,
+		);
+		if ("history" in result) return { sessionId: target, ...result };
+		throw new Error("Pi session returned no history");
+	}
+
+	async inputs(
+		chatId: string,
+		sessionId: string | undefined,
+		signal: AbortSignal,
 	): Promise<SessionInput[]> {
-		const boundId = this.#state.binding(chatId);
-		const target = sessionId ?? boundId;
-		if (!target || !this.#sessions.has(target)) return [];
-		signal.throwIfAborted();
-		if (target === boundId) await this.#join(chatId, target, requestId);
+		const target = sessionId ?? this.#state.binding(chatId);
+		if (!target || !this.#sessions.has(target) || !this.deliveryAllowed(signal))
+			return [];
 		const { inputs } = await this.#inspect(target, signal);
-		await this.#ackInputs(target, inputs);
+		if (!this.deliveryAllowed(signal)) return [];
+		await this.#ackInputs(target, inputs, signal);
 		return inputs;
 	}
 
@@ -313,13 +551,14 @@ export class Broker {
 		input: QuestionInput,
 		requestId: unknown,
 		signal: AbortSignal,
-	): Promise<Question> {
-		const { sessionId: target } = await this.#selectSession(
+	): Promise<Question & { initialization?: Initialization }> {
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
 			requestId,
 			signal,
 		);
+		this.#requireUnlocked(chatId, target, signal);
 		const session = this.#sessions.get(target);
 		if (!session) throw new Error(`Pi session ${target} is offline`);
 		const question: QuestionRecord = {
@@ -331,11 +570,19 @@ export class Broker {
 			delivered: false,
 		};
 		await this.#state.addQuestion(question);
+		const activity = source(chatId, requestId);
 		void this.#notify(
 			target,
-			`ChatGPT ${chatId.slice(-4)} asked: ${question.question}`,
+			`${chatLabel(activity)} asked: ${question.question}`,
+			{
+				event: "asked",
+				...activity,
+			},
 		).catch(() => {});
-		return questionView(question);
+		return {
+			...questionView(question),
+			...(initialization ? { initialization } : {}),
+		};
 	}
 
 	async assertQuestion(
@@ -346,6 +593,7 @@ export class Broker {
 		for (;;) {
 			signal.throwIfAborted();
 			const question = this.#state.question(chatId, id);
+			this.#requireUnlocked(chatId, question.sessionId, signal);
 			if (question.loaded) return questionView(question);
 			await this.#waitForChange(signal);
 		}
@@ -380,14 +628,20 @@ export class Broker {
 					: previous
 						? `Answer updated in ChatGPT ${chatId.slice(-4)}: ${question.question} — ${response}`
 						: `Answered in ChatGPT ${chatId.slice(-4)}: ${question.question} — ${response}`;
-				void this.#notify(question.sessionId, message).catch(() => {});
+				void this.#notify(question.sessionId, message, {
+					event: question.answer?.skipped ? "skipped" : "answered",
+					chatId,
+				}).catch(() => {});
 			}
 		}
 		return questionView(question);
 	}
 
 	answers(chatId: string): QuestionRecord[] {
-		return this.#state.answers(chatId);
+		if (this.synchronizing(chatId)) return [];
+		return this.#state
+			.answers(chatId)
+			.filter((question) => !this.#locks.has(question.sessionId));
 	}
 
 	async readResource(uri: string, signal: AbortSignal): Promise<ResourceData> {
@@ -403,7 +657,10 @@ export class Broker {
 	}
 
 	deliveries(chatId: string): DeliveryRecord[] {
-		return this.#state.deliveries(chatId);
+		if (this.synchronizing(chatId)) return [];
+		return this.#state
+			.deliveries(chatId)
+			.filter((delivery) => !this.#locks.has(delivery.sessionId));
 	}
 
 	acknowledge(
@@ -432,7 +689,9 @@ export class Broker {
 					sessionId: message.session.id,
 				});
 				if (!registered)
-					await this.#notify(message.session.id, "Chappie connected");
+					await this.#notify(message.session.id, "Chappie connected", {
+						event: "connected",
+					});
 				this.#notifyChange();
 				break;
 			}
@@ -465,40 +724,48 @@ export class Broker {
 		requestId: unknown,
 		signal: AbortSignal,
 		bindRequested = false,
+		communication = false,
 	): Promise<{
 		sessionId: string;
 		selection: InitializedSession["selection"];
+		initialization?: Initialization;
 	}> {
-		if (requestedId) {
-			await this.#waitForSession(requestedId, signal);
-			signal.throwIfAborted();
-			const boundId = this.#state.binding(chatId);
-			if (bindRequested || !boundId || boundId === requestedId) {
-				await this.#join(chatId, requestedId, requestId, bindRequested);
-			}
-			return { sessionId: requestedId, selection: "explicit" };
-		}
-
 		for (;;) {
 			signal.throwIfAborted();
 			const boundId = this.#state.binding(chatId);
-			if (boundId) {
-				await this.#waitForSession(boundId, signal);
-				signal.throwIfAborted();
-				if (bindRequested || this.#state.binding(chatId) === boundId) {
-					await this.#join(chatId, boundId, requestId, bindRequested);
-				}
-				return { sessionId: boundId, selection: "existing" };
+			let target = requestedId ?? boundId;
+			if (!target) {
+				const occupied = this.#state.bindingCounts();
+				target = [...this.#sessions.keys()].find(
+					(id) => !occupied.has(id) && !this.#locks.has(id),
+				);
 			}
-			const occupied = this.#state.bindingCounts();
-			const candidate = [...this.#sessions.keys()].find(
-				(sessionId) => !occupied.has(sessionId),
-			);
-			if (candidate) {
-				await this.#join(chatId, candidate, requestId, bindRequested);
-				return { sessionId: candidate, selection: "automatic" };
+			if (!communication) this.#requireUnlocked(chatId, target, signal);
+			if (!target) {
+				await this.#waitForChange(signal);
+				continue;
 			}
-			await this.#waitForChange(signal);
+			await this.#waitForSession(target, signal);
+			signal.throwIfAborted();
+			if (!communication) this.#requireUnlocked(chatId, target, signal);
+			const current = this.#state.binding(chatId);
+			const initialize =
+				bindRequested ||
+				!current ||
+				(current === target && this.#sync && !this.#state.code(target));
+			const initialization =
+				initialize && !this.synchronizing(chatId, target)
+					? await this.#join(chatId, target, requestId, signal, bindRequested)
+					: undefined;
+			return {
+				sessionId: target,
+				selection: requestedId
+					? "explicit"
+					: boundId
+						? "existing"
+						: "automatic",
+				...(initialization ? { initialization } : {}),
+			};
 		}
 	}
 
@@ -506,28 +773,99 @@ export class Broker {
 		chatId: string,
 		sessionId: string,
 		requestId: unknown,
+		signal: AbortSignal,
 		explicit = false,
-	): Promise<void> {
+	): Promise<Initialization> {
+		this.#requireUnlocked(chatId, sessionId, signal);
+		const operation = this.#operations.get(signal);
+		if (operation) this.#observe(operation, sessionId);
 		const previous = this.#state.binding(chatId);
-		const workflow = workflowId(requestId);
-		const joined = await this.#state.join(chatId, sessionId, workflow);
+		const code = this.#sync ? randomBytes(6).toString("hex") : undefined;
+		await this.#state.bind(chatId, sessionId);
+		this.#requireUnlocked(chatId, sessionId, signal);
+		if (code) {
+			if (!operation)
+				throw new Error(
+					"Initialization is outside a tracked Chappie operation",
+				);
+			operation.initialization = {
+				sessionId,
+				code,
+				previousCode: undefined,
+				committed: false,
+			};
+		}
+		const activity = source(chatId, requestId);
 		if (previous !== sessionId) {
 			this.#notifyChange();
 			if (previous)
-				await this.#notify(previous, `ChatGPT ${chatId.slice(-4)} left`);
+				await this.#notify(previous, `${chatLabel(activity)} left`, {
+					...activity,
+					event: "left",
+				});
 		}
-		if (joined || explicit) {
-			await this.#notify(
+		this.#requireUnlocked(chatId, sessionId, signal);
+		await this.#notify(sessionId, `${chatLabel(activity)} joined`, {
+			...activity,
+			event: "joined",
+			initialization: explicit ? "explicit" : "implicit",
+		});
+		const name = activity.requestId?.match(/\/([^/]+)$/)?.[1];
+		const instructions = name
+			? `${historyInstructions} Use this name when coordinating through chat.`
+			: historyInstructions;
+		return {
+			sessionId,
+			...(name ? { name } : {}),
+			...(code ? { code } : {}),
+			instructions: code
+				? `${instructions} Keep this code private for sync verification.`
+				: instructions,
+		};
+	}
+
+	#requireUnlocked(
+		chatId: string,
+		sessionId: string | undefined,
+		signal: AbortSignal,
+	): void {
+		signal.throwIfAborted();
+		const operation = this.#operations.get(signal);
+		if (operation) this.#observe(operation, sessionId);
+		const locked = this.synchronizing(chatId, sessionId);
+		if (locked) throw new Error(syncMessage(locked));
+	}
+
+	#observe(operation: Operation, sessionId: string | undefined): void {
+		if (!sessionId) return;
+		operation.sessionId ??= sessionId;
+		if (!operation.revisions.has(sessionId)) {
+			operation.revisions.set(
 				sessionId,
-				`ChatGPT ${chatId.slice(-4)}${workflow ? ` (${workflow.slice(-4)})` : ""} joined`,
+				this.#syncRevisions.get(sessionId) ?? 0,
 			);
 		}
+		if (this.#locks.has(sessionId)) operation.coordinating = true;
+	}
+
+	async #rollbackInitialization(operation: Operation): Promise<void> {
+		const initialization = operation.initialization;
+		if (!initialization?.committed) return;
+		initialization.committed = false;
+		await this.#state.setCode(
+			initialization.sessionId,
+			initialization.previousCode,
+		);
 	}
 
-	async #notify(sessionId: string, message: string): Promise<void> {
+	async #notify(
+		sessionId: string,
+		message: string,
+		activity: Activity = {},
+	): Promise<void> {
 		await this.#sessions
 			.get(sessionId)
-			?.peer.send({ type: "notice", sessionId, message });
+			?.peer.send({ type: "notice", sessionId, message, activity });
 	}
 
 	async #waitForSession(sessionId: string, signal: AbortSignal): Promise<void> {
@@ -547,7 +885,12 @@ export class Broker {
 		throw new Error("Pi session returned no inspection");
 	}
 
-	async #ackInputs(sessionId: string, inputs: SessionInput[]): Promise<void> {
+	async #ackInputs(
+		sessionId: string,
+		inputs: SessionInput[],
+		signal: AbortSignal,
+	): Promise<void> {
+		signal.throwIfAborted();
 		if (inputs.length === 0) return;
 		const session = this.#sessions.get(sessionId);
 		if (!session) throw new Error(`Pi session ${sessionId} is offline`);
@@ -563,6 +906,12 @@ export class Broker {
 		message: (id: number) => BrokerMessage,
 		signal: AbortSignal,
 	): Promise<SessionResult> {
+		const operation = this.#operations.get(signal);
+		if (operation) {
+			this.#observe(operation, sessionId);
+			if (!operation.communication)
+				this.#requireUnlocked(operation.chatId, sessionId, signal);
+		}
 		const session = this.#sessions.get(sessionId);
 		if (!session) throw new Error(`Pi session ${sessionId} is offline`);
 		if (signal.aborted) throw abortError(signal);
@@ -591,12 +940,10 @@ export class Broker {
 		};
 		this.#pending.set(id, pending);
 		signal.addEventListener("abort", onAbort, { once: true });
-		try {
-			await session.peer.send(message(id));
-		} catch (error) {
+		void session.peer.send(message(id)).catch((error: unknown) => {
 			this.#finishRequest(id, pending);
-			throw error;
-		}
+			pending.reject(error instanceof Error ? error : new Error(String(error)));
+		});
 		return completion.promise;
 	}
 
@@ -648,12 +995,8 @@ export class Broker {
 	}
 }
 
-function workflowId(requestId: unknown): string | undefined {
-	return typeof requestId === "string"
-		? /^wfr_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}(?=\/|$)/i
-				.exec(requestId)?.[0]
-				.toLowerCase()
-		: undefined;
+function syncMessage(sessionId: string): string {
+	return `Pi session ${sessionId} is synchronizing. Ordinary tools and initialization are locked. Verify with your own initialization code; keep it private. ${coordinationInstructions} Only the verified coordinator can release.`;
 }
 
 function abortError(signal: AbortSignal): Error {