@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/domains/config/keybindings.ts

@@ -4,8 +4,9 @@
  * can resolve both against user overrides stored in `settings.yaml`.
  *
  * The `Keybindings` interface in pi-tui is extensible via declaration merging.
- * Adding `clio.*` ids here makes them typed everywhere the manager is used:
- * pass a wrong id to `matches("clio.typo", ...)` and the compiler complains.
+ * Adding `clio-coder.*` ids here makes them typed everywhere the manager is
+ * used: pass a wrong id to `matches("clio-coder.typo", ...)` and the compiler
+ * complains.
  */
 
 import type { KeybindingDefinitions } from "../../engine/tui.js";
@@ -18,28 +19,28 @@ import { TUI_KEYBINDINGS } from "../../engine/tui.js";
  * live in `resolveCtrlCAction` and are not a simple keybinding.
  */
 export interface ClioAppKeybindings {
-	"clio.thinking.cycle": true;
-	"clio.exit": true;
-	"clio.status.toggle": true;
-	"clio.session.tree": true;
-	"clio.dispatchBoard.toggle": true;
-	"clio.tasks.open": true;
-	"clio.decisions.open": true;
-	"clio.dispatch.background": true;
-	"clio.model.select": true;
-	"clio.model.cycleForward": true;
-	"clio.model.cycleBackward": true;
-	"clio.tool.expand": true;
-	"clio.tool.expandAll": true;
-	"clio.tool.liveOutput": true;
-	"clio.thinking.expand": true;
-	"clio.thinking.expandAll": true;
-	"clio.editor.external": true;
-	"clio.message.followUp": true;
-	"clio.message.interrupt": true;
-	"clio.message.dequeue": true;
-	"clio.notifications.dismiss": true;
-	"clio.leader": true;
+	"clio-coder.thinking.cycle": true;
+	"clio-coder.exit": true;
+	"clio-coder.status.toggle": true;
+	"clio-coder.session.tree": true;
+	"clio-coder.dispatchBoard.toggle": true;
+	"clio-coder.tasks.open": true;
+	"clio-coder.decisions.open": true;
+	"clio-coder.dispatch.background": true;
+	"clio-coder.model.select": true;
+	"clio-coder.model.cycleForward": true;
+	"clio-coder.model.cycleBackward": true;
+	"clio-coder.tool.expand": true;
+	"clio-coder.tool.expandAll": true;
+	"clio-coder.tool.liveOutput": true;
+	"clio-coder.thinking.expand": true;
+	"clio-coder.thinking.expandAll": true;
+	"clio-coder.editor.external": true;
+	"clio-coder.message.followUp": true;
+	"clio-coder.message.interrupt": true;
+	"clio-coder.message.dequeue": true;
+	"clio-coder.notifications.dismiss": true;
+	"clio-coder.leader": true;
 }
 
 export type ClioKeybinding = keyof ClioAppKeybindings;
