@iowarp/clio-coder 0.4.1 → 0.4.2

package/src/entry/extension-reload.ts

@@ -0,0 +1,309 @@
+/**
+ * Composition-root coordinator for extension generations.
+ *
+ * The extensions bundle owns the snapshot store and the middleware bundle
+ * owns the registration table; neither knows the other exists. This module
+ * is the only writer of both for the "user-hooks" owner and the only caller
+ * of the extensions reload, and it sequences them so no observer can see
+ * resources from one generation paired with hooks from another:
+ *
+ *   1. capture and canonicalize the workspace once;
+ *   2. prepare the extension candidate (build, validate, reserve generation)
+ *      and require its snapshot to be for that exact workspace;
+ *   3. build the user-hook registrations from the candidate's captured
+ *      declarations plus the project files under that workspace;
+ *   4. prepare the middleware replacement (validate, build the next state);
+ *   5. confirm both prepared states are still current, then publish both
+ *      with two assignment-only calls in adjacent statements;
+ *   6. only then emit conflicts, the reload event, and issue lines.
+ *
+ * Neither publish primitive validates, refuses, throws, or calls out, so a
+ * partial publication is impossible by construction: every failure or stale
+ * state is detected before step 5 and discards both prepared states. Boot
+ * uses the same path, so the first extension generation and the first hook
+ * set become live together; before that, readers take the ephemeral
+ * generation-0 path. Everything here is synchronous; the reentrancy guard
+ * exists for a caller that re-enters from a callback.
+ */
+
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import type { ExtensionsReloadedPayload } from "../core/bus-events.js";
+import type {
+	ExtensionReloadCommitted,
+	ExtensionReloadRejection,
+	ExtensionSnapshotDiagnostics,
+	ExtensionsContract,
+} from "../domains/extensions/index.js";
+import { EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP } from "../domains/extensions/index.js";
+import {
+	type BuildUserHookRegistrationsResult,
+	buildUserHookRegistrations,
+	type CapturedHookSourceSet,
+	type HookReceiptSink,
+	type MiddlewareContract,
+	type MiddlewareRegistrationConflict,
+	type UserHookCommandRunner,
+} from "../domains/middleware/index.js";
+import { capturedHookSourcesFor } from "./extension-hook-sources.js";
+
+export interface ExtensionReloadHookSummary {
+	/** Registrations published for the owner in this generation. */
+	registered: number;
+	dropped: number;
+	fileIssues: number;
+	issues: number;
+	overridden: number;
+}
+
+export type ExtensionReloadOutcome =
+	| (ExtensionReloadCommitted & { hooks: ExtensionReloadHookSummary; lines: ReadonlyArray<string> })
+	| (ExtensionReloadRejection & { lines: ReadonlyArray<string> });
+
+export interface ExtensionReloadCoordinatorDeps {
+	/** Absent on a degraded boot where the extensions domain failed to start. */
+	extensions: Pick<ExtensionsContract, "prepareReload" | "snapshot"> | undefined;
+	middleware: Pick<MiddlewareContract, "prepareRegistrationReplacement" | "replaceRegistrations" | "ownedGeneration">;
+	/** Read once per run and canonicalized; the candidate must be for exactly this workspace. */
+	cwd: () => string;
+	recordReceipt: HookReceiptSink;
+	runCommand?: UserHookCommandRunner;
+	now?: () => number;
+	/** One operator line per issue; stderr in headless runs, dropped or noticed by the host in interactive runs. */
+	report: (line: string) => void;
+	/** Called once per published generation, after both references are live. */
+	onCommitted?: (event: ExtensionsReloadedPayload) => void;
+}
+
+export interface ExtensionReloadCoordinator {
+	/**
+	 * Boot: publish generation 1 and its user hooks together. On a rejected
+	 * build, or without an extensions domain, the project's own hooks are
+	 * published under generation 1 and no extension generation exists.
+	 */
+	applyBoot(): ExtensionReloadOutcome;
+	/** Operator or programmatic reload. Synchronous and never throws. */
+	reload(): ExtensionReloadOutcome;
+}
+
+/** Cap on issue lines carried in one outcome so an operator surface stays bounded. */
+export const EXTENSION_RELOAD_REPORT_LINE_CAP = 40;
+
+function failure(message: string): ExtensionSnapshotDiagnostics {
+	return {
+		entries: [{ type: "error", message: message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP) }],
+		truncated: 0,
+	};
+}
+
+function issueLines(
+	built: BuildUserHookRegistrationsResult,
+	dropped: ReadonlyArray<MiddlewareRegistrationConflict>,
+): string[] {
+	const lines: string[] = [];
+	for (const issue of built.fileIssues) lines.push(`[clio-coder:hooks] ${issue.message}`);
+	for (const issue of built.issues) {
+		lines.push(`[clio-coder:hooks] ${issue.source.sourcePath}#${issue.index}: ${issue.issues.join("; ")}`);
+	}
+	for (const { loser, winner } of built.overridden) {
+		lines.push(`[clio-coder:hooks] ${loser.source.sourcePath} hook '${loser.id}' overridden by ${winner.sourcePath}`);
+	}
+	for (const conflict of dropped) {
+		lines.push(
+			`[clio-coder:hooks] hook '${conflict.id}' dropped: id is held by a ${conflict.conflictsWith} registration`,
+		);
+	}
+	return lines;
+}
+
+export function createExtensionReloadCoordinator(deps: ExtensionReloadCoordinatorDeps): ExtensionReloadCoordinator {
+	let inFlight = false;
+
+	const build = (workspace: string, captured: CapturedHookSourceSet | null): BuildUserHookRegistrationsResult =>
+		buildUserHookRegistrations({
+			cwd: workspace,
+			workspaceRoot: workspace,
+			...(captured !== null ? { capturedSources: captured } : {}),
+			recordReceipt: deps.recordReceipt,
+			...(deps.runCommand !== undefined ? { runCommand: deps.runCommand } : {}),
+			...(deps.now !== undefined ? { now: deps.now } : {}),
+		});
+
+	const emitLines = (lines: ReadonlyArray<string>): void => {
+		for (const line of lines) {
+			try {
+				deps.report(line);
+			} catch {
+				// Reporting is observability; it must never affect the reload.
+			}
+		}
+	};
+
+	const rejected = (rejection: ExtensionReloadRejection): ExtensionReloadOutcome => {
+		const lines = rejection.diagnostics.entries.map((entry) => `[clio-coder:extensions] ${entry.message}`);
+		emitLines(lines);
+		return { ...rejection, lines: lines.slice(0, EXTENSION_RELOAD_REPORT_LINE_CAP) };
+	};
+
+	const canonicalWorkspace = (): string | null => {
+		try {
+			return realpathSync(path.resolve(deps.cwd()));
+		} catch {
+			return null;
+		}
+	};
+
+	/**
+	 * Degraded boot: no extension generation will ever exist, so the project's
+	 * own hooks are published alone under generation 1. Readers keep taking
+	 * the ephemeral path, which pairs no generation with no generation.
+	 */
+	const publishProjectHooksOnly = (workspace: string): void => {
+		if (deps.middleware.ownedGeneration("user-hooks") !== 0) return;
+		const built = build(workspace, null);
+		const report = deps.middleware.replaceRegistrations("user-hooks", 1, built.registrations);
+		const lines = issueLines(built, report.dropped);
+		if (!report.applied) lines.push(`[clio-coder:hooks] project hooks were not applied: ${report.reason ?? "refused"}`);
+		emitLines(lines);
+	};
+
+	const run = (boot: boolean): ExtensionReloadOutcome => {
+		const activeGeneration = deps.extensions?.snapshot()?.generation ?? 0;
+		if (inFlight) {
+			return rejected({
+				status: "rejected",
+				reason: "reentrant",
+				generation: activeGeneration,
+				diagnostics: { entries: [], truncated: 0 },
+			});
+		}
+		inFlight = true;
+		try {
+			const workspace = canonicalWorkspace();
+			if (workspace === null) {
+				return rejected({
+					status: "rejected",
+					reason: "build-failed",
+					generation: activeGeneration,
+					diagnostics: failure("the working directory could not be resolved"),
+				});
+			}
+			if (deps.extensions === undefined) {
+				if (boot) publishProjectHooksOnly(workspace);
+				return rejected({
+					status: "rejected",
+					reason: "build-failed",
+					generation: 0,
+					diagnostics: failure("extensions domain is not loaded; restart to recover it"),
+				});
+			}
+			const prepared = deps.extensions.prepareReload();
+			if (prepared.status === "rejected") {
+				if (boot) publishProjectHooksOnly(workspace);
+				return rejected(prepared);
+			}
+			const candidate = prepared.candidate;
+			if (candidate.snapshot.cwd !== workspace) {
+				candidate.discard();
+				return rejected({
+					status: "rejected",
+					reason: "workspace-changed",
+					generation: candidate.previousGeneration,
+					diagnostics: failure(
+						`extension snapshot was built for ${candidate.snapshot.cwd} but the session workspace is ${workspace}`,
+					),
+				});
+			}
+			let built: BuildUserHookRegistrationsResult;
+			try {
+				built = build(workspace, capturedHookSourcesFor(candidate.snapshot));
+			} catch (error) {
+				candidate.discard();
+				return rejected({
+					status: "rejected",
+					reason: "build-failed",
+					generation: candidate.previousGeneration,
+					diagnostics: failure(
+						`user hook registrations could not be built: ${error instanceof Error ? error.message : String(error)}`,
+					),
+				});
+			}
+			const preparedReplacement = deps.middleware.prepareRegistrationReplacement(
+				"user-hooks",
+				candidate.generation,
+				built.registrations,
+			);
+			if (preparedReplacement.status === "rejected") {
+				candidate.discard();
+				return rejected({
+					status: "rejected",
+					reason: "stale",
+					generation: candidate.previousGeneration,
+					diagnostics: failure(
+						`middleware refused generation ${candidate.generation} (${preparedReplacement.reason}; active ${preparedReplacement.activeGeneration})`,
+					),
+				});
+			}
+			const replacement = preparedReplacement.replacement;
+			// Final freshness validation. After this point neither primitive can
+			// refuse, so a stale side here discards both and publishes neither.
+			if (!candidate.current() || !replacement.current()) {
+				replacement.discard();
+				candidate.discard();
+				return rejected({
+					status: "rejected",
+					reason: "stale",
+					generation: candidate.previousGeneration,
+					diagnostics: failure(`generation ${candidate.generation} was superseded before it could be published`),
+				});
+			}
+			candidate.publish();
+			replacement.publish();
+			// Both references are live. Observers may run from here on.
+			replacement.emitConflicts();
+			const lines = issueLines(built, replacement.dropped);
+			try {
+				deps.onCommitted?.({
+					generation: candidate.generation,
+					previousGeneration: candidate.previousGeneration,
+					changed: candidate.changed,
+					digest: candidate.snapshot.digest,
+				});
+			} catch (error) {
+				// Publication is already complete. An observability callback cannot
+				// turn a live paired generation into a thrown or rejected outcome.
+				const message = error instanceof Error ? error.message : String(error);
+				lines.push(
+					`[clio-coder:extensions] committed generation observer failed: ${message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP)}`,
+				);
+			}
+			emitLines(lines);
+			return {
+				status: "committed",
+				generation: candidate.generation,
+				previousGeneration: candidate.previousGeneration,
+				changed: candidate.changed,
+				digest: candidate.snapshot.digest,
+				added: candidate.added,
+				removed: candidate.removed,
+				modified: candidate.modified,
+				diagnostics: candidate.snapshot.diagnostics,
+				hooks: {
+					registered: replacement.size,
+					dropped: replacement.dropped.length,
+					fileIssues: built.fileIssues.length,
+					issues: built.issues.length,
+					overridden: built.overridden.length,
+				},
+				lines: lines.slice(0, EXTENSION_RELOAD_REPORT_LINE_CAP),
+			};
+		} finally {
+			inFlight = false;
+		}
+	};
+
+	return {
+		applyBoot: () => run(true),
+		reload: () => run(false),
+	};
+}

