@zetaloop/chappie 0.3.1 → 0.4.0

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 exitInstructions =
+	"Send one final chat message stating your task, entry time, and that this execution is ending; keep all codes private. Then end this ChatGPT response immediately with no further tool calls. Do not wait for unlock, poll history, reinitialize, or resume this task after release.";
+
 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,34 @@ interface ChangeWaiter {
 	onAbort(): void;
 }
 
+export interface Initialization {
+	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 +102,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 +123,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,48 +150,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 =
-			typeof requestId === "string"
-				? /^wfr_[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}(?=\/|$)/i
-						.exec(requestId)?.[0]
-						.toLowerCase()
-				: undefined;
-		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),
+			};
 		}
-		const combined = AbortSignal.any([signal, workflow.controller.signal]);
-		combined.throwIfAborted();
-		return combined;
+		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(
+				`The sync code is missing or outdated. This execution is a stale, accidental duplicate. ${exitInstructions}`,
+			);
+		}
+		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:
+					"This is the surviving execution. Keep the verified code private in this ChatGPT context. Use chat and history to identify every observed conflicting execution and require its final exit. Confirm they have ended their responses, rather than only paused ordinary tools. Verification, idle Pi status, or a quiet history page alone does not establish their exit. Release with this code only after explicit final exit statements and resolution of conflicting activity; ordinary tools remain locked until then.",
+			};
+		}
+		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. The surviving execution may continue the current task. Executions with rejected or unavailable codes remain finished.",
+		};
 	}
 
-	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) } : {}),
 			}));
 	}
 