@@ -47,7 +48,7 @@ export type ClioKeybinding = keyof ClioAppKeybindings;
 /**
  * Declaration merge: pi-tui's `Keybindings` interface is open so downstream
  * packages register their action ids. After this block, `KeybindingsManager`
- * returned from `createKeybindingManager` accepts `clio.*` ids with full
+ * returned from `createKeybindingManager` accepts `clio-coder.*` ids with full
  * TypeScript checking.
  */
 declare module "@earendil-works/pi-tui" {
@@ -69,37 +70,37 @@ declare module "@earendil-works/pi-tui" {
  * net for user rebinds.
  */
 export const CLIO_APP_KEYBINDINGS = {
-	"clio.thinking.cycle": {
+	"clio-coder.thinking.cycle": {
 		defaultKeys: "shift+tab",
 		description: "Cycle orchestrator thinking level",
 	},
-	"clio.exit": {
+	"clio-coder.exit": {
 		defaultKeys: "ctrl+d",
 		description: "Exit when the editor is empty",
 	},
-	"clio.status.toggle": {
+	"clio-coder.status.toggle": {
 		defaultKeys: "alt+u",
 		description: "Toggle the footer dashboard (compact / expanded)",
 	},
-	"clio.session.tree": {
+	"clio-coder.session.tree": {
 		defaultKeys: "alt+t",
 		description: "Open the /tree navigator",
 	},
-	"clio.dispatchBoard.toggle": {
+	"clio-coder.dispatchBoard.toggle": {
 		defaultKeys: "alt+w",
 		description: "Toggle the dispatch (workers) board overlay",
 	},
-	"clio.tasks.open": {
+	"clio-coder.tasks.open": {
 		// Approved application-boundary override of pi-tui editor word-back.
 		defaultKeys: "alt+b",
 		description: "Open the composite session and operator task board",
 	},
-	"clio.decisions.open": {
+	"clio-coder.decisions.open": {
 		// Approved application-boundary override of pi-tui editor word-delete.
 		defaultKeys: "alt+d",
 		description: "Open the settled interview decision board",
 	},
-	"clio.dispatch.background": {
+	"clio-coder.dispatch.background": {
 		// Ctrl+B alone is pi-tui's editor cursor-left, so the Claude Code chord
 		// cannot be the primary here. Alt+S ("send to background") keeps the app
 		// scheme and earns the Ctrl+G leader fallback, which only alt+<letter>
@@ -107,56 +108,56 @@ export const CLIO_APP_KEYBINDINGS = {
 		defaultKeys: ["alt+s", "ctrl+alt+b"],
 		description: "Send the running attached dispatch to the background as a detached batch",
 	},
-	"clio.model.select": {
+	"clio-coder.model.select": {
 		defaultKeys: "alt+l",
 		description: "Open the model + targets selector",
 	},
-	"clio.model.cycleForward": {
+	"clio-coder.model.cycleForward": {
 		defaultKeys: "alt+j",
 		description: "Cycle to next scoped model",
 	},
-	"clio.model.cycleBackward": {
+	"clio-coder.model.cycleBackward": {
 		defaultKeys: "alt+k",
 		description: "Cycle to previous scoped model",
 	},
-	"clio.tool.expand": {
+	"clio-coder.tool.expand": {
 		defaultKeys: "alt+o",
 		description:
 			"Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block",
 	},
-	"clio.tool.expandAll": {
+	"clio-coder.tool.expandAll": {
 		// Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
 		// Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
 		defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
 		description:
 			"Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides",
 	},
-	"clio.tool.liveOutput": {
+	"clio-coder.tool.liveOutput": {
 		defaultKeys: "alt+p",
 		description: "Toggle streaming partial tool output in expanded tool bodies",
 	},
-	"clio.thinking.expand": {
+	"clio-coder.thinking.expand": {
 		defaultKeys: "alt+r",
 		description:
 			"Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)",
 	},
-	"clio.thinking.expandAll": {
+	"clio-coder.thinking.expandAll": {
 		// Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
 		// Alt+Shift+R as a distinct key event.
 		defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
 		description:
 			"Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides",
 	},
-	"clio.editor.external": {
+	"clio-coder.editor.external": {
 		defaultKeys: "alt+g",
 		description: "Open the current input in an external editor",
 	},
-	"clio.message.followUp": {
+	"clio-coder.message.followUp": {
 		defaultKeys: "alt+enter",
 		description:
 			"End of turn: queue the current input for delivery when the active run settles (Enter delivers it at the next slot, between tool batches)",
 	},
-	"clio.message.interrupt": {
+	"clio-coder.message.interrupt": {
 		// Alt+I keeps the app scheme and earns the Ctrl+G leader fallback. A
 		// Ctrl+Enter chord was rejected because legacy terminals send it as a
 		// plain Enter, which would turn every send into a cancel.
@@ -164,15 +165,15 @@ export const CLIO_APP_KEYBINDINGS = {
 		description:
 			"Interrupt: cancel the active run and deliver the current input now (refused while an attached dispatch runs or a permission ask is parked; the input then queues for the next slot)",
 	},
-	"clio.message.dequeue": {
+	"clio-coder.message.dequeue": {
 		defaultKeys: "alt+up",
 		description: "Restore queued steering and follow-up messages to the editor",
 	},
-	"clio.notifications.dismiss": {
+	"clio-coder.notifications.dismiss": {
 		defaultKeys: "alt+x",
 		description: "Dismiss footer notifications",
 	},
-	"clio.leader": {
+	"clio-coder.leader": {
 		defaultKeys: "ctrl+g",
 		description: "Start portable leader-key fallback for Alt shortcuts",
 	},

package/src/domains/config/watcher.ts

@@ -28,7 +28,7 @@ export function startConfigWatcher(cb: WatcherCallback): ConfigWatcher {
 			}, 80);
 		});
 	} catch (err) {
-		console.error("[clio:config] watcher setup failed:", err);
+		console.error("[clio-coder:config] watcher setup failed:", err);
 	}
 
 	return {

package/src/domains/context/codewiki/indexer.ts

@@ -752,7 +752,7 @@ function mergeTreeSitterWithRegexImports(
 	};
 }
 
-export function fallbackExtraction(language: CodewikiLanguage, relPath: string, text: string): LanguageExtraction {
+function fallbackExtraction(language: CodewikiLanguage, relPath: string, text: string): LanguageExtraction {
 	return extractWithExtractors(fallbackExtractors, language, relPath, text);
 }
 

package/src/domains/context/extension.ts

@@ -146,15 +146,15 @@ function collectStartupHints(cwd: string, options: ContextBundleOptions = {}): s
 		projectType !== "unknown" &&
 		options.noContextFiles !== true
 	) {
-		hints.push("clio: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
+		hints.push("clio-coder: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
 	}
 	for (const issue of clio.errors) {
-		hints.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
+		hints.push(`clio-coder: malformed ${issue.path} ignored: ${issue.error}`);
 	}
 	const state = readClioState(cwd);
 	if (!state) return hints;
 	if (state.contextSources !== undefined && adoptionSourcesChanged(state.contextSources, { cwd })) {
-		hints.push("clio: Imported agent context changed. Run /context init --adopt to refresh.");
+		hints.push("clio-coder: Imported agent context changed. Run /context init --adopt to refresh.");
 	}
 	return hints;
 }

package/src/domains/context/prompt-context.ts

@@ -32,7 +32,7 @@ export function renderPromptContext(cwd: string): ProjectPromptContext {
 	const clioMd: ParsedClioMd | null = loadedClioMd.value;
 	for (const file of loadedClioMd.files) pieces.push(renderProjectContextFragment(file.value, file.path));
 	for (const issue of loadedClioMd.errors) {
-		warnings.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
+		warnings.push(`clio-coder: malformed ${issue.path} ignored: ${issue.error}`);
 	}
 	// Said where the handbook would have been: a model that sees no project
 	// context spends its first tool call reading CLIO-CODER.md and gets

package/src/domains/context/wiki/assemble.ts

@@ -39,7 +39,7 @@ const SOURCE_CITATION =
 const INTERNAL_LINK = /\[[^\]]*\]\((?![a-z][a-z\d+.-]*:|\/\/|#)([^)\s]+\.md)(?:#[^)\s]*)?\)/gi;
 
 /** Marker line carrying a page's unrepaired references; regenerated every pass. */
-const REPAIR_NOTE = /^<!-- clio:wiki .*-->$/gm;
+const REPAIR_NOTE = /^<!-- (?:clio-coder|clio):wiki .*-->$/gm;
 
 export interface WikiPageIssue {
 	page: string;
@@ -79,7 +79,7 @@ function renderRepairNote(issues: ReadonlyArray<WikiPageIssue>): string {
 	const parts: string[] = [];
 	if (links.length > 0) parts.push(`unresolved links: ${[...new Set(links)].join(", ")}`);
 	if (citations.length > 0) parts.push(`unresolved sources: ${[...new Set(citations)].join(", ")}`);
-	return parts.length === 0 ? "" : `\n<!-- clio:wiki ${parts.join("; ")} -->\n`;
+	return parts.length === 0 ? "" : `\n<!-- clio-coder:wiki ${parts.join("; ")} -->\n`;
 }
 
 /**

package/src/domains/context/working-set/replay/metrics.ts

@@ -144,10 +144,6 @@ function measure(input: ReplayMeasurement): MeasuredTrace {
 	};
 }
 
-export function measureReplayTrace(input: ReplayMeasurement): ReplayMetrics {
-	return measure(input).metrics;
-}
-
 function mean(values: ReadonlyArray<number>): number {
 	return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
 }

package/src/domains/context/working-set/replay/report.ts

@@ -49,7 +49,7 @@ function metricObject(metrics: ReplayMetrics, turnsToFirstSummaryCount: number):
 export function renderReplayJson(input: ReplayReportInput): string {
 	const filtered = Object.fromEntries(Object.entries(input.cascade.filtered).sort(([a], [b]) => a.localeCompare(b)));
 	const artifact = {
-		schema: "clio-context-replay-v2",
+		schema: "clio-coder-context-replay-v2",
 		config: {
 			policies: [...input.config.policies],
 			budgets: [...input.config.budgets],

package/src/domains/context/working-set/replay/synthetic.ts

@@ -93,7 +93,7 @@ export const SYNTHETIC_CORPORA: ReadonlyArray<SyntheticCorpusSpec> = [
 	},
 ];
 
-export function syntheticCorpus(id: string): SyntheticCorpusSpec | undefined {
+function syntheticCorpus(id: string): SyntheticCorpusSpec | undefined {
 	return SYNTHETIC_CORPORA.find((spec) => spec.id === id);
 }
 
@@ -258,7 +258,7 @@ function testOutput(files: ReadonlyArray<RepoFile>, failing: RepoFile | null): s
 }
 
 /** Generate one trace of the corpus. `index` selects the trace; the spec's seed and index fix every byte. */
-export function generateSyntheticTrace(spec: SyntheticCorpusSpec, index: number): Trace {
+function generateSyntheticTrace(spec: SyntheticCorpusSpec, index: number): Trace {
 	const rnd = mulberry32(spec.seed * 1000 + index);
 	const between = (low: number, high: number): number => low + Math.floor(rnd() * (high - low + 1));
 	const pick = <T>(items: ReadonlyArray<T>): T => items[Math.floor(rnd() * items.length)] as T;

package/src/domains/dispatch/active-route-planner.ts

@@ -80,8 +80,8 @@ function enabled(input: ActivationInputs): boolean {
 			input.settings !== undefined &&
 			posture !== "manual" &&
 			input.failover === "approved" &&
-			input.settings.activePostures.includes(posture as (typeof input.settings.activePostures)[number]) &&
-			input.settings.agentAutomation.activeAgentRoles.length > 0
+			input.settings.postures.includes(posture as (typeof input.settings.postures)[number]) &&
+			input.settings.agentRoles.length > 0
 		);
 	}
 	return (

package/src/domains/dispatch/admission-error.ts

@@ -0,0 +1,9 @@
+/** A queued assignment was intentionally canceled before it acquired capacity. */
+export class AdmissionCanceledError extends Error {
+	readonly code = "admission_canceled" as const;
+
+	constructor(message = "dispatch: admission canceled before a capacity slot opened") {
+		super(message);
+		this.name = "AdmissionCanceledError";
+	}
+}

package/src/domains/dispatch/admission.ts

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { endpointLabel } from "../providers/endpoint-capacity.js";
 import type { ActionClass } from "../safety/action-classifier.js";
 import type { ScopeSpec } from "../safety/scope.js";
+import { AdmissionCanceledError } from "./admission-error.js";
 import { createAdmissionQueue } from "./admission-queue.js";
 import {
 	acquireCapacityLease,
@@ -131,7 +132,12 @@ function describeAdmissionFailure(input: {
 				holders === undefined
 					? "the supplied capacity snapshot does not attribute the occupied slots"
 					: describeEndpointCapacityHolders(holders);
-			return `dispatch: admission denied: endpoint '${endpointLabel(input.endpointKey)}' capacity reached (${endpointActive}/${endpointLimit} slots): ${occupancy}; collect in-flight runs or point workers at a second server`;
+			const queued = input.queueDepth > 0 ? `, ${input.queueDepth} more queued` : "";
+			return [
+				`dispatch: admission timed out after ${Math.round(input.waitedMs)}ms waiting for an endpoint slot`,
+				` on '${endpointLabel(input.endpointKey)}' (${endpointActive}/${endpointLimit} slots${queued}): ${occupancy}.`,
+				" Wait for the running request to settle or dispatch this work again.",
+			].join("");
 		}
 	}
 	const nodeLimit = input.limits.nodes[input.nodeId];
@@ -202,14 +208,9 @@ export function createCapacityAdmissionController(options: {
 					admittedLease = request.value();
 					return true;
 				} catch (error) {
-					// Endpoint saturation is a named refusal because waiting would keep a
-					// model request queued behind the same inference scheduler. Existing
-					// node and global admission retain their bounded wait behavior.
-					if (error instanceof Error && /endpoint '.*' capacity reached/u.test(error.message)) {
-						queue.fail(request.requestId, error);
-						return false;
-					}
-					// Node and global capacity can wait. Anything else fails the request.
+					// Saturation at any capacity dimension is transient and keeps its
+					// assignment in the one bounded admission queue. Unavailable capacity,
+					// draining, corrupt state, and every other error still fail immediately.
 					if (error instanceof Error && /capacity reached/.test(error.message)) return false;
 					queue.fail(request.requestId, error instanceof Error ? error : new Error(String(error)));
 					return false;
@@ -278,18 +279,18 @@ export function createCapacityAdmissionController(options: {
 				pumpNow();
 				const outcome = await outcomePromise;
 				if (outcome.state !== "admitted") {
-					throw new Error(
-						describeAdmissionFailure({
-							state: outcome.state,
-							nodeId: input.nodeId,
-							...(input.endpointKey !== undefined ? { endpointKey: input.endpointKey } : {}),
-							waitedMs: now() - queuedAt,
-							overdueAtQueueMs: queuedAt - input.deadlineAt,
-							queueDepth: queue.size(),
-							limits: options.limits(),
-							usage: options.usage?.() ?? capacityLeaseUsage({ nowMs: now() }),
-						}),
-					);
+					const detail = describeAdmissionFailure({
+						state: outcome.state,
+						nodeId: input.nodeId,
+						...(input.endpointKey !== undefined ? { endpointKey: input.endpointKey } : {}),
+						waitedMs: now() - queuedAt,
+						overdueAtQueueMs: queuedAt - input.deadlineAt,
+						queueDepth: queue.size(),
+						limits: options.limits(),
+						usage: options.usage?.() ?? capacityLeaseUsage({ nowMs: now() }),
+					});
+					if (outcome.state === "canceled") throw new AdmissionCanceledError(detail);
+					throw new Error(detail);
 				}
 				const lease = acquired.get(input.assignmentId);
 				if (!lease) throw new Error("dispatch: admitted request has no capacity lease");

package/src/domains/dispatch/agent-candidates.ts

@@ -249,7 +249,7 @@ function candidateRejections(spec: AgentSpec, intent: AgentTaskIntent): string[]
 }
 
 /** Hard filters first; display-only category is deliberately never read. */
-export function evaluateAgentCandidates(specs: ReadonlyArray<AgentSpec>, intent: AgentTaskIntent): AgentCandidateSet {
+function evaluateAgentCandidates(specs: ReadonlyArray<AgentSpec>, intent: AgentTaskIntent): AgentCandidateSet {
 	if (specs.length > AGENT_CANDIDATE_LIMIT) {
 		throw new Error(
 			`dispatch routing configuration error: agent candidate overflow (${specs.length}/${AGENT_CANDIDATE_LIMIT})`,

package/src/domains/dispatch/agent-ledger-store.ts

@@ -251,7 +251,7 @@ export function agentLedgerContribution(id: string, runId: string): AgentLedgerC
 		.filter((entry) => entry.runId === runId)
 		.sort((left, right) => left.sequence - right.sequence);
 	const digest = createHash("sha256")
-		.update(`clio.agentLedger:${canonicalJson(mine)}`, "utf8")
+		.update(`clio-coder.agentLedger:${canonicalJson(mine)}`, "utf8")
 		.digest("hex");
 	return { posted: contribution.posted, refused: contribution.refused, digest };
 }

package/src/domains/dispatch/agent-ledger.ts

@@ -124,7 +124,7 @@ export function corroboration(entries: ReadonlyArray<AgentLedgerEntry>): Corrobo
 }
 
 /** Entry ids targeted by a review that did not pass. */
-export function disputes(entries: ReadonlyArray<AgentLedgerEntry>): ReadonlySet<string> {
+function disputes(entries: ReadonlyArray<AgentLedgerEntry>): ReadonlySet<string> {
 	const disputed = new Set<string>();
 	for (const entry of entries) {
 		if (entry.body.kind === "review" && !entry.body.passed) disputed.add(entry.body.target);

package/src/domains/dispatch/assignment.ts

@@ -44,9 +44,9 @@ export interface AssignmentPolicy {
 }
 
 export interface RoutingActivationSnapshot {
-	activeRoles: ReadonlyArray<ActiveRoutingRole>;
-	activePostures: ReadonlyArray<ActiveRoutingPosture>;
-	agentAutomation: { activeAgentRoles: ReadonlyArray<ActiveAgentRole> };
+	roles: ReadonlyArray<ActiveRoutingRole>;
+	postures: ReadonlyArray<ActiveRoutingPosture>;
+	agentRoles: ReadonlyArray<ActiveAgentRole>;
 }
 
 /** Activation is explicit in both dimensions and never widens mutation authority. */
@@ -60,8 +60,8 @@ export function activeRoutingEnabled(input: {
 	if (input.posture === "manual" || input.failover !== "approved") return false;
 	if (input.capabilityClass !== "read-only" && input.capabilityClass !== "verification") return false;
 	return (
-		input.settings.activeRoles.includes(input.role as ActiveRoutingRole) &&
-		input.settings.activePostures.includes(input.posture as ActiveRoutingPosture)
+		input.settings.roles.includes(input.role as ActiveRoutingRole) &&
+		input.settings.postures.includes(input.posture as ActiveRoutingPosture)
 	);
 }
 

package/src/domains/dispatch/capacity-lease.ts

@@ -68,7 +68,7 @@ export interface LeaseOwnerProbe {
 	alive?(pid: number): boolean;
 }
 
-export function capacityStatePath(): string {
+function capacityStatePath(): string {
 	return join(clioStateDir(), "dispatch-admission.json");
 }
 /** The admission state file itself keys the one cross-process transaction lock. */
@@ -263,6 +263,26 @@ export function describeEndpointCapacityHolders(holders: EndpointCapacityHolders
 	return `${named} ${total === 1 ? "holds" : "hold"} ${total === 1 ? "the slot" : "the slots"}`;
 }
 
+/**
+ * The ways past a saturated inference endpoint, in the order an operator can
+ * act on them.
+ *
+ * `maxConcurrentRequests` is named because the conservative default of one slot
+ * is a guess about an unprobed server, and on a server started with
+ * `--parallel 4` it is simply wrong. Without that sentence the denial reads as
+ * a hardware limit and the operator has no reason to look for a setting.
+ *
+ * `rosterFloor` is the smallest same-wave width the caller's topology can have.
+ * A council runs its whole roster in one wave, so "dispatch fewer at once" is
+ * not a move it has; saying so keeps the remedy honest.
+ */
+export function endpointCapacityRemedy(input?: { rosterFloor?: number }): string {
+	const ways =
+		"set this target's maxConcurrentRequests to the slot count the server was started with, collect in-flight runs, or point workers at a second server";
+	if (input?.rosterFloor === undefined) return `reduce the same-wave worker count, ${ways}`;
+	return `a council runs its whole roster in one wave and cannot go below ${input.rosterFloor} members, so ${ways}`;
+}
+
 function assertCapacity(
 	file: CapacityStateFile,
 	nodeId: string,
@@ -299,7 +319,7 @@ function assertCapacity(
 			const used = holders.leases + holders.reservations + holders.foregroundStreams;
 			if (used >= endpointLimit)
 				throw new Error(
-					`dispatch: admission denied: endpoint '${endpointLabel(endpointKey)}' capacity reached (${used}/${endpointLimit} slots): ${describeEndpointCapacityHolders(holders)}; collect in-flight runs or point workers at a second server`,
+					`dispatch: admission denied: endpoint '${endpointLabel(endpointKey)}' capacity reached (${used}/${endpointLimit} slots): ${describeEndpointCapacityHolders(holders)}; ${endpointCapacityRemedy()}`,
 				);
 		}
 	}
@@ -488,10 +508,7 @@ export function createNodeLeaseUsageReader(options: {
 	};
 }
 
-export function listCapacityLeases(options?: {
-	nowMs?: number;
-	probe?: LeaseOwnerProbe;
-}): ReadonlyArray<CapacityLease> {
+function listCapacityLeases(options?: { nowMs?: number; probe?: LeaseOwnerProbe }): ReadonlyArray<CapacityLease> {
 	return withStateFileLockSync(capacityStateLockPath(), () => {
 		const file = readCapacityStateUnsafe();
 		const before = file.leases.length;

package/src/domains/dispatch/code-step.ts

@@ -145,7 +145,7 @@ function resolveCwd(command: FleetCommand, workspaceRoot: string): string {
 }
 
 /** Closed environment: the base allowlist plus whatever this command declared. */
-export function codeStepEnv(command: FleetCommand, source: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+function codeStepEnv(command: FleetCommand, source: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
 	const names = [...FLEET_COMMAND_BASE_ENV, ...command.env];
 	const env: NodeJS.ProcessEnv = {};
 	for (const name of names) {

package/src/domains/dispatch/contract.ts

@@ -308,7 +308,7 @@ export interface DispatchContract {
 	 * assignment id addresses its current attempt. The text is sent as a JSON
 	 * line on the worker's open stdin and injected into its transcript at the
 	 * next loop boundary; the worker acknowledges runtime acceptance with a
-	 * `clio_steer_received` event. Throws with an operator-facing message when
+	 * `clio_coder_steer_received` event. Throws with an operator-facing message when
 	 * the run is unknown or inactive, when the runtime is a single-shot
 	 * subprocess or ACP delegation, or when the worker's stdin is already gone.
 	 */
@@ -319,7 +319,7 @@ export interface DispatchContract {
 	 * running native worker. A logical assignment id addresses its current attempt (onPermission="escalate"). Writes a
 	 * `permission_decision` JSON line on the worker's open stdin; the worker
 	 * releases or denies the parked tool call and acks with a
-	 * `clio_permission_resolved` event. Human-only: no model-facing tool can
+	 * `clio_coder_permission_resolved` event. Human-only: no model-facing tool can
 	 * reach this. Throws with an operator-facing message when the run is
 	 * unknown or no longer active, when the run kind has no stdin channel
 	 * (acp-delegation), or when the worker's stdin is already gone. Mirrors