@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/tools/bootstrap.ts

@@ -3,13 +3,16 @@ import type { SafeEventBus } from "../core/event-bus.js";
 import type { AgentSpec } from "../domains/agents/spec.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import type { AgentRoleFactsResolver } from "../domains/dispatch/execution-role.js";
+import type { PanesOperations } from "../domains/mux/operations.js";
 import type { AutonomyLevel } from "../domains/safety/autonomy.js";
 import { builtin, toolPromptHintsForNames } from "./builtin-tool-catalog.js";
+import type { CompeteMuxWorktrees } from "./compete-worktrees.js";
 import { assertRegisteredBuiltinTools, type CoreToolBootstrapDeps, registerCoreTools } from "./core-bootstrap.js";
 import { createDispatchRunEventRegistry, createDispatchTool } from "./dispatch.js";
 import type { DispatchBackgroundRegistry } from "./dispatch-background.js";
 import { lazyTool } from "./lazy-tool.js";
 import { monitorToolSurface } from "./monitor-surface.js";
+import { panesToolSurface } from "./panes-surface.js";
 import type { ToolRegistry } from "./registry.js";
 import { steerToolSurface } from "./steer-surface.js";
 
@@ -25,6 +28,13 @@ export interface ToolBootstrapDeps extends CoreToolBootstrapDeps {
 	getCostCeilingUsd?: () => number;
 	getWorkerRosters?: () => WorkerRosters;
 	dispatchBackground?: DispatchBackgroundRegistry;
+	/** Optional herdr worktree lifecycle for compete candidates. */
+	competeMuxWorktrees?: CompeteMuxWorktrees;
+	/**
+	 * Pane operations. Present only when a pane host answered detection, which
+	 * is what keeps the `panes` tool out of the prompt on a machine with none.
+	 */
+	panes?: PanesOperations;
 }
 
 /**
@@ -36,7 +46,11 @@ export function registerAllTools(registry: ToolRegistry, deps: ToolBootstrapDeps
 	const registration = registerCoreTools(registry, deps);
 	if (deps.dispatch) {
 		const dispatch = deps.dispatch;
-		const dispatchRunEvents = createDispatchRunEventRegistry();
+		// Display tail only. In a composed process the dispatch domain writes the
+		// durable journal off its own progress channel, which covers every run
+		// rather than only the ones the model dispatched through this tool, so a
+		// second sink here would transcribe a tool-path run twice.
+		const dispatchRunEvents = createDispatchRunEventRegistry({ journal: null });
 		const dispatchToolDeps = {
 			dispatch,
 			runEvents: dispatchRunEvents,
@@ -48,6 +62,7 @@ export function registerAllTools(registry: ToolRegistry, deps: ToolBootstrapDeps
 			...(deps.getCostCeilingUsd ? { getCostCeilingUsd: deps.getCostCeilingUsd } : {}),
 			...(deps.getWorkerRosters ? { getWorkerRosters: deps.getWorkerRosters } : {}),
 			...(deps.dispatchBackground ? { background: deps.dispatchBackground } : {}),
+			...(deps.competeMuxWorktrees ? { competeWorktrees: { mux: deps.competeMuxWorktrees } } : {}),
 		};
 		registry.register({
 			...builtin(createDispatchTool(dispatchToolDeps), {
@@ -76,5 +91,14 @@ export function registerAllTools(registry: ToolRegistry, deps: ToolBootstrapDeps
 			),
 		});
 	}
-	assertRegisteredBuiltinTools(registry, registration, Boolean(deps.dispatch));
+	if (deps.panes) {
+		const panes = deps.panes;
+		registry.register({
+			...builtin(
+				lazyTool(panesToolSurface, async () => (await import("./panes.js")).createPanesTool({ panes })),
+				{ path: "src/tools/panes.ts", scope: "core" },
+			),
+		});
+	}
+	assertRegisteredBuiltinTools(registry, registration, Boolean(deps.dispatch), Boolean(deps.panes));
 }

package/src/tools/builtin-tool-catalog.ts

@@ -95,7 +95,7 @@ const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 		),
 		costLatency: "local_fast",
 		promptHint:
-			'Call context with scope="skills" to list installed and marketplace skills; when one matches the task, or the operator names a skill or asks how one works, suggest the operator run /skill <name> (a marketplace skill is offered for install) and never load it uninvited. When the user message carries a skill request, first load that skill via context (scope="skills", name=<skill>) before doing anything else. When an [evicted ...] marker names content you need, recall it with context(scope="recall", ref=...); re-read the file only when the marker says it changed.',
+			'Call context with scope="skills" to list installed and marketplace skills; when one matches the task, or the operator names a skill or asks how one works, suggest the operator run /skill <name> (a marketplace skill is offered for install) and never load it uninvited; a [Marketplace] reminder naming an uninstalled skill may instead be offered through ask_user with its exact options, and the harness performs any install. When the user message carries a skill request, first load that skill via context (scope="skills", name=<skill>) before doing anything else. When an [evicted ...] marker names content you need, recall it with context(scope="recall", ref=...); re-read the file only when the marker says it changed.',
 	},
 	[ToolNames.CredentialPresent]: {
 		objective: "Check whether a credential key is present without returning its value.",
@@ -213,6 +213,21 @@ const TOOL_METADATA: Readonly<Record<string, ToolMetadata>> = {
 		},
 		costLatency: "local_fast",
 	},
+	[ToolNames.Panes]: {
+		objective: "Focus, open, close, and inventory the terminal panes Clio owns beside this session.",
+		uiLabel: "Panes",
+		// show and list land on the same state twice; open starts a second pane
+		// and close is a no-op the second time, so the surface as a whole is not.
+		retrySafety: "not_retry_safe",
+		resultSizePolicy: {
+			kind: "exact",
+			maxBytes: 8_192,
+			followUpHint: 'Call panes with action="list" to re-read the pane inventory.',
+		},
+		costLatency: "local_fast",
+		promptHint:
+			'When the operator asks to see a dispatched agent ("show me the tester"), call panes with action="show" and the agent id. Utility panes are presets only; an arbitrary command is the operator\'s own /panes open.',
+	},
 	// RETRIEVE: network-class.
 	[ToolNames.WebFetch]: {
 		objective: "Fetch HTTP(S) text for explicit external research.",

package/src/tools/compete-worktrees.ts

@@ -2,7 +2,7 @@
  * Scratch git worktrees for the compete dispatch topology.
  *
  * Each candidate builds in its own worktree on its own branch
- * (`clio/compete/<group>/<n>`), created from the repository HEAD under
+ * (`clio-coder/compete/<group>/<n>`), created from the repository HEAD under
  * `<root>/.clio-coder/worktrees/<group>/candidate-<n>`. The path sits inside the
  * project root because remote fleet nodes share the filesystem and doctor
  * preflight verifies path parity only for the project root; `.clio-coder/` is
@@ -34,7 +34,7 @@ import {
 } from "node:fs";
 import { hostname } from "node:os";
 import { join, relative, resolve } from "node:path";
-import type { RunKind } from "../domains/dispatch/types.js";
+import type { RunGateWorktreeProvenance, RunKind } from "../domains/dispatch/types.js";
 import {
 	commitWorktreePath,
 	isCanonicalWorktreePathInside,
@@ -47,6 +47,24 @@ export interface CandidateWorktree {
 	index: number;
 	branch: string;
 	path: string;
+	provenance?: RunGateWorktreeProvenance;
+}
+
+/** Narrow mux surface used by compete; the native functions remain usable alone. */
+export interface CompeteMuxWorktrees {
+	available(): boolean;
+	worktreeCreate(request: {
+		cwd: string;
+		branch: string;
+		base: string;
+		path: string;
+		label: string;
+		focus: boolean;
+	}): Promise<{
+		workspaceId: string;
+		worktree: { path: string; branch: string | null };
+	} | null>;
+	worktreeRemove(workspaceId: string, options?: { force?: boolean }): Promise<boolean>;
 }
 
 export type CompeteGroupState = "active" | "cleanup-ready" | "winner-preserved";