@@ -177,24 +371,22 @@ export class Broker {
 	async initialize(
 		chatId: string,
 		sessionId: string | undefined,
+		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<InitializedSession> {
-		const previous = this.#state.binding(chatId);
-		const { sessionId: target, selection } = await this.#selectSession(
-			chatId,
-			sessionId,
-			signal,
-			true,
-		);
-		if (previous === target)
-			await this.#notify(target, `ChatGPT ${chatId.slice(-4)} joined`);
+		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,
@@ -209,22 +401,37 @@ export class Broker {
 		chatId: string,
 		sessionId: string | undefined,
 		text: string,
+		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");
 	}
@@ -233,19 +440,21 @@ export class Broker {
 		chatId: string,
 		sessionId: string | undefined,
 		names: string[] | undefined,
+		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<InspectedSession> {
-		const { sessionId: target } = await this.#selectSession(
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
+			requestId,
 			signal,
-			false,
 		);
 		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,
@@ -257,13 +466,14 @@ export class Broker {
 		chatId: string,
 		sessionId: string | undefined,
 		calls: ToolInput[],
+		requestId: unknown,
 		signal: AbortSignal,
 	): Promise<CallResult> {
-		const { sessionId: target } = await this.#selectSession(
+		const { sessionId: target, initialization } = await this.#selectSession(
 			chatId,
 			sessionId,
+			requestId,
 			signal,
-			false,
 		);
 		const toolCalls: ToolCall[] = calls.map((call) => ({
 			type: "toolCall",
@@ -276,16 +486,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,
@@ -294,15 +505,42 @@ export class Broker {
 		throw new Error("Pi session returned no tool results");
 	}
 
+	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 target = sessionId ?? this.#state.binding(chatId);
-		if (!target || !this.#sessions.has(target)) return [];
+		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;
 	}
 
@@ -310,14 +548,16 @@ export class Broker {
 		chatId: string,
 		sessionId: string | undefined,
 		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,
-			false,
 		);
+		this.#requireUnlocked(chatId, target, signal);
 		const session = this.#sessions.get(target);
 		if (!session) throw new Error(`Pi session ${target} is offline`);
 		const question: QuestionRecord = {
@@ -329,11 +569,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(
@@ -344,6 +592,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);
 		}
@@ -378,14 +627,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> {
@@ -401,7 +656,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(
@@ -430,7 +688,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;
 			}
@@ -460,56 +720,146 @@ export class Broker {
 	async #selectSession(
 		chatId: string,
 		requestedId: string | undefined,
+		requestId: unknown,
 		signal: AbortSignal,
-		bindRequested: boolean,
+		bindRequested = false,
+		communication = false,
 	): Promise<{
 		sessionId: string;
 		selection: InitializedSession["selection"];
+		initialization?: Initialization;
 	}> {
-		if (requestedId) {
-			await this.#waitForSession(requestedId, signal);
-			if (bindRequested && this.#state.binding(chatId) !== requestedId) {
-				await this.#bind(chatId, requestedId);
+		for (;;) {
+			signal.throwIfAborted();
+			const boundId = this.#state.binding(chatId);
+			let target = requestedId ?? boundId;
+			if (!target) {
+				const occupied = this.#state.bindingCounts();
+				target = [...this.#sessions.keys()].find(
+					(id) => !occupied.has(id) && !this.#locks.has(id),
+				);
 			}
-			return { sessionId: requestedId, selection: "explicit" };
+			if (!communication) this.#requireUnlocked(chatId, target, signal);
+			if (!target) {
+				await this.#waitForChange(signal);
+				continue;
+			}
+			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 } : {}),
+			};
 		}
+	}
 
-		const boundId = this.#state.binding(chatId);
-		if (boundId) {
-			await this.#waitForSession(boundId, signal);
-			return { sessionId: boundId, selection: "existing" };
+	async #join(
+		chatId: string,
+		sessionId: string,
+		requestId: unknown,
+		signal: AbortSignal,
+		explicit = false,
+	): 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 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, `${chatLabel(activity)} left`, {
+					...activity,
+					event: "left",
+				});
 		}
+		this.#requireUnlocked(chatId, sessionId, signal);
+		await this.#notify(sessionId, `${chatLabel(activity)} joined`, {
+			...activity,
+			event: "joined",
+			initialization: explicit ? "explicit" : "implicit",
+		});
+		return {
+			sessionId,
+			...(code ? { code } : {}),
+			instructions: code
+				? `${historyInstructions} Retain this initialization code in this ChatGPT context for sync verification; Pi history and chat messages contain only coordination details.`
+				: historyInstructions,
+		};
+	}
 
-		for (;;) {
-			const occupied = this.#state.bindingCounts();
-			const candidate = [...this.#sessions.keys()].find(
-				(sessionId) => !occupied.has(sessionId),
+	#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,
+				this.#syncRevisions.get(sessionId) ?? 0,
 			);
-			if (candidate) {
-				await this.#bind(chatId, candidate);
-				return { sessionId: candidate, selection: "automatic" };
-			}
-			await this.#waitForChange(signal);
 		}
+		if (this.#locks.has(sessionId)) operation.coordinating = true;
 	}
 
-	async #bind(chatId: string, sessionId: string): Promise<void> {
-		const previous = this.#state.binding(chatId);
-		await this.#state.setBinding(chatId, sessionId);
-		this.#notifyChange();
-		if (previous) {
-			await this.#notify(previous, `ChatGPT ${chatId.slice(-4)} left`);
-			if (this.#state.chats(previous).length === 0) {
-				await this.#notify(previous, "Ready for ChatGPT");
-			}
-		}
-		await this.#notify(sessionId, `ChatGPT ${chatId.slice(-4)} joined`);
+	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> {
@@ -529,7 +879,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`);
@@ -545,6 +900,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);
@@ -573,12 +934,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;
 	}
 
@@ -630,6 +989,10 @@ export class Broker {
 	}
 }
 
+function syncMessage(sessionId: string): string {
+	return `Pi session ${sessionId} is synchronizing to end duplicate executions. Ordinary tools and initialization are locked for this session and its bound ChatGPT conversations. Verify with the code returned by your own most recent initialization. With a missing or rejected code, this execution is an accidental duplicate: ${exitInstructions} The verified execution must confirm the conflicting executions' final exits before releasing the lock.`;
+}
+
 function abortError(signal: AbortSignal): Error {
 	return signal.reason instanceof Error
 		? signal.reason