package/src/entry/orchestrator.ts

@@ -88,8 +88,7 @@ import {
 	createMarketplaceOfferRegistration,
 	createMiddlewareToolChoiceControl,
 	createSkillsReminderRegistration,
-	type ExtensionHookRoot,
-	installUserHooks,
+	formatRegistrationConflict,
 	type MiddlewareContract,
 	MiddlewareDomainModule,
 	writeMiddlewareDiagnosticToStderr,
@@ -181,6 +180,7 @@ import { createChatLoop } from "../interactive/chat-loop.js";
 import { type RunIo, startInteractive } from "../interactive/index.js";
 import { buildModelReplayAgentMessagesFromTurns } from "../interactive/model-session-replay.js";
 import type { BootOptions } from "./boot-options.js";
+import { createExtensionReloadCoordinator } from "./extension-reload.js";
 import { resolvePanesEnablement } from "./panes-activation.js";
 
 export type { BootOptions, HeadlessSamplingOverrides } from "./boot-options.js";
@@ -200,6 +200,7 @@ import { type AskUserHandler, cancelledAskUserResult } from "../tools/ask-user.j
 import { registerAllTools } from "../tools/bootstrap.js";
 import { isGitRepository, recoverCleanupReadyCompeteGroups } from "../tools/compete-worktrees.js";
 import { createDispatchBackgroundRegistry } from "../tools/dispatch-background.js";
+import { dispatchSchemaCompositionFor } from "../tools/dispatch-schema.js";
 import { createFileMutationObserver, createSkillActivationObserver } from "../tools/observers.js";
 import { createRegistry } from "../tools/registry.js";
 import { sweepExpiredToolOffloads } from "../tools/result-shaping.js";
@@ -1026,7 +1027,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			else resolvedResumeId = latest.id;
 		}
 	}
