@iowarp/clio-coder 0.3.6 → 0.3.7

package/src/tools/dispatch-runner.ts

@@ -3,7 +3,9 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { BusChannels } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { parseJsonObjectPayload } from "../core/json-payload.js";
 import { clioStateDir } from "../core/xdg.js";
+import type { CouncilReport, CouncilReportMember } from "../domains/agents/result-contract.js";
 import { closeAgentLedger, openAgentLedger, renderAgentLedgerBoard } from "../domains/dispatch/agent-ledger-store.js";
 import type { DetachedBatchRun } from "../domains/dispatch/batch-store.js";
 import type { AbortReason, DispatchContract, DispatchRequest } from "../domains/dispatch/contract.js";
@@ -32,6 +34,7 @@ import {
 } from "../domains/dispatch/gate-decisions.js";
 import {
 	COMPETE_STANCES,
+	COUNCIL_JUDGE_PROMPT,
 	type CompeteStance,
 	JUDGE_GATE_PROMPT,
 	REVIEWER_GATE_PROMPT,
@@ -71,7 +74,12 @@ import {
 	type DispatchRunEventRegistry,
 } from "./dispatch-run-events.js";
 import { runScoutContinuationPlan, scoutPlanAuthorityGranted, scoutTransitionDetail } from "./dispatch-scout.js";
-import type { DispatchCompeteSettings, DispatchReviewSettings, DispatchToolDeps } from "./dispatch-types.js";
+import type {
+	DispatchCompeteSettings,
+	DispatchCouncilSettings,
+	DispatchReviewSettings,
+	DispatchToolDeps,
+} from "./dispatch-types.js";
 import type { ToolInvokeOptions, ToolResult, ToolResultDetails } from "./registry.js";
 import { truncateUtf8 } from "./truncate-utf8.js";
 import {
@@ -487,7 +495,10 @@ function formatDispatchOutput(
 			// Evidence confidence comes from the sealed receipt. A receipt that fails
 			// integrity cannot be read as evidence at all.
 			const verification = run.integrity.ok ? receipt.verification : UNVERIFIABLE_RECEIPT_VERIFICATION;
-			const trustStatus = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity: run.integrity });
+			const trustStatus = adaptRunReceiptTrustStatus(
+				{ ...receipt, verification: verification },
+				{ integrity: run.integrity },
+			);
 			const evidenceSuffix = ` ${receiptEvidenceLabels(receipt, verification, run.integrity).join(" ")}`;
 			const routingSuffix =
 				run.integrity.ok && receipt.routeDecision !== undefined && receipt.routingIntent !== undefined
@@ -566,6 +577,7 @@ function dispatchDetails(
 				// sealed receipt read-only, plus the integrity check so a tampered
 				// receipt is machine-visible here too.
 				verification: integrity.ok ? receipt.verification : UNVERIFIABLE_RECEIPT_VERIFICATION,
+				hostVerification: integrity.ok ? (receipt.hostVerification ?? null) : null,
 				receiptIntegrity: integrity,
 				trustStatus,
 				...(receipt.outcome !== undefined && receipt.outcome !== "succeeded"
@@ -1782,6 +1794,230 @@ function competeResult(
 	};
 }
 
+const COUNCIL_BRIEFING_MAX_BYTES = 8 * 1024;
+const COUNCIL_BRIEFING_TRUNCATION = "\n[council peer briefing truncated]";
+
+function councilVerdict(text: string): string | undefined {
+	const parsed = parseJsonObjectPayload(text);
+	return parsed.ok && typeof parsed.value.verdict === "string" && parsed.value.verdict.trim().length > 0
+		? parsed.value.verdict.trim()
+		: undefined;
+}
+
+function councilJudgeText(text: string): string {
+	const parsed = parseJsonObjectPayload(text);
+	return parsed.ok && typeof parsed.value.text === "string" && parsed.value.text.trim().length > 0
+		? parsed.value.text.trim()
+		: text;
+}
+
+function boundedCouncilBriefing(parts: ReadonlyArray<string>): string {
+	return truncateUtf8(parts.join("\n\n"), COUNCIL_BRIEFING_MAX_BYTES, COUNCIL_BRIEFING_TRUNCATION);
+}
+
+async function runCouncil(
+	deps: RegisteredDispatchToolDeps,
+	base: DispatchRequest,
+	council: DispatchCouncilSettings,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+): Promise<{ report: CouncilReport; runs: CompletedRun[]; group: string }> {
+	const group = newGateGroupId("council");
+	const runs: CompletedRun[] = [];
+	let prior = new Map<string, CompletedRun>();
+	const runMember = async (request: DispatchRequest): Promise<CompletedRun> => {
+		if (signal?.aborted) throw new Error("council dispatch aborted");
+		const handle = await deps.dispatch.dispatch(request);
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		if (timeoutMs !== undefined) {
+			timer = setTimeout(
+				() => deps.dispatch.abort(handle.runId, { cause: "timeout", detail: `timed out after ${timeoutMs}ms` }),
+				timeoutMs,
+			);
+		}
+		const abort = (): void => deps.dispatch.abort(handle.runId);
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			const [summary, receipt] = await Promise.all([
+				consumeGateSensitiveDispatchEvents(deps, handle.runId, request.agentId, handle.events),
+				handle.finalPromise,
+			]);
+			return completeRun(deps, receipt, summary);
+		} finally {
+			if (timer !== undefined) clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+		}
+	};
+
+	for (let round = 1; round <= council.rounds; round += 1) {
+		const settled = await Promise.all(
+			council.members.map(async (member, index) => {
+				const peerParts: string[] = base.briefing === undefined ? [] : [`[original briefing] ${base.briefing}`];
+				if (round > 1) {
+					for (const peer of council.members) {
+						if (peer.label === member.label) continue;
+						const previous = prior.get(peer.label);
+						if (previous === undefined || isPipelineStepFailure(previous.receipt)) {
+							peerParts.push(`[${peer.label}] failed in prior round; no answer contributed.`);
+						} else {
+							peerParts.push(`[${peer.label}] ${normalizedAssistantText(previous.summary)}`);
+						}
+					}
+				}
+				const position = (round - 1) * council.members.length + index + 1;
+				const pinned = council.resolvedTasks?.find((task) => task.role === "member" && task.position === position);
+				const request: DispatchRequest = {
+					...base,
+					executionRole: "researcher",
+					autonomy: "read-only",
+					toolProfile: "council-read-only",
+					target: member.target,
+					...(member.model ? { model: member.model } : {}),
+					...(member.thinking ? { thinkingLevel: member.thinking as NonNullable<DispatchRequest["thinkingLevel"]> } : {}),
+					gate: {
+						role: "member",
+						group,
+						cycle: round,
+						...(round > 1
+							? {
+									subjects: [...prior.entries()]
+										.filter(([label]) => label !== member.label)
+										.map(([, run]) => subjectRef(run.receipt)),
+								}
+							: {}),
+					},
+					council: { group, label: member.label, ...(member.color ? { color: member.color } : {}), round },
+					...(round > 1
+						? { briefing: boundedCouncilBriefing(peerParts) }
+						: base.briefing !== undefined
+							? { briefing: base.briefing }
+							: {}),
+				};
+				return [
+					member.label,
+					await runMember(withResolvedPlanTaskPin(request, pinned, { pinTask: false, pinBriefing: false })),
+				] as const;
+			}),
+		);
+		prior = new Map(settled);
+		runs.push(...settled.map(([, run]) => run));
+	}
+
+	const members: CouncilReportMember[] = runs.map((run) => {
+		const text = normalizedAssistantText(run.summary);
+		const failed = isPipelineStepFailure(run.receipt);
+		const verdict = councilVerdict(text);
+		return {
+			label: run.receipt.council?.label ?? "member",
+			runId: run.receipt.runId,
+			round: run.receipt.council?.round ?? 1,
+			answer: text,
+			...(verdict !== undefined ? { verdict } : {}),
+			...(failed ? { failed: { reason: pipelineFailureReason(run.receipt) } } : {}),
+		};
+	});
+	const finalMembers = members.filter((member) => member.round === council.rounds && member.failed === undefined);
+	const finalReports = members.filter((member) => member.round === council.rounds);
+	let synthesis: CouncilReport["synthesis"] = { kind: council.synthesis };
+	if (council.synthesis === "vote") {
+		const tally: Record<string, number> = {};
+		for (const member of finalMembers)
+			if (member.verdict !== undefined) tally[member.verdict] = (tally[member.verdict] ?? 0) + 1;
+		const ranked = Object.entries(tally).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+		const winner = ranked[0];
+		const verdict =
+			winner === undefined ? "no_verdict_field" : winner[1] > finalMembers.length / 2 ? winner[0] : "no_majority";
+		synthesis = { kind: "vote", verdict, tally };
+	} else if (council.synthesis === "judge") {
+		const finalRuns = [...prior.values()];
+		const judgeRequest: DispatchRequest = {
+			agentId: council.judge?.agent ?? base.agentId,
+			executionRole: "judge",
+			task: `Synthesize the council answers for this task:\n\n${base.task}`,
+			briefing: boundedCouncilBriefing(
+				finalReports.map((member) =>
+					member.failed === undefined
+						? `[${member.label}] ${member.answer}`
+						: `[${member.label}] failed; no final answer contributed. Reason: ${member.failed.reason}`,
+				),
+			),
+			systemPrompt: COUNCIL_JUDGE_PROMPT,
+			autonomy: "read-only",
+			toolProfile: "council-read-only",
+			gate: { role: "synthesis", group, cycle: council.rounds, subjects: finalRuns.map((run) => subjectRef(run.receipt)) },
+			council: { group, label: "synthesis", round: council.rounds },
+			...(council.judge?.target ? { target: council.judge.target } : {}),
+			...(council.judge?.model ? { model: council.judge.model } : {}),
+			...(council.judge?.node ? { node: council.judge.node } : {}),
+			...(base.plan ? { plan: base.plan } : {}),
+			...(base.parentToolCallId ? { parentToolCallId: base.parentToolCallId } : {}),
+		};
+		const pinned = council.resolvedTasks?.find((task) => task.role === "synthesis");
+		const judgeRun = await runMember(
+			withResolvedPlanTaskPin(judgeRequest, pinned, { pinTask: false, pinBriefing: false }),
+		);
+		runs.push(judgeRun);
+		const rawText = normalizedAssistantText(judgeRun.summary);
+		const text = councilJudgeText(rawText);
+		const verdict = councilVerdict(rawText);
+		synthesis = {
+			kind: "judge",
+			text,
+			...(verdict !== undefined ? { verdict } : {}),
+			judgeRunId: judgeRun.receipt.runId,
+		};
+	}
+	if (council.synthesis !== "judge" && prior.size > 0 && deps.dispatch.sealCouncilSynthesis !== undefined) {
+		const finalRuns = [...prior.values()];
+		const template = finalRuns[0];
+		if (template === undefined) throw new Error("council synthesis has no final member receipt");
+		// The sealed text is the whole council-report, not the synthesis alone:
+		// /share <synthesis runId> reads this receipt to bring every final
+		// member's labelled answer and the synthesis line into the main context.
+		const text = JSON.stringify({ members, synthesis } satisfies CouncilReport);
+		const receipt = await deps.dispatch.sealCouncilSynthesis({
+			group,
+			round: council.rounds,
+			kind: council.synthesis,
+			text,
+			subjects: finalRuns.map((run) => subjectRef(run.receipt)),
+			template: template.receipt,
+		});
+		runs.push(
+			completeRun(deps, receipt, {
+				count: 0,
+				types: [],
+				lastAssistantText: text,
+				terminalAttemptRunId: receipt.runId,
+			}),
+		);
+	}
+	return { report: { members, synthesis }, runs, group };
+}
+
+function councilResult(deps: DispatchToolDeps, outcome: Awaited<ReturnType<typeof runCouncil>>): ToolResult {
+	const sections = outcome.report.members
+		.filter((member) => member.round === Math.max(...outcome.report.members.map((entry) => entry.round)))
+		.map((member) => {
+			const run = outcome.runs.find((entry) => entry.receipt.runId === member.runId);
+			return `[${member.label}] ${run?.receipt.targetId ?? "unknown"}/${run?.receipt.wireModelId ?? "unknown"}\n${member.answer}`;
+		});
+	sections.push(
+		`[synthesis] ${outcome.report.synthesis.kind}\n${outcome.report.synthesis.text ?? outcome.report.synthesis.verdict ?? "none"}`,
+	);
+	const details: ToolResultDetails = {
+		...dispatchDetails(deps, "council", outcome.runs),
+		council: { group: outcome.group, ...outcome.report },
+	};
+	const finalRound = Math.max(...outcome.report.members.map((member) => member.round));
+	const failed =
+		outcome.report.members.some((member) => member.round === finalRound && member.failed !== undefined) ||
+		outcome.runs.some((run) => run.receipt.gate?.role === "synthesis" && isPipelineStepFailure(run.receipt));
+	return failed
+		? { kind: "error", message: sections.join("\n\n"), details }
+		: { kind: "ok", output: sections.join("\n\n"), details };
+}
+
 export async function runDispatchTool(
 	inputDeps: DispatchToolDeps,
 	admissionState: DispatchAdmissionState,
@@ -1856,6 +2092,7 @@ export async function runDispatchTool(
 	const maxOutputBytes = snapshot.maxOutputBytes;
 	const timeoutMs = snapshot.timeoutMs;
 	let review = snapshot.review === undefined ? undefined : structuredClone(snapshot.review);
+	let council = snapshot.council === undefined ? undefined : structuredClone(snapshot.council);
 
 	// Plan-scale calls are either approved at supervised admission or run
 	// unstopped at full-auto; every run seals the same plan hash.
@@ -1888,7 +2125,8 @@ export async function runDispatchTool(
 		};
 	}
 	if (resolvedPlan !== null) {
-		const primaryRole = review !== undefined ? "builder" : mode === "compete" ? "candidate" : "task";
+		const primaryRole =
+			review !== undefined ? "builder" : mode === "compete" ? "candidate" : mode === "council" ? "member" : "task";
 		const primaryTasks = resolvedPlan.tasks.filter((task) => task.role === primaryRole);
 		const executionTasks = primaryRole === "task" ? primaryTasks : primaryTasks.slice(0, 1);
 		if (executionTasks.length !== requests.length) {
@@ -1924,6 +2162,7 @@ export async function runDispatchTool(
 				resolvedTasks: resolvedPlan.tasks,
 			};
 		}
+		if (council !== undefined) council = { ...council, resolvedTasks: resolvedPlan.tasks };
 	}
 	if (planView.planScale) {
 		const plan: RunPlanProvenance = {
@@ -1955,15 +2194,17 @@ export async function runDispatchTool(
 			? "a Scout dependency plan drives its stages from this turn"
 			: mode === "compete"
 				? "compete holds its judge gate in this turn"
-				: review !== undefined
-					? "a review gate holds its cycle state in this turn"
-					: mode === "pipeline" && requests.length > 1
-						? "a pipeline threads each step's output through this turn"
-						: timeoutMs !== undefined
-							? `this call set timeout_ms=${timeoutMs} and nobody would be left to enforce the deadline`
-							: deps.dispatch.detached === undefined
-								? "detached batch records are unavailable in this context"
-								: null;
+				: mode === "council"
+					? "council holds its rounds and synthesis in this turn"
+					: review !== undefined
+						? "a review gate holds its cycle state in this turn"
+						: mode === "pipeline" && requests.length > 1
+							? "a pipeline threads each step's output through this turn"
+							: timeoutMs !== undefined
+								? `this call set timeout_ms=${timeoutMs} and nobody would be left to enforce the deadline`
+								: deps.dispatch.detached === undefined
+									? "detached batch records are unavailable in this context"
+									: null;
 	const background = createBackgroundSwitch();
 	// Review and Scout both execute under mode=parallel, so the operator-facing
 	// label names the topology they actually asked for.
@@ -1994,6 +2235,7 @@ export async function runDispatchTool(
 				topology: executionPlan.topology,
 				rootTask: executionPlan.rootTask,
 				maxWorkers: executionPlan.maxWorkers,
+				...(executionPlan.writers === 1 ? { writers: 1 as const } : {}),
 				onFailure: executionPlan.onFailure,
 				steps: requireAgentSteps(executionPlan.steps).map((step) => ({
 					...step,
@@ -2085,6 +2327,17 @@ export async function runDispatchTool(
 			}
 		}
 
+		if (mode === "council") {
+			if (requests.length !== 1 || requests[0] === undefined || council === undefined) {
+				return { kind: "error", message: "dispatch: trusted council settings are unavailable" };
+			}
+			try {
+				return councilResult(deps, await runCouncil(deps, requests[0], council, timeoutMs, options?.signal));
+			} catch (err) {
+				return { kind: "error", message: dispatchErrorMessage(err) };
+			}
+		}
+
 		if (review !== undefined) {
 			if (requests.length !== 1 || requests[0] === undefined) {
 				return { kind: "error", message: REVIEW_SINGLE_TASK_MESSAGE };
@@ -2111,7 +2364,10 @@ export async function runDispatchTool(
 				// plain sequential and no pipeline-input message is sent.
 				runs = await runSequential(deps, requests, mode, timeoutMs, options?.signal, background);
 			} else {
-				const batch = await runBatch(deps, requests, timeoutMs, options?.signal, background);
+				const batch =
+					snapshot.writers === 1
+						? await runWriterLimitedBatch(deps, requests, timeoutMs, options?.signal)
+						: await runBatch(deps, requests, timeoutMs, options?.signal, background);
 				runs = batch.runs;
 				board = batch.board;
 			}
@@ -2370,3 +2626,53 @@ async function runBatch(
 		if (!backgrounded) await closeAgentLedger(ledgerId);
 	}
 }
+
+/** Admit one checkout writer at a time while every read-only peer remains concurrent. */
+async function runWriterLimitedBatch(
+	deps: RegisteredDispatchToolDeps,
+	requests: ReadonlyArray<DispatchRequest>,
+	timeoutMs: number | undefined,
+	signal: AbortSignal | undefined,
+): Promise<BatchOutcome> {
+	const specs = new Map(deps.getAgentSpecs().map((spec) => [spec.id, spec]));
+	const readers = requests.filter((request) => specs.get(request.agentId)?.capabilityClass === "read-only");
+	const writers = requests.filter((request) => specs.get(request.agentId)?.capabilityClass !== "read-only");
+	const ledgerId = newGateGroupId("ledger");
+	await openAgentLedger(ledgerId);
+	const activeIds = new Set<string>();
+	const completed = new Map<DispatchRequest, CompletedRun>();
+	const start = async (request: DispatchRequest): Promise<CompletedRun> => {
+		const ledgered = { ...request, ledger: { id: ledgerId, sequence: 0 } };
+		const handle = await deps.dispatch.dispatch(ledgered);
+		activeIds.add(handle.runId);
+		const registered = deps.runEvents.registerSingle(handle, request.agentId, fallbackProgressBus(deps));
+		const value = await registered.completion;
+		activeIds.delete(handle.runId);
+		const run = completeRun(deps, value.receipt, value.summary);
+		completed.set(request, run);
+		return run;
+	};
+	const abort = (bySignal: boolean): void => {
+		const reason = bySignal ? undefined : ({ cause: "timeout", detail: `timed out after ${timeoutMs}ms` } as const);
+		for (const runId of activeIds) deps.dispatch.abort(runId, reason);
+	};
+	const onSignalAbort = (): void => abort(true);
+	const timer = timeoutMs === undefined ? null : setTimeout(() => abort(false), timeoutMs);
+	signal?.addEventListener("abort", onSignalAbort, { once: true });
+	try {
+		const readerPromises = readers.map((request) => start(request));
+		for (const writer of writers) await start(writer);
+		await Promise.all(readerPromises);
+		return {
+			runs: requests.flatMap((request) => {
+				const run = completed.get(request);
+				return run === undefined ? [] : [run];
+			}),
+			board: renderAgentLedgerBoard(ledgerId),
+		};
+	} finally {
+		if (timer !== null) clearTimeout(timer);
+		signal?.removeEventListener("abort", onSignalAbort);
+		await closeAgentLedger(ledgerId);
+	}
+}

package/src/tools/dispatch-types.ts

@@ -8,7 +8,23 @@ import type { DispatchBackgroundRegistry } from "./dispatch-background.js";
 import type { DispatchPlanView, ResolvedDispatchPlanArtifact } from "./dispatch-plan.js";
 import type { DispatchRunEventRegistry } from "./dispatch-run-events.js";
 
-export type DispatchMode = "parallel" | "sequential" | "pipeline" | "compete";
+export type DispatchMode = "parallel" | "sequential" | "pipeline" | "compete" | "council";
+
+export interface DispatchCouncilMember {
+	label: string;
+	target: string;
+	model?: string;
+	thinking?: string;
+	color?: string;
+}
+
+export interface DispatchCouncilSettings {
+	members: DispatchCouncilMember[];
+	synthesis: "none" | "judge" | "vote";
+	rounds: number;
+	judge?: DispatchCompeteSettings["judge"];
+	resolvedTasks?: ReadonlyArray<ResolvedDispatchPlanArtifact["tasks"][number]>;
+}
 
 export interface DispatchReviewSettings {
 	reviewer?: string;
@@ -33,8 +49,10 @@ export interface DispatchRunExecutionSnapshot {
 	readonly planView: DispatchPlanView;
 	readonly requests: ReadonlyArray<DispatchRequest>;
 	readonly mode: DispatchMode;
+	readonly writers: 1 | undefined;
 	readonly review: DispatchReviewSettings | undefined;
 	readonly compete: DispatchCompeteSettings | undefined;
+	readonly council: DispatchCouncilSettings | undefined;
 	readonly detach: boolean;
 	readonly timeoutMs: number | undefined;
 	readonly maxOutputBytes: number;
@@ -74,4 +92,5 @@ export interface DispatchToolDeps {
 	getAgentRoleFacts?: AgentRoleFactsResolver;
 	getAutonomy?: () => AutonomyLevel;
 	getCostCeilingUsd?: () => number;
+	getWorkerRosters?: () => Readonly<Record<string, { members: ReadonlyArray<DispatchCouncilMember> }>>;
 }

package/src/tools/dispatch.ts

@@ -25,6 +25,16 @@ export type { DispatchToolDeps } from "./dispatch-types.js";
 
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
+const CouncilMemberSchema = Type.Object(
+	{
+		label: Type.String({ pattern: "^[a-z][a-z0-9_-]{0,31}$" }),
+		target: Type.String(),
+		model: Type.Optional(Type.String()),
+		thinking: Type.Optional(StringEnum(THINKING_LEVELS)),
+	},
+	{ additionalProperties: false },
+);
+
 const DispatchBudgetPhaseSchema = Type.Object(
 	{
 		toolCalls: Type.Integer({ minimum: 1 }),
@@ -46,6 +56,34 @@ const DispatchBudgetSchema = Type.Object(
 	},
 );
 
+const DispatchVerificationSchema = Type.Array(
+	Type.Object(
+		{
+			check: Type.String({ description: "Declared verification check id. This is not a shell command." }),
+			timeout_ms: Type.Optional(
+				Type.Integer({ minimum: 1, description: "Requested timeout within the declared check bounds." }),
+			),
+		},
+		{ additionalProperties: false },
+	),
+	{ maxItems: 8 },
+);
+
+const DispatchIntentSchema = Type.Object(
+	{
+		read_roots: Type.Optional(Type.Array(Type.String(), { maxItems: 32 })),
+		write_roots: Type.Optional(Type.Array(Type.String(), { maxItems: 32 })),
+		relevant_paths: Type.Optional(Type.Array(Type.String(), { maxItems: 32 })),
+		expected_outputs: Type.Optional(Type.Array(Type.String(), { maxItems: 32 })),
+		verification: Type.Optional(DispatchVerificationSchema),
+	},
+	{
+		additionalProperties: false,
+		description:
+			"Typed repository-relative path and output intent. Verification checks are declared ids from package scripts or .clio-coder/verifiers.yaml, not shell commands.",
+	},
+);
+
 /**
  * Stable, lightweight dispatch surface. Admission remains synchronous so the
  * policy decision and provisional reservation are bound to the exact argument
@@ -131,17 +169,42 @@ export function createDispatchTool(
 							model: Type.Optional(Type.String()),
 							node: Type.Optional(Type.String({ description: "Fleet node pin: local or a fleet.nodes id." })),
 							cwd: Type.Optional(Type.String()),
+							worktree: Type.Optional(Type.Literal(true, { description: "Run this writer in an isolated git worktree." })),
+							apply: Type.Optional(
+								StringEnum(["merge", "preserve"], { description: "Merge successful work by default, or preserve its branch." }),
+							),
+							intent: Type.Optional(DispatchIntentSchema),
+							gate: Type.Optional(
+								Type.String({
+									description: "Shorthand for one intent.verification declared check id. This is not a shell command.",
+								}),
+							),
 						}),
 					]),
 					{ description: "Tasks to dispatch; a single object or string is accepted and wrapped." },
 				),
 			),
 			mode: Type.Optional(
-				StringEnum(["parallel", "sequential", "pipeline", "compete"], {
+				StringEnum(["parallel", "sequential", "pipeline", "compete", "council"], {
 					description:
 						"Run tasks concurrently (default), one at a time, as a pipeline where each task receives the previous task's output as input data, or as a compete where N candidates build the same single task in scratch worktrees and a judge picks the winner.",
 				}),
 			),
+			roster: Type.Optional(Type.String({ description: "Configured workers.rosters name for council mode." })),
+			members: Type.Optional(Type.Array(CouncilMemberSchema, { minItems: 2, maxItems: 5 })),
+			synthesis: Type.Optional(StringEnum(["none", "judge", "vote"] as const)),
+			rounds: Type.Optional(Type.Integer({ minimum: 1, maximum: 3 })),
+			writers: Type.Optional(
+				Type.Literal(1, {
+					description: "Serialize writer admission in declared task order while readers continue concurrently.",
+				}),
+			),
+			worktree: Type.Optional(
+				Type.Literal(true, { description: "Run a singular writer task in an isolated git worktree." }),
+			),
+			apply: Type.Optional(
+				StringEnum(["merge", "preserve"], { description: "Merge successful work by default, or preserve its branch." }),
+			),
 			detach: Type.Optional(
 				Type.Boolean({
 					description:
@@ -200,7 +263,8 @@ export function createDispatchTool(
 			),
 			agent: Type.Optional(
 				Type.String({
-					description: "Default agent recipe for string tasks, or auto for bounded agent selection (default coder).",
+					description:
+						"Default agent recipe for string tasks, or auto for bounded agent selection (default coder; researcher for mode council).",
 				}),
 			),
 			briefing: Type.Optional(
@@ -208,6 +272,12 @@ export function createDispatchTool(
 					description: `Separate bounded parent context/data for task, or the shared default for tasks; never worker instructions and never a task replacement. Max ${DISPATCH_BRIEFING_MAX_BYTES} UTF-8 bytes.`,
 				}),
 			),
+			intent: Type.Optional(DispatchIntentSchema),
+			gate: Type.Optional(
+				Type.String({
+					description: "Shorthand for one intent.verification declared check id. This is not a shell command.",
+				}),
+			),
 			persona: Type.Optional(
 				Type.String({ description: "Default ad-hoc specialist persona for dispatched tasks, max 8000 chars." }),
 			),

package/src/tools/monitor.ts

@@ -123,6 +123,11 @@ function runStatus(deps: MonitorToolDeps, runId: string): ToolResult {
 		`started=${run.startedAt} ended=${run.endedAt ?? "n/a"} exit=${run.exitCode ?? "n/a"}`,
 		`tokens=${run.tokenCount} cost=${formatCostAggregate(costAggregateForAmount(run.costUsd, run.costProvenance)) ?? COST_NOT_MEASURED} receipt=${run.receiptPath ?? "n/a"}`,
 	];
+	if (run.council !== undefined || run.gate?.role === "synthesis") {
+		lines.push(
+			`council: role=${run.gate?.role === "synthesis" ? "synthesis" : "member"} group=${run.council?.group ?? run.gate?.group ?? "unknown"}${run.council?.label ? ` label=${run.council.label}` : ""}`,
+		);
+	}
 	if (run.budget !== undefined) {
 		lines.push(
 			`recipe policy: ${formatBudgetPolicy(run.budget)}`,
@@ -158,6 +163,15 @@ function runStatus(deps: MonitorToolDeps, runId: string): ToolResult {
 			costUsd: run.costUsd,
 			costProvenance: run.costProvenance ?? "unknown",
 			budget: run.budget ?? null,
+			...(run.council !== undefined || run.gate?.role === "synthesis"
+				? {
+						council: {
+							role: run.gate?.role === "synthesis" ? "synthesis" : "member",
+							group: run.council?.group ?? run.gate?.group ?? null,
+							...(run.council !== undefined ? { label: run.council.label, round: run.council.round } : {}),
+						},
+					}
+				: {}),
 			receiptPath: run.receiptPath,
 			running: live !== null,
 		},
@@ -378,6 +392,7 @@ function runReceipt(deps: MonitorToolDeps, runId: string): ToolResult {
 			...(receipt !== null && receiptIntegrity.ok
 				? {
 						evidenceVerification: receipt.verification,
+						hostVerification: receipt.hostVerification ?? null,
 						briefing: receipt.briefing ?? null,
 						projectContext: receipt.projectContext ?? null,
 					}
@@ -717,6 +732,7 @@ async function runCollect(
 					receiptIntegrity: row.evidence.integrity,
 					trustStatus: row.evidence.trustStatus,
 					evidenceVerification: row.evidence.verification,
+					hostVerification: row.evidence.receipt?.hostVerification ?? null,
 					briefing: row.evidence.receipt?.briefing ?? null,
 					projectContext: row.evidence.receipt?.projectContext ?? null,
 					...(output ? { output: { state: output.state, bytes: output.bytes, truncated: output.truncated } } : {}),

package/src/tools/profiles.ts

@@ -1,8 +1,13 @@
 import { type BuiltinToolName, isBuiltinToolName, type ToolName, ToolNames } from "../core/tool-names.js";
 
-export type ToolProfileName = "minimal-local" | "science-local" | "full-agent";
+export type ToolProfileName = "minimal-local" | "science-local" | "full-agent" | "council-read-only";
 
-export const TOOL_PROFILE_NAMES: ReadonlyArray<ToolProfileName> = ["minimal-local", "science-local", "full-agent"];
+export const TOOL_PROFILE_NAMES: ReadonlyArray<Exclude<ToolProfileName, "council-read-only">> = [
+	"minimal-local",
+	"science-local",
+	"full-agent",
+];
+const ALL_TOOL_PROFILE_NAMES: ReadonlyArray<ToolProfileName> = [...TOOL_PROFILE_NAMES, "council-read-only"];
 const CODEWIKI_TOOL_NAMES: ReadonlyArray<BuiltinToolName> = [ToolNames.CodeNav];
 
 export interface ToolProfileContext {
@@ -24,14 +29,23 @@ const MINIMAL_LOCAL_TOOLS: ReadonlyArray<BuiltinToolName> = [
 ];
 
 const SCIENCE_LOCAL_TOOLS: ReadonlyArray<BuiltinToolName> = [...MINIMAL_LOCAL_TOOLS, ToolNames.Verify];
+const COUNCIL_READ_ONLY_TOOLS: ReadonlyArray<BuiltinToolName> = [
+	ToolNames.Read,
+	ToolNames.Grep,
+	ToolNames.Find,
+	ToolNames.Ls,
+	ToolNames.CodeNav,
+	ToolNames.Context,
+];
 
 const NARROW_TOOL_PROFILES: Readonly<Record<Exclude<ToolProfileName, "full-agent">, ReadonlySet<BuiltinToolName>>> = {
 	"minimal-local": new Set(MINIMAL_LOCAL_TOOLS),
 	"science-local": new Set(SCIENCE_LOCAL_TOOLS),
+	"council-read-only": new Set(COUNCIL_READ_ONLY_TOOLS),
 };
 
 export function isToolProfileName(value: string): value is ToolProfileName {
-	return (TOOL_PROFILE_NAMES as ReadonlyArray<string>).includes(value);
+	return (ALL_TOOL_PROFILE_NAMES as ReadonlyArray<string>).includes(value);
 }
 
 /**
@@ -72,7 +86,7 @@ export function applyToolProfile(
 		const allowed = NARROW_TOOL_PROFILES[profile];
 		profiled = unique.filter((tool): tool is BuiltinToolName => isBuiltinToolName(tool) && allowed.has(tool));
 	}
-	return applyCodewikiWorkerPolicy(profiled, context);
+	return profile === "council-read-only" ? profiled : applyCodewikiWorkerPolicy(profiled, context);
 }
 
 function uniquePreservingOrder(tools: ReadonlyArray<ToolName>): ToolName[] {