@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/tools/context/docs-engine.ts

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { basename, join, relative, resolve } from "node:path";
 import { resolvePackageRoot } from "../../core/package-root.js";
 
 // Deterministic, dependency-free retrieval over Clio's bundled human docs,
@@ -298,14 +298,27 @@ function indexSection(section: RawSection): IndexedSection {
 
 function candidateDocFiles(root: string): string[] {
 	const docsDir = join(root, "docs");
+	const htmlDir = join(docsDir, "html");
 	const files: string[] = [];
-	try {
-		for (const name of readdirSync(docsDir).sort((a, b) => a.localeCompare(b))) {
-			if (name.toLowerCase().endsWith(".md")) files.push(join("docs", name));
+	const walk = (dir: string): void => {
+		let entries: import("node:fs").Dirent[];
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
 		}
-	} catch {
-		// The caller reports a missing docs directory below if nothing can load.
-	}
+		for (const entry of entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+			const absolute = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (absolute !== htmlDir) walk(absolute);
+				continue;
+			}
+			if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+				files.push(relative(root, absolute).replaceAll("\\", "/"));
+			}
+		}
+	};
+	walk(docsDir);
 	for (const name of ["README.md", "CHANGELOG.md", "CLIO-CODER.md"]) {
 		if (existsSync(join(root, name))) files.push(name);
 	}

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 {
@@ -197,6 +203,23 @@ function pendingSkillRequestFor(name: string, options: ToolInvokeOptions | undef
 	return options?.pendingSkillPolicy?.requests.find((request) => request.name === name) ?? null;
 }
 
+/**
+ * A hidden skill is intentionally absent from model discovery, but
+ * `disable-model-invocation` still promises that the operator may activate it
+ * by hand. Slash-command and selector requests are the two authenticated
+ * interactive paths for that choice. Recipe and marketplace requests do not
+ * widen visibility: neither proves that the operator selected an installed
+ * manual-only skill for this turn.
+ */
+function operatorRequestedManualSkill(skill: Skill, request: ReturnType<typeof pendingSkillRequestFor>): boolean {
+	return (
+		skill.trusted &&
+		skill.disableModelInvocation &&
+		request?.installed === true &&
+		(request.source === "slash-command" || request.source === "selector")
+	);
+}
+
 function renderPendingSkillTask(name: string, options: ToolInvokeOptions | undefined): string[] {
 	const request = pendingSkillRequestFor(name, options);
 	if (!request) return [];
@@ -257,10 +280,11 @@ function renderSkillsList(
 		// claim none is configured; it simply has nothing to list.
 		return marketplaceOffered ? "No skills are installed and no marketplace is configured." : "No skills are installed.";
 	}
-	const lines = [
-		"Available skills. Match the current task against the descriptions below: when one fits, suggest the operator run /skill <name>; when several compose, suggest the sequence in order. Skill bodies load only after an explicit operator request; never load one without it.",
-		"",
-	];
+	// The header names the listing and nothing more. The reply protocol is
+	// stated once, as the recency anchor at the bottom, because that is the
+	// line literal models act on; a second copy up here cost every listing
+	// call the same sentences again.
+	const lines = ["Available skills.", ""];
 	if (skills.length > 0) {
 		lines.push("Installed:");
 		for (const skill of skills) {
@@ -274,10 +298,7 @@ function renderSkillsList(
 		// operator's /skill <name> prompts to install before it runs, so the
 		// model's move is the same suggest-and-wait. Only the body is out of
 		// reach until then, which is why the description is all that appears.
-		lines.push(
-			"",
-			"Marketplace (not installed; /skill <name> offers to install, or `clio-coder skills install <name>`). Suggest these the same way when one matches; their bodies cannot be loaded until the operator installs them:",
-		);
+		lines.push("", "Marketplace (not installed; /skill <name> offers to install):");
 		for (const entry of marketplace) {
 			const category = entry.category ? ` [${entry.category}]` : "";
 			lines.push(`- ${entry.name}${category}: ${entry.description}`);
@@ -289,6 +310,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");
 }
 
@@ -393,7 +422,7 @@ function runSkillsScope(
 	if (name.length === 0) {
 		const list = loadSkills({ cwd: cwdFromDeps(deps), ...(deps.getSkillLoaderOptions?.() ?? {}) });
 		const visible = modelVisibleSkills(list.items);
-		const marketplace = marketplaceRowsFor(deps, visible, options);
+		const marketplace = marketplaceRowsFor(deps, list.items, options);
 		const rendered = renderSkillsList(visible, marketplace, deps.skillMarketplace !== false);
 		// The catalog is bounded but not small: the whole listing must fit the
 		// per-call cap like any observation, and a cut list says so instead of
@@ -423,12 +452,15 @@ function runSkillsScope(
 	if (policyError) return { kind: "error", message: policyError };
 	const list = loadSkills({ cwd: cwdFromDeps(deps), ...(deps.getSkillLoaderOptions?.() ?? {}) });
 	const visible = modelVisibleSkills(list.items);
-	const skill = visible.find((item) => item.name === name);
+	const pendingRequest = pendingSkillRequestFor(name, options);
+	const skill =
+		visible.find((item) => item.name === name) ??
+		list.items.find((item) => item.name === name && operatorRequestedManualSkill(item, pendingRequest));
 	if (!skill) {
 		// A marketplace entry is a skill that exists and is not installed. Saying
 		// "unknown skill" about it denies the operator a thing the listing just
 		// offered; name the state and the one move that changes it.
-		const installable = marketplaceRowsFor(deps, visible, options).some((entry) => entry.name === name);
+		const installable = marketplaceRowsFor(deps, list.items, options).some((entry) => entry.name === name);
 		if (installable) {
 			return {
 				kind: "error",
@@ -441,7 +473,6 @@ function runSkillsScope(
 	}
 	const includeTree = args.include_tree === true;
 	const tree = includeTree ? buildResourceTree(skill.baseDir, DEFAULT_TREE_ENTRIES) : null;
-	const pendingRequest = pendingSkillRequestFor(name, options);
 	const pendingTask = pendingRequest?.args.trim() ?? "";
 	// Provenance: the activated content is compared against whatever recorded
 	// hash can speak for it, the audited catalog's pinned manifest or the

package/src/tools/core-bootstrap.ts

@@ -38,6 +38,16 @@ export interface CoreToolBootstrapDeps {
 	taskBoard?: TaskBoardStore;
 	userTasks?: UserTasksStore;
 	agentLedger?: AgentLedgerPort;
+	/**
+	 * Register the ledger tool even without a port. A worker registry needs
+	 * this: `attestedToolSignature` signs the names a bare worker registry
+	 * produces, and the orchestrator admits `ledger` for every batch member,
+	 * so a registry that dropped the tool for want of a port drifted the
+	 * signature and admission refused every batch worker. The session never
+	 * sets it: it has no peers, and the schema was 444 tokens of every first
+	 * turn for a tool that could only answer "no ledger".
+	 */
+	includeLedgerTools?: boolean;
 	getSkillLoaderOptions?: () => Pick<
 		LoadSkillsInput,
 		"trustProjectCompatRoots" | "disableDiscovery" | "explicitSkillPaths"
@@ -49,6 +59,8 @@ export interface CoreToolRegistration {
 	includeNetworkTools: boolean;
 	includeSessionTools: boolean;
 	includeInteractiveTools: boolean;
+	/** True only when a worker bound its dispatch's agent-ledger port; the session never does. */
+	includeLedgerTools: boolean;
 }
 
 export function registerCoreTools(registry: ToolRegistry, deps: CoreToolBootstrapDeps = {}): CoreToolRegistration {
@@ -154,12 +166,21 @@ export function registerCoreTools(registry: ToolRegistry, deps: CoreToolBootstra
 	registry.register({
 		...builtin(createArtifactTool({ getCwd: skillToolDeps.getCwd }), { path: "src/tools/artifact.ts", scope: "core" }),
 	});
-	registry.register({
-		...builtin(createLedgerTool(deps.agentLedger ? { agentLedger: deps.agentLedger } : {}), {
-			path: "src/tools/ledger.ts",
-			scope: "core",
-		}),
-	});
+	// The coordination board exists only inside a dispatch: a worker process
+	// binds the port, the session never does, and without a port the tool can
+	// only answer "no ledger". Registering it on the session put its schema on
+	// every first turn, so the session registers it with a port or not at all;
+	// a worker registry asks for it explicitly, port or no port, because its
+	// attested surface must not depend on whether this run bound one.
+	const includeLedgerTools = deps.includeLedgerTools === true || deps.agentLedger !== undefined;
+	if (includeLedgerTools) {
+		registry.register({
+			...builtin(createLedgerTool(deps.agentLedger ? { agentLedger: deps.agentLedger } : {}), {
+				path: "src/tools/ledger.ts",
+				scope: "core",
+			}),
+		});
+	}
 	registry.register({
 		...builtin(
 			createTasksTool({
@@ -177,6 +198,7 @@ export function registerCoreTools(registry: ToolRegistry, deps: CoreToolBootstra
 		includeNetworkTools,
 		includeSessionTools: Boolean(session),
 		includeInteractiveTools: Boolean(deps.askUser),
+		includeLedgerTools,
 	};
 }
 

package/src/tools/credential-present.ts

@@ -92,8 +92,7 @@ export const credentialPresentTool: ToolSpec = {
 		name: Type.String({ description: "Credential key name, e.g. OPENAI_API_KEY." }),
 		source: Type.Optional(
 			StringEnum(["auto", "environment", "env", "file"], {
-				description:
-					"auto checks the environment and the file when file is supplied; environment/env checks only the process environment; file checks only the file.",
+				description: "auto (default) checks the environment, then file when given; the others check one source.",
 			}),
 		),
 		file: Type.Optional(Type.String({ description: "Env-style file to check for NAME=, e.g. .env." })),

package/src/tools/dispatch-admission.ts

@@ -456,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());

package/src/tools/dispatch-arguments.ts

@@ -62,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;
@@ -186,7 +186,11 @@ function dispatchRequestFromArgs(
 	let rawIntent = args.intent;
 	if (Object.hasOwn(args, "gate")) {
 		if (typeof args.gate !== "string" || args.gate.trim().length === 0) {
-			return { ok: false, message: "gate must be a non-empty declared check id" };
+			return {
+				ok: false,
+				message:
+					"gate must be a non-empty declared check id: a check verify() lists, never a shell command; omit gate and run the check yourself after the receipt",
+			};
 		}
 		rawIntent = { ...(isRecord(rawIntent) ? rawIntent : {}), verification: [{ check: args.gate.trim() }] };
 	}

package/src/tools/dispatch-plan.ts

@@ -103,7 +103,14 @@ export interface DispatchPlanView {
 	/** True when this call requires plan approval at supervised autonomy levels. */
 	planScale: boolean;
 	tasks: DispatchPlanTaskView[];
-	/** Rendered plan artifact, deterministic for identical arguments. */
+	/**
+	 * Rendered plan artifact, deterministic for identical arguments against an
+	 * unchanged working tree. The tree is an input because a legacy task's scope
+	 * lines resolve a "../"-leading prose token by probing the dispatch root, so
+	 * creating or deleting the probed file between two renders of the same call
+	 * changes this text and the hash below. Nothing re-derives the hash to compare
+	 * it; both renders of one call happen in the same synchronous admission pass.
+	 */
 	text: string;
 	/** sha256 of the rendered artifact. */
 	hash: string;
@@ -251,12 +258,24 @@ function safeField(value: string, bindChangedValue = true): string {
 	return `${result}{sha256=${createHash("sha256").update(value, "utf8").digest("hex")}}`;
 }
 
-function renderLegacyPathScope(task: DispatchPlanTaskView): string[] {
+/**
+ * The scope lines of the approval artifact, for a task with no typed intent.
+ *
+ * `cwd` is the dispatch's own working directory, not this process's: prose
+ * inference probes a "../"-leading token against the dispatch root, so a plan
+ * rendered against `process.cwd()` would show the operator a working context
+ * the run does not resolve whenever the call carries an explicit `cwd` (a
+ * worktree, most often). Passing it makes this render and admission read the
+ * same tree, which is also the sense in which the artifact is deterministic:
+ * identical arguments against an unchanged tree, not against any tree.
+ */
+function renderLegacyPathScope(task: DispatchPlanTaskView, cwd: string | undefined): string[] {
 	if (task.intent !== undefined) return [];
 	const scope = resolveDispatchPathScope({
 		agentId: task.agent,
 		executionRole: task.executionRole,
 		task: task.task,
+		...(cwd !== undefined ? { cwd } : {}),
 		...(task.briefing !== undefined ? { briefing: task.briefing } : {}),
 	});
 	const lines = ["    scope mode=legacy-inferred"];
@@ -275,6 +294,17 @@ function renderLegacyPathScope(task: DispatchPlanTaskView): string[] {
 	if (scope.provenance.workingContextPaths.length === 0 && scope.provenance.writeBoundaries.length === 0) {
 		lines.push("    scope policy_paths=none");
 	}
+	// Named here as well as on the dispatch-time notice, because this artifact is
+	// the surface an operator approves: a token the run anchored somewhere the
+	// prose did not spell, or discarded outright, would otherwise be visible in
+	// the plan only as a scope line that has no counterpart in the task text.
+	for (const entry of scope.parentTokens) {
+		lines.push(
+			`    scope parent_token raw=${JSON.stringify(safeField(entry.token))} resolved=${
+				entry.resolved === null ? "dropped" : JSON.stringify(safeField(entry.resolved))
+			} source=${entry.source}`,
+		);
+	}
 	return lines;
 }
 
@@ -365,6 +395,7 @@ function renderPlanText(
 	source: DispatchPlanSource,
 	maxWorkers: number | null,
 	onFailure: ResolvedDispatchPlanArtifact["onFailure"],
+	cwd: string | undefined,
 	confirmation?: ResolvedDispatchPlanArtifact["confirmation"],
 ): string {
 	const lines = [
@@ -453,7 +484,7 @@ function renderPlanText(
 			const serialized = JSON.stringify(task.intent);
 			lines.push(`    intent_sha256=${createHash("sha256").update(serialized, "utf8").digest("hex")}`);
 		}
-		lines.push(...renderLegacyPathScope(task));
+		lines.push(...renderLegacyPathScope(task, cwd));
 		for (const check of task.resolvedVerification ?? []) {
 			lines.push(
 				`    verification check=${safeField(check.check)} argv=${JSON.stringify(check.argv)} cwd=${JSON.stringify(check.cwd)} timeout_ms=${check.timeoutMs}`,
@@ -887,7 +918,20 @@ export function describeDispatchPlan(rawArgs: Record<string, unknown> | undefine
 			tasks.some((task) => task.failover === "approved") ||
 			confirmation !== undefined ||
 			isRecord(args.apply_winner));
-	const text = renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, maxWorkers, onFailure, confirmation);
+	const text = renderPlanText(
+		topology,
+		tasks,
+		costCeilingUsd,
+		deadlineMs,
+		source,
+		maxWorkers,
+		onFailure,
+		// Read off the whole call rather than a task view: `cwd` is one top-level
+		// dispatch argument, so it survives on both the freshly parsed path and
+		// the resolved-artifact path, where the sealed task shape carries no cwd.
+		str(args.cwd),
+		confirmation,
+	);
 	return {
 		topology,
 		taskCount: Math.max(1, tasks.length),
@@ -900,14 +944,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;
-	}
-}

package/src/tools/dispatch-run-events.ts

@@ -1,5 +1,6 @@
 import { BusChannels } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import { normalizeClioCoderEventRecord, normalizeClioCoderEventType } from "../core/naming-events.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import { durableAssistantTextFromEvent } from "../domains/dispatch/event-pump.js";
 import { defaultRunEventJournal, type RunEventJournalSink } from "../domains/dispatch/run-event-journal.js";
@@ -61,18 +62,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function eventDetail(event: unknown): string | undefined {
-	const text = assistantTextFromEvent(event);
+	const normalized = isRecord(event) ? normalizeClioCoderEventRecord(event) : event;
+	const text = assistantTextFromEvent(normalized);
 	if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
-	if (!isRecord(event)) return undefined;
-	if (event.type === "clio_tool_finish" && isRecord(event.payload)) {
-		const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
-		const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+	if (!isRecord(normalized)) return undefined;
+	if (normalized.type === "clio_coder_tool_finish" && isRecord(normalized.payload)) {
+		const tool = typeof normalized.payload.tool === "string" ? normalized.payload.tool : "tool";
+		const outcome = typeof normalized.payload.outcome === "string" ? normalized.payload.outcome : "";
 		return `${tool} ${outcome}`.trim();
 	}
-	if (event.type === "attempt_start") {
-		const attempt = typeof event.attempt === "number" ? event.attempt : "?";
-		const runId = typeof event.runId === "string" ? event.runId : "?";
-		const reason = typeof event.reason === "string" ? event.reason : "retry";
+	if (normalized.type === "attempt_start") {
+		const attempt = typeof normalized.attempt === "number" ? normalized.attempt : "?";
+		const runId = typeof normalized.runId === "string" ? normalized.runId : "?";
+		const reason = typeof normalized.reason === "string" ? normalized.reason : "retry";
 		return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
 	}
 	return undefined;
@@ -89,7 +91,7 @@ function eventDetail(event: unknown): string | undefined {
  * (src/domains/dispatch/run-event-journal-bridge.ts) call it.
  */
 export function runTailEntryFromEvent(event: unknown, at: string = new Date().toISOString()): RunTailEntry | null {
-	const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+	const type = isRecord(event) && typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "unknown";
 	if (type === "heartbeat" || type === "message_update") return null;
 	const entry: RunTailEntry = { at, type };
 	const detail = eventDetail(event);
@@ -100,7 +102,7 @@ export function runTailEntryFromEvent(event: unknown, at: string = new Date().to
 export interface DispatchRunEventRegistryOptions {
 	/**
 	 * Durable tee for the display tail. Omitted takes the process-wide default
-	 * journal (settings-gated by `panes.journal`); `null` turns it off for this
+	 * journal (settings-gated by `fleet.history.journal`); `null` turns it off for this
 	 * registry. This is the one wiring choke point: every registry in the
 	 * process is built by this factory, so the sink attaches here rather than at
 	 * each of the three construction sites that call it.

package/src/tools/dispatch-runner.ts

@@ -57,6 +57,7 @@ import {
 	claimCompeteGroup,
 	cleanupCompeteGroup,
 	commitCandidateWork,
+	competeBranchForCandidate,
 	createCandidateWorktreeMapped,
 	isGitRepository,
 	loadCompeteGroup,
@@ -964,6 +965,8 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 		const pick = judged?.ok ? judged.result.winner : null;
 		const pickedSubject = pick === null ? undefined : record.subjects[pick - 1];
 		const candidateReceipt = pickedSubject === undefined ? null : readVerifiedGateReceipt(deps, pickedSubject.runId);
+		const root = record.resourceRoot ?? process.cwd();
+		const pickedBranch = pick === null ? null : competeBranchForCandidate(root, record.group, pick);
 		if (pickedSubject !== undefined && candidateReceipt === null) {
 			throw new Error(
 				`pending compete decision ${record.id} has no verified candidate receipt for ${pickedSubject.runId}`,
@@ -971,11 +974,10 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 		}
 		let blockedProtected: string[] = [];
 		if (pick !== null && pickedSubject !== undefined && candidateReceipt !== null) {
-			const root = record.resourceRoot ?? process.cwd();
 			const protectedPaths = deps.dispatch.protectedArtifactState?.().artifacts.map((artifact) => artifact.path) ?? [];
 			blockedProtected = protectedPathsChangedByCompeteBranch(
 				root,
-				`clio/compete/${record.group}/${pick}`,
+				pickedBranch ?? `clio-coder/compete/${record.group}/${pick}`,
 				protectedPaths,
 			);
 		}
@@ -985,7 +987,7 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 			candidateReceipt !== null &&
 			!isPipelineStepFailure(candidateReceipt) &&
 			blockedProtected.length === 0;
-		if (validWinner && pick !== null && pickedSubject !== undefined) {
+		if (validWinner && pick !== null && pickedSubject !== undefined && pickedBranch !== null) {
 			draft = {
 				group: record.group,
 				topology: "compete",
@@ -997,7 +999,7 @@ function recoverPendingGateEvidence(deps: DispatchToolDeps): void {
 				winner: {
 					index: pick,
 					subject: pickedSubject,
-					branch: `clio/compete/${record.group}/${pick}`,
+					branch: pickedBranch,
 				},
 			};
 		} else {
@@ -1599,9 +1601,12 @@ function runApplyWinner(
 		};
 	}
 	const branch = input.branch;
-	const match = /^clio\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch);
+	const match = /^(?:clio-coder|clio)\/compete\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/([1-9]\d*)$/.exec(branch);
 	if (!match) {
-		return { kind: "error", message: "dispatch: apply_winner.branch must be a clio/compete/<group>/<n> branch" };
+		return {
+			kind: "error",
+			message: "dispatch: apply_winner.branch must be a clio-coder/compete/<group>/<n> branch",
+		};
 	}
 	const group = match[1] ?? "";
 	const winnerIndex = Number.parseInt(match[2] ?? "", 10);