-	const resumeId = resolvedResumeId ?? process.env.CLIO_CODER_RESUME_SESSION_ID?.trim();
+	const resumeId = resolvedResumeId;
 	let resumedSessionAtBoot = false;
 	if (resumeId && session && headlessResumeFailure === null) {
 		try {
@@ -1038,7 +1039,6 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			else bootStderr(`Clio Coder: failed to resume session ${resumeId}: ${detail}\n`);
 		}
 	}
-	Reflect.deleteProperty(process.env, "CLIO_CODER_RESUME_SESSION_ID");
 	if (headlessResumeFailure !== null) {
 		bootStderr(`clio-coder run: ${headlessResumeFailure}\n`);
 		await termination.shutdown(2);
@@ -1050,6 +1050,20 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// middleware.hookFailed (the interactive warn notice consumes it) and keep
 	// stderr for non-interactive runs, which have no notice subscriber.
 	middleware.setDiagnosticSink((diagnostic) => {
+		if (diagnostic.kind === "registration_conflict") {
+			// Registration bookkeeping has no hook occurrence; the affected owner
+			// today declares user hooks, which never run on on_compaction, so the
+			// payload's hook slot carries that as the "no evaluation" marker.
+			bus.emit(BusChannels.MiddlewareHookFailed, {
+				kind: "registration_conflict",
+				registrationId: diagnostic.registrationId,
+				hook: "on_compaction",
+				at: Date.now(),
+				message: formatRegistrationConflict(diagnostic),
+			});
+			if (!interactive) writeMiddlewareDiagnosticToStderr(diagnostic);
+			return;
+		}
 		bus.emit(BusChannels.MiddlewareHookFailed, {
 			kind: diagnostic.kind,
 			registrationId: diagnostic.registrationId,
@@ -1082,15 +1096,14 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		});
 	}
 
-	// Guardrail policy (tool-call budgets, tool byte caps, dispatch ledger cap)
-	// resolves settings-first with env as emergency override; install the
-	// settings section before any guard registration or tool reads it.
+	// Install guardrail policy before any guard registration or tool reads it.
+	// The effective session view replaces this boot projection below.
 	const resolvedSettings = config?.get() ?? readSettings();
 	configureGuardrails(guardrailValuesFromSettings(resolvedSettings));
 
-	// The run event journal resolves the same way for the same reason: the sink
-	// sits on the dispatch event path, where reading settings.yaml would be both
-	// a cost and a throw site, so the composition root installs the value once.
+	// The journal sink sits on the dispatch event path, where reading settings
+	// would be both a cost and a throw site. The effective session view replaces
+	// this boot projection below.
 	configureRunEventJournal(resolvedSettings.fleet.history.journal);
 
 	// Guard registrations on the middleware contract, in order: loop guard,
@@ -1104,7 +1117,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			safety,
 			bus,
 			turnBlockBudget: INTERACTIVE_LOOP_BLOCK_BUDGET,
-			turnToolCallBudget: readOrchTurnToolCallBudget(),
+			turnToolCallBudget: () => readOrchTurnToolCallBudget(),
 			// Interactive/headless/ACP all share this orchestrator guard: at the
 			// block budget, lock tools for the rest of the turn so the model
 			// answers from what it gathered instead of hard-cancelling a turn that
@@ -1299,24 +1312,26 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// same effect machinery. They register after the guards, so safety stays
 	// authoritative: a hook may add effects (including request block_tool) but
 	// cannot grant a permission safety would deny. Loading is best-effort.
+	// The coordinator is the only writer of the "user-hooks" owner and the only
+	// caller of the extensions reload; it publishes the extension generation
+	// and the hook registrations with two adjacent assignments on one stack
+	// and emits extensions.reloaded only after both. The boot generation is
+	// published here too (the extensions bundle publishes nothing at start),
+	// so no consumer ever sees extension resources paired with hooks from a
+	// different generation. The owner slot is anchored here, so user hooks
+	// keep evaluating after the guards and before the assessors below.
 	const hookReceiptLog = createHookReceiptLog({ persistPath: join(clioStateDir(), "hook-receipts.json") });
-	const extensionHookRoots: ExtensionHookRoot[] = (extensions?.list(process.cwd()) ?? [])
-		.filter((ext) => ext.enabled && ext.effective)
-		.map((ext) => ({ id: ext.id, rootPath: ext.rootPath }));
-	const userHooks = installUserHooks({
-		cwd: process.cwd(),
-		extensions: extensionHookRoots,
-		registerHook: (registration) => middleware.registerHook(registration),
+	const extensionReload = createExtensionReloadCoordinator({
+		extensions,
+		middleware,
+		cwd: () => process.cwd(),
 		recordReceipt: (receipt) => hookReceiptLog.record(receipt),
+		report: (line) => {
+			if (!interactive) process.stderr.write(`${line}\n`);
+		},
+		onCommitted: (event) => bus.emit(BusChannels.ExtensionsReloaded, event),
 	});
-	if (!interactive) {
-		for (const issue of userHooks.fileIssues) {
-			process.stderr.write(`[clio-coder:hooks] ${issue.message}\n`);
-		}
-		for (const issue of userHooks.issues) {
-			process.stderr.write(`[clio-coder:hooks] ${issue.source.sourcePath}#${issue.index}: ${issue.issues.join("; ")}\n`);
-		}
-	}
+	extensionReload.applyBoot();
 	termination.onDrain(() => hookReceiptLog.flush());
 	// Autonomy is hot-reloaded for interactive and headless admissions. ACP
 	// server prompts use the snapshot captured at session/new.
@@ -1494,6 +1509,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		...(panes && mux?.mode !== "none" ? { panes } : {}),
 		getCostCeilingUsd: () => result.getContract<SchedulingContract>("scheduling")?.ceilingUsd() ?? 0,
 		...(config ? { getWorkerRosters: () => config.get().fleet.rosters } : {}),
+		...(config ? { getDispatchSchemaComposition: () => dispatchSchemaCompositionFor(config.get().fleet) } : {}),
 		getSkillLoaderOptions: () => ({
 			trustProjectCompatRoots: config?.get().integrations.projectResources.trustProjectImports === true,
 			disableDiscovery: options.noSkills === true || options.headless?.noSkills === true,
@@ -1518,8 +1534,13 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// view, so the live session reflects them immediately while settings.yaml
 	// (the global default for new sessions) stays untouched until the operator
 	// chooses to save globally.
+	// Overrides are keyed by settings path, the same ids the /settings overlay
+	// commits (`setAtPath` walks the dotted path). The headless `--autonomy`
+	// flag was keyed by the bare word, which wrote a top-level `autonomy` key
+	// nothing reads, so `run --autonomy full-auto` compiled and admitted at
+	// whatever settings.yaml said.
 	const sessionOverrides: SessionOverrides = new Map(
-		options.headless?.autonomy === undefined ? [] : [["autonomy", options.headless.autonomy]],
+		options.headless?.autonomy === undefined ? [] : [["safety.autonomy", options.headless.autonomy]],
 	);
 	// The effective view is derived by deep-cloning the saved snapshot, and it
 	// is read on the tool-admission hot path (every call resolves autonomy
@@ -1534,9 +1555,10 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	let cachedSettingsView: ClioSettings | null = null;
 	const bumpSessionState = (): void => {
 		sessionStateGeneration += 1;
-		// Child-process seams read the effective setting from the environment,
-		// and the session view may override the saved value.
-		setGitCommitAttributionEnabled(getCurrentSettings().integrations.git.commitAttribution);
+		const settings = getCurrentSettings();
+		configureGuardrails(guardrailValuesFromSettings(settings));
+		configureRunEventJournal(settings.fleet.history.journal);
+		setGitCommitAttributionEnabled(settings.integrations.git.commitAttribution);
 	};
 	const getCurrentSettings = (): ClioSettings => {
 		// Recents live in the data dir (core/recent-models.ts), never in
@@ -1562,10 +1584,11 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	};
 	effectiveSettingsForDispatch = getCurrentSettings;
 	bumpSessionState();
-	// The config bundle publishes the saved value on reload; a session-scoped
-	// override must win, so re-derive from the session view after it.
-	const unsubscribeCommitAttributionSync = bus.on(BusChannels.ConfigHotReload, () => bumpSessionState());
-	termination.onDrain(() => unsubscribeCommitAttributionSync());
+	// The config bundle publishes saved values on reload; session-scoped
+	// overrides must win, so re-derive every process-local projection from the
+	// effective session view after it.
+	const unsubscribeSettingsProjectionSync = bus.on(BusChannels.ConfigHotReload, () => bumpSessionState());
+	termination.onDrain(() => unsubscribeSettingsProjectionSync());
 	const getTaskMemorySeedOffer = (): { source: string; count: number } | null => {
 		return taskMemoryHandoffSeedOffer(process.cwd(), getCurrentSettings().context.memory.enabled);
 	};
@@ -1892,7 +1915,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		await chat.whenSettled();
 	});
 
-	// A boot-time resume (CLIO_CODER_RESUME_SESSION_ID) must replay the resumed
+	// A boot-time resume (headless --session or --continue) must replay the resumed
 	// session into the chat loop the same way the interactive /resume overlay
 	// does. Without this, the first submit runs with an empty provider context
 	// and parents its user turn at null, appending a second root that silently
@@ -2117,6 +2140,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		...(initialNotices.length > 0 ? { initialNotices } : {}),
 		...(resources ? { resources } : {}),
 		...(extensions ? { extensions } : {}),
+		reloadExtensions: () => extensionReload.reload(),
 		...(interop ? { interop } : {}),
 		...(share ? { share } : {}),
 		...(mux ? { mux } : {}),

package/src/interactive/application-controller.ts

@@ -18,11 +18,12 @@ const CLOSED_ACTION_ORDER = [
 	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
-const GLOBAL_ACTION_ORDER = [
+export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.status.toggle",
 	"clio-coder.thinking.cycle",
 	"clio-coder.session.tree",
 	"clio-coder.dispatchBoard.toggle",
+	"clio-coder.files.toggle",
 	"clio-coder.tasks.open",
 	"clio-coder.decisions.open",
 	"clio-coder.dispatch.background",

package/src/interactive/bus-notices.ts

@@ -72,7 +72,7 @@ function isSafetyBlockedPayload(value: unknown): value is SafetyBlockedPayload {
 function isMiddlewareHookFailedPayload(value: unknown): value is MiddlewareHookFailedPayload {
 	if (!value || typeof value !== "object") return false;
 	const p = value as Record<string, unknown>;
-	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded") return false;
+	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded" && p.kind !== "registration_conflict") return false;
 	if (typeof p.registrationId !== "string" || p.registrationId.length === 0) return false;
 	if (typeof p.hook !== "string" || p.hook.length === 0) return false;
 	if (p.message !== undefined && typeof p.message !== "string") return false;
@@ -142,6 +142,13 @@ function middlewareHookFailedNotice(
 	options: MiddlewareHookFailedNoticeOptions = {},
 ): BusNotice | null {
 	if (!isMiddlewareHookFailedPayload(payload)) return null;
+	if (payload.kind === "registration_conflict") {
+		const detail =
+			payload.message !== undefined && payload.message.length > 0
+				? payload.message
+				: `registration '${payload.registrationId}' conflicts with an existing id`;
+		return { level: "warn", text: `[middleware] ${detail}` };
+	}
 	if (payload.kind === "hook_failed") {
 		const detail = payload.message !== undefined && payload.message.length > 0 ? `: ${payload.message}` : "";
 		return {

package/src/interactive/chat-loop-messages.ts

@@ -21,12 +21,13 @@ import {
 } from "../core/response-model-id.js";
 import type { PendingSkillRequest, PendingSkillToolPolicy, SkillDeclaredToolPolicy } from "../core/skill-activation.js";
 import { ToolNames } from "../core/tool-names.js";
-import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import { sha256 } from "../domains/prompts/hash.js";
 import { toContextOverflowError } from "../domains/providers/errors.js";
 import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
 import { ceilChars, extractReasoningTokens } from "../domains/session/context-accounting.js";
 import type { AgentMessage } from "../engine/types.js";
 import type { AskUserToolPolicy } from "../tools/registry.js";
+import { attachedToolSchemaBytes, attachedToolSchemasFromState } from "./prompt-cache-identity.js";
 
 /** Minimal structural view of the engine agent used by state-inspection helpers. */
 export interface AgentStateView {
@@ -291,18 +292,7 @@ export function pendingSkillRequestPreamble(requests: ReadonlyArray<PendingSkill
  * tool-surface change.
  */
 export function toolSignatureFromState(tools: ReadonlyArray<unknown>): string {
-	const schemas: Array<{ name: string; description: string; parameters: unknown }> = [];
-	for (const tool of tools) {
-		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
-		const record = tool as Record<string, unknown>;
-		schemas.push({
-			name: typeof record.name === "string" ? record.name : "",
-			description: typeof record.description === "string" ? record.description : "",
-			parameters: record.parameters ?? null,
-		});
-	}
-	schemas.sort((a, b) => a.name.localeCompare(b.name));
-	return sha256(canonicalJson(schemas));
+	return sha256(attachedToolSchemaBytes(attachedToolSchemasFromState(tools)));
 }
 
 /**

package/src/interactive/chat-loop.ts

@@ -648,7 +648,9 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().chat.retry);
 
 	const currentToolInvokeOptions = (): Partial<ToolInvokeOptions> => {
-		const options: Partial<ToolInvokeOptions> = {};
+		const options: Partial<ToolInvokeOptions> = {
+			toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes,
+		};
 		const sessionId = deps.session?.current()?.id ?? null;
 		if (sessionId) options.sessionId = sessionId;
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -764,6 +766,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		deps.bus?.on(BusChannels.ConfigHotReload, () => {
 			context.invalidateSessionPromptCache();
 		}) ?? null;
+	// A committed extension generation with new content can change the skill
+	// and prompt inputs the session prompt compiles from; same invalidation.
+	const unsubscribeExtensionsReload =
+		deps.bus?.on(BusChannels.ExtensionsReloaded, (payload) => {
+			if (payload.changed) context.invalidateSessionPromptCache();
+		}) ?? null;
 
 	const unsubscribeSynthesisLock =
 		deps.bus?.on(BusChannels.LoopBlocked, (payload) => {
@@ -1417,6 +1425,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		dispose(): void {
 			unsubscribeConfigReload?.();
+			unsubscribeExtensionsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();