@@ -109,8 +127,9 @@ export interface CompeteRunAdmission {
 
 const COMPETE_PARENT_SEGMENTS = [".clio-coder", "worktrees"] as const;
 const COMPETE_MANIFEST_FILE = ".clio-coder-compete-owner.json";
-const COMPETE_MANIFEST_KIND = "clio-compete-group";
-const COMPETE_COMMIT_IDENTITY = "clio-compete";
+const COMPETE_MANIFEST_KIND = "clio-coder-compete-group";
+const LEGACY_COMPETE_MANIFEST_KIND = "clio-compete-group";
+const COMPETE_COMMIT_IDENTITY = "clio-coder-compete";
 
 const SAFE_GROUP = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const PROCESS_EXIT_GRACE_MS = 750;
@@ -306,7 +325,7 @@ function isCanonicalDirectoryAt(path: string): boolean {
  * `relative()` makes the decision by path segment, so `/group-a2` can never
  * be mistaken for a child of `/group-a` as it can with textual startsWith.
  */
-export function isCanonicalPathInside(parent: string, candidate: string): boolean {
+function isCanonicalPathInside(parent: string, candidate: string): boolean {
 	return isCanonicalWorktreePathInside(parent, candidate);
 }
 
@@ -315,7 +334,7 @@ function manifestFromUnknown(value: unknown): CompeteGroupManifest | null {
 	const manifest = value as Record<string, unknown>;
 	if (
 		manifest.version !== 2 ||
-		manifest.kind !== COMPETE_MANIFEST_KIND ||
+		(manifest.kind !== COMPETE_MANIFEST_KIND && manifest.kind !== LEGACY_COMPETE_MANIFEST_KIND) ||
 		typeof manifest.root !== "string" ||
 		typeof manifest.group !== "string" ||
 		typeof manifest.token !== "string" ||
@@ -399,10 +418,14 @@ export function isGitRepository(root: string): boolean {
 	}
 }
 
-function competeBranch(group: string, index: number): string {
+function competeBranch(group: string, index: number, legacy = false): string {
 	validateGroup(group);
 	if (!Number.isInteger(index) || index < 1) throw new Error(`invalid compete candidate index ${index}`);
-	return `clio/compete/${group}/${index}`;
+	return `${legacy ? "clio" : "clio-coder"}/compete/${group}/${index}`;
+}
+
+function competeBranchMatches(branch: string, group: string, index: number): boolean {
+	return branch === competeBranch(group, index) || branch === competeBranch(group, index, true);
 }
 
 /** Claim the group before creating a branch or candidate worktree. */
@@ -531,19 +554,61 @@ export function markCompeteGroupWinnerPreserved(
  * baseline is a parameter rather than HEAD so every candidate in a compete
  * transaction starts from the same approved state.
  */
-export function createCandidateWorktree(
+function createCandidateWorktree(ownership: CompeteGroupOwnership, index: number, baseline: string): CandidateWorktree {
+	assertOwnership(ownership);
+	const branch = competeBranch(ownership.group, index);
+	const path = join(ownership.directory, `candidate-${index}`);
+	if (!isCanonicalPathInside(ownership.directory, path)) {
+		throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
+	}
+	git(ownership.root, ["worktree", "add", "-b", branch, path, baseline]);
+	return { index, branch, path };
+}
+
+/**
+ * Prefer herdr's worktree lifecycle while preserving Git as the recovery
+ * authority. A failed or vanished mux is deliberately indistinguishable from
+ * no mux to the caller except for the receipt provenance returned here.
+ */
+export async function createCandidateWorktreeMapped(
 	ownership: CompeteGroupOwnership,
 	index: number,
 	baseline: string,
-): CandidateWorktree {
+	mux?: CompeteMuxWorktrees,
+): Promise<CandidateWorktree> {
 	assertOwnership(ownership);
 	const branch = competeBranch(ownership.group, index);
 	const path = join(ownership.directory, `candidate-${index}`);
 	if (!isCanonicalPathInside(ownership.directory, path)) {
 		throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
 	}
-	git(ownership.root, ["worktree", "add", "-b", branch, path, baseline]);
-	return { index, branch, path };
+	let fallback: RunGateWorktreeProvenance["fallback"] = "mux-unavailable";
+	if (mux?.available()) {
+		const created = await mux
+			.worktreeCreate({
+				cwd: ownership.root,
+				branch,
+				base: baseline,
+				path,
+				label: `clio-coder compete ${ownership.group} candidate ${index}`,
+				focus: false,
+			})
+			.catch(() => null);
+		if (created !== null) {
+			if (resolve(created.worktree.path) !== resolve(path) || created.worktree.branch !== branch) {
+				throw new Error(`herdr created candidate ${index} at an unexpected path or branch`);
+			}
+			return {
+				index,
+				branch,
+				path,
+				provenance: { backend: "herdr", path, branch, workspaceId: created.workspaceId },
+			};
+		}
+		fallback = "mux-operation-failed";
+	}
+	const native = createCandidateWorktree(ownership, index, baseline);
+	return { ...native, provenance: { backend: "native", path, branch, fallback } };
 }
 
 /**
@@ -588,7 +653,7 @@ function exactGroupBranches(root: string, group: string): string[] {
 			const parts = branch.split("/");
 			return (
 				parts.length === 4 &&
-				parts[0] === "clio" &&
+				(parts[0] === "clio-coder" || parts[0] === "clio") &&
 				parts[1] === "compete" &&
 				parts[2] === group &&
 				/^\d+$/.test(parts[3] ?? "")
@@ -596,6 +661,16 @@ function exactGroupBranches(root: string, group: string): string[] {
 		});
 }
 
+/** Resolve a current candidate branch while retaining indefinite read support for released refs. */
+export function competeBranchForCandidate(root: string, group: string, index: number): string {
+	const branches = exactGroupBranches(root, group);
+	return (
+		branches.find((branch) => branch === competeBranch(group, index)) ??
+		branches.find((branch) => branch === competeBranch(group, index, true)) ??
+		competeBranch(group, index)
+	);
+}
+
 function removeRegisteredWorktree(root: string, path: string): void {
 	try {
 		git(root, ["worktree", "remove", "--force", path]);
@@ -605,17 +680,16 @@ function removeRegisteredWorktree(root: string, path: string): void {
 	}
 }
 
-export function removeCandidateWorktree(
+function removeCandidateWorktree(
 	ownership: CompeteGroupOwnership,
 	worktree: CandidateWorktree,
 	deleteBranch: boolean,
 ): void {
 	assertOwnership(ownership);
 	const expectedPath = join(ownership.directory, `candidate-${worktree.index}`);
-	const expectedBranch = competeBranch(ownership.group, worktree.index);
 	if (
 		resolve(worktree.path) !== resolve(expectedPath) ||
-		worktree.branch !== expectedBranch ||
+		!competeBranchMatches(worktree.branch, ownership.group, worktree.index) ||
 		!isCanonicalPathInside(ownership.directory, worktree.path)
 	) {
 		throw new Error(`candidate ${worktree.index} does not belong to compete group ${ownership.group}`);
@@ -633,6 +707,23 @@ export function removeCandidateWorktree(
 	}
 }
 
+/** Remove through herdr when it owns the workspace, then verify with Git. */
+export async function removeCandidateWorktreeMapped(
+	ownership: CompeteGroupOwnership,
+	worktree: CandidateWorktree,
+	deleteBranch: boolean,
+	mux?: CompeteMuxWorktrees,
+): Promise<void> {
+	const workspaceId = worktree.provenance?.backend === "herdr" ? worktree.provenance.workspaceId : undefined;
+	if (workspaceId && mux?.available()) {
+		await mux.worktreeRemove(workspaceId, { force: true }).catch(() => false);
+	}
+	// This is both the native fallback after mux loss and the postcondition check
+	// after a successful RPC. It prunes an already-removed path harmlessly and
+	// removes the candidate branch, which worktree.remove does not promise to do.
+	removeCandidateWorktree(ownership, worktree, deleteBranch);
+}
+
 /**
  * Merge the winning candidate branch into the current branch. Fast-forward
  * is impossible by construction (the candidate branched from HEAD and HEAD
@@ -738,8 +829,8 @@ export function settleRecoveredCompeteDecision(
 		cleanupWorktreeGroup(ownership);
 		return null;
 	}
-	const winnerBranch = competeBranch(group, winnerIndex);
 	const branches = exactGroupBranches(ownership.root, group);
+	const winnerBranch = competeBranchForCandidate(ownership.root, group, winnerIndex);
 	const winnerPath = join(ownership.directory, `candidate-${winnerIndex}`);
 	if (
 		!branches.includes(winnerBranch) ||

package/src/tools/context/index.ts

@@ -1,7 +1,13 @@
 import { type Dirent, readdirSync } from "node:fs";
 import path from "node:path";
 import type { ContextRecalledPayload } from "../../core/bus-events.js";
-import { SKILL_SUGGESTION_ANCHOR } from "../../core/skill-activation.js";
+import {
+	SKILL_INSTALL_OFFER_OPTION_NEVER,
+	SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
+	SKILL_INSTALL_OFFER_OPTION_PROJECT,
+	SKILL_INSTALL_OFFER_OPTION_USER,
+	SKILL_SUGGESTION_ANCHOR,
+} from "../../core/skill-activation.js";
 import { ToolNames } from "../../core/tool-names.js";
 import { foldWorkingSet } from "../../domains/context/working-set/fold.js";
 import {
@@ -289,6 +295,14 @@ function renderSkillsList(
 		"",
 		`If one skill above matches the current task, begin your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose), then continue the task in the same turn without it; only the operator can run it. If none match, do not mention skills.`,
 	);
+	if (marketplace.length > 0) {
+		// The offer protocol mirrors the marketplace-offer middleware: fixed
+		// option labels so the harness recognizes the answer, and the model
+		// never performs an install itself.
+		lines.push(
+			`When no installed skill serves the task but a marketplace skill above genuinely does, you may instead ask the operator with ask_user (mode=single_question, header "Install skill") whether to install it, offering exactly: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". The harness handles the answer and any install; never install or load a skill yourself.`,
+		);
+	}
 	return lines.join("\n");
 }
 

package/src/tools/core-bootstrap.ts

@@ -184,6 +184,7 @@ export function assertRegisteredBuiltinTools(
 	registry: ToolRegistry,
 	registration: CoreToolRegistration,
 	includeDispatchTools: boolean,
+	includePanesTools = false,
 ): void {
-	assertBuiltinToolPolicy(registry.listAll(), { ...registration, includeDispatchTools });
+	assertBuiltinToolPolicy(registry.listAll(), { ...registration, includeDispatchTools, includePanesTools });
 }

package/src/tools/dispatch-admission.ts

@@ -4,11 +4,13 @@ import type { ExecutionPlan } from "../domains/dispatch/execution-plan.js";
 import { gateDeciderAgentId } from "../domains/dispatch/execution-role.js";
 import {
 	COUNCIL_JUDGE_PROMPT,
+	COUNCIL_MAX_MEMBERS,
+	COUNCIL_MIN_MEMBERS,
 	JUDGE_GATE_PROMPT,
 	REVIEWER_GATE_PROMPT,
 	renderCouncilVoteMemberTask,
 } from "../domains/dispatch/gate-role-prompts.js";
-import { normalizeDispatchIntent } from "../domains/dispatch/intent.js";
+import { narrowDispatchIntentToReadOnly, normalizeDispatchIntent } from "../domains/dispatch/intent.js";
 import { renderDispatchReviewerTask } from "../domains/dispatch/intent-requirements.js";
 import { approvedRouteCandidates } from "../domains/dispatch/route-approval.js";
 import { defaultRoutingIntent } from "../domains/dispatch/routing-intent.js";
@@ -109,7 +111,9 @@ function councilSettingsFromArgs(
 			members.push({ label, target, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}) });
 		}
 	}
-	if (members.length < 2 || members.length > 5) return { ok: false, message: "council_members_out_of_range" };
+	if (members.length < COUNCIL_MIN_MEMBERS || members.length > COUNCIL_MAX_MEMBERS) {
+		return { ok: false, message: "council_members_out_of_range" };
+	}
 	const labels = new Set<string>();
 	for (const member of members) {
 		if (labels.has(member.label)) return { ok: false, message: `council_member_label_duplicate: ${member.label}` };
@@ -389,7 +393,9 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 			};
 		});
 		const reservation = deps.dispatch.reservations.prepare({
-			topology: artifact.topology === "fleet" || artifact.topology === "council" ? "parallel" : artifact.topology,
+			// A council keeps its own name so a capacity denial can say that its
+			// width has a floor. A fleet's waves are already parallel by shape.
+			topology: artifact.topology === "fleet" ? "parallel" : artifact.topology,
 			tasks,
 		});
 		try {
@@ -450,10 +456,12 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 				return shapeRejection(args, "dispatch: apply_winner must be an options object");
 			}
 			const branch = stringArg(args.apply_winner, "branch");
-			const match = branch ? /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch) : null;
+			const match = branch
+				? /^(?:clio-coder|clio)\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch)
+				: null;
 			if (branch === undefined) return shapeRejection(args, "dispatch: apply_winner.branch is required");
 			if (match === null) {
-				return shapeRejection(args, "dispatch: apply_winner.branch must be a clio/compete/<group>/<n> branch");
+				return shapeRejection(args, "dispatch: apply_winner.branch must be a clio-coder/compete/<group>/<n> branch");
 			}
 			try {
 				const cwd = resolve(stringArg(args.apply_winner, "cwd") ?? process.cwd());
@@ -638,6 +646,11 @@ export function createDispatchAdmissionController(deps: DispatchToolDeps): Dispa
 							executionRole: "researcher",
 							autonomy: "read-only",
 							toolProfile: "council-read-only",
+							// A member inherits the caller's declared scope but never its
+							// write authority: the same trees arrive as read roots, so the
+							// declaration stays enforceable against a read-only run instead of
+							// claiming a write scope nothing can grant.
+							...(base.intent === undefined ? {} : { intent: narrowDispatchIntentToReadOnly(base.intent) }),
 							// The runner reuses this composed task from the resolved plan, so
 							// the approval artifact the plan hash binds shows the operator the
 							// exact ballot the member is asked to cast.

package/src/tools/dispatch-arguments.ts

@@ -1,12 +1,16 @@
 /** Pure model-argument parsing; every returned DispatchRequest has a concrete agent id. */
 
-import { pathBoundaryCovers } from "../core/path-boundary.js";
 import type { AgentAutomationAuthority } from "../domains/agents/spec.js";
 import { type AgentTaskType, classifyAgentTask } from "../domains/dispatch/agent-candidates.js";
 import { cloneDispatchBudgetRequest } from "../domains/dispatch/budget-envelope.js";
 import type { DispatchRequest } from "../domains/dispatch/contract.js";
 import { type AgentRoleFactsResolver, requestExecutionRole } from "../domains/dispatch/execution-role.js";
 import type { DispatchIntent } from "../domains/dispatch/intent.js";
+import {
+	classifyDispatchIntentCompatibility,
+	dispatchIntentRefusals,
+	dispatchIntentScopeWidening,
+} from "../domains/dispatch/intent-compatibility.js";
 import { parseRoutingIntent } from "../domains/dispatch/routing-intent.js";
 import { DISPATCH_BRIEFING_MAX_BYTES, type JobThinkingLevel } from "../domains/dispatch/validation.js";
 import { isToolProfileName, TOOL_PROFILE_NAMES } from "./profiles.js";
@@ -58,7 +62,7 @@ const AUTO_BASELINE_FALLBACK_AGENT_ID = "scout";
  * the mapped recipe is not present in this install, so a trimmed recipe set
  * can never produce a dispatch against an agent id that does not resolve.
  */
-export function autoBaselineAgentId(task: string, hasAgent?: (id: string) => boolean): string {
+function autoBaselineAgentId(task: string, hasAgent?: (id: string) => boolean): string {
 	const mapped = AUTO_BASELINE_BY_TASK_TYPE[classifyAgentTask(task).taskType] ?? AUTO_BASELINE_FALLBACK_AGENT_ID;
 	if (hasAgent === undefined) return mapped;
 	if (hasAgent(mapped)) return mapped;
@@ -197,10 +201,17 @@ function dispatchRequestFromArgs(
 				? args.writeRoots.filter((entry): entry is string => typeof entry === "string")
 				: undefined;
 			if (legacy !== undefined) {
-				const left = [...new Set(legacy)].sort();
-				if (JSON.stringify(left) !== JSON.stringify(resolved.intent.writeRoots)) {
-					return { ok: false, message: "intent_write_roots_contradiction" };
-				}
+				// Asked through the same rule the job-spec validator asks, so the two
+				// cannot disagree about the same pair. A raw string comparison here
+				// would refuse './src/tools' against 'src/tools', which name one tree.
+				const refusal = dispatchIntentRefusals(
+					classifyDispatchIntentCompatibility({
+						intent: resolved.intent,
+						writeRoots: legacy,
+						...(cwd !== undefined ? { cwd } : {}),
+					}),
+				).find((entry) => entry.code === "intent_write_roots_contradiction");
+				if (refusal !== undefined) return { ok: false, message: refusal.message };
 				request.writeRoots = legacy;
 			} else {
 				request.writeRoots = resolved.intent.writeRoots;
@@ -273,21 +284,10 @@ export function dispatchRequestsFromArgs(
 			}
 			const ceiling = options.resolveIntent(sharedIntent, parsed.request.cwd);
 			if (!ceiling.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${ceiling.message}` };
-			const pathCeilings = {
-				readRoots: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots],
-				writeRoots: ceiling.intent.writeRoots,
-				relevantPaths: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots, ...ceiling.intent.relevantPaths],
-			};
-			for (const field of ["readRoots", "writeRoots", "relevantPaths"] as const) {
-				const outside = parsed.request.intent?.[field].find(
-					(candidate) => !pathBoundaryCovers(pathCeilings[field], candidate),
-				);
-				if (outside !== undefined) {
-					return {
-						ok: false,
-						message: `dispatch: task ${index + 1}: intent_scope_widening: ${field} entry '${outside}' is outside the top-level intent ceiling`,
-					};
-				}
+			const widening =
+				parsed.request.intent === undefined ? null : dispatchIntentScopeWidening(ceiling.intent, parsed.request.intent);
+			if (widening !== null) {
+				return { ok: false, message: `dispatch: task ${index + 1}: ${widening.message}` };
 			}
 		}
 		requests.push(parsed.request);

package/src/tools/dispatch-plan.ts

@@ -900,14 +900,3 @@ export function describeDispatchPlan(rawArgs: Record<string, unknown> | undefine
 		...(confirmation !== undefined ? { confirmation } : {}),
 	};
 }
-
-/** Registry-side predicate: does this dispatch call require plan approval at supervised levels? */
-export function isPlanScaleDispatchArgs(rawArgs: Record<string, unknown> | undefined): boolean {
-	try {
-		return describeDispatchPlan(rawArgs).planScale;
-	} catch {
-		// A malformed call fails closed as NOT plan-scale; the dispatch tool's
-		// own validation rejects it with a real error message.
-		return false;
-	}
-}