@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/domains/lifecycle/migrations/index.ts

@@ -72,6 +72,10 @@ export function listMigrations(): ReadonlyArray<Migration> {
 	return REGISTRY;
 }
 
+export function readMigrationManifest(stateDir: string): MigrationManifest {
+	return readManifest(manifestPath(stateDir));
+}
+
 function manifestPath(stateDir: string): string {
 	return join(stateDir, "migrations.json");
 }

package/src/domains/memory/task-memory-policy.ts

@@ -29,11 +29,16 @@ export interface TaskMemoryTrajectoryStep {
 	resultDigestProvenance: ToolResultDigestProvenance;
 }
 
+/** Admission changed while a client prepared; no inference request was sent. */
+export class TaskMemoryEndpointBusyError extends Error {}
+
 export interface TaskMemoryModelRequest {
 	systemPrompt: string;
 	userPrompt: string;
 	maxTokens: number;
 	signal: AbortSignal;
+	/** Known usage may arrive even when completion rejects or the policy has been canceled. */
+	onUsage?: (usage: TaskMemoryStepUsage) => void;
 }
 
 /**
@@ -116,10 +121,8 @@ export type TaskMemoryPolicyReason =
 	 */
 	| "timed_out"
 	/**
-	 * The step would have run on the endpoint the chat target is streaming
-	 * against, so it never started. A single-slot local server queues the memory
-	 * call behind the operator's own turn, or evicts the resident model to serve
-	 * it; neither is a cost a background step may impose.
+	 * Known occupancy exhausts the endpoint request capacity, so no step starts.
+	 * A shared gateway URL alone does not establish a one-slot capacity bound.
 	 */
 	| "endpoint_busy"
 	/** The model client threw: unreachable route, auth failure, malformed request. */
@@ -139,7 +142,9 @@ export type TaskMemoryPolicyReason =
 	/** Rules tier: the turn ended with no repeated failure worth reporting. */
 	| "no_repeated_failure"
 	/** Rules tier: compaction reactivation found no knowledge entries to restore. */
-	| "bank_empty";
+	| "bank_empty"
+	/** The owning session/branch generation was invalidated. */
+	| "scope_changed";
 
 /**
  * The model's own words for one step, handed to an observer before they are
@@ -161,6 +166,12 @@ export interface TaskMemoryEnvelope {
 }
 
 export interface TaskMemoryPolicyInput {
+	/** Content authority, checked after inference and before any bank write. */
+	isCurrent?: () => boolean;
+	/** Cancellation releases policy bookkeeping even if the transport ignores abort. */
+	signal?: AbortSignal;
+	/** Reports actual provider usage, including responses arriving after cancellation/deadline. */
+	onStepUsage?: (usage: TaskMemoryStepUsage) => void;
 	task: string;
 	trajectory: ReadonlyArray<TaskMemoryTrajectoryStep>;
 	deterministicTrigger: boolean;
@@ -246,10 +257,31 @@ export async function runTaskMemoryPolicy(
 	const timeoutMs = positiveInteger(input.timeoutMs, TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS);
 	const timeoutMarker = Symbol("task-memory-timeout");
 	let timer: NodeJS.Timeout | undefined;
+	const cancelledMarker = Symbol("task-memory-cancelled");
+	let cancel: () => void = () => {};
+	const cancelled = new Promise<typeof cancelledMarker>((resolve) => {
+		cancel = () => {
+			controller.abort();
+			resolve(cancelledMarker);
+		};
+	});
+	input.signal?.addEventListener("abort", cancel, { once: true });
+	if (input.signal?.aborted) cancel();
 	let userPrompt = "";
 	let rawResponse = "";
 	let clientError: string | null = null;
 	let stepUsage: TaskMemoryStepUsage | null = null;
+	let usageReported = false;
+	const reportUsage = (usage: TaskMemoryStepUsage): void => {
+		if (usageReported) return;
+		usageReported = true;
+		stepUsage = usage;
+		try {
+			input.onStepUsage?.(usage);
+		} catch {
+			/* Accounting cannot steer content. */
+		}
+	};
 	// Every exit reports through here so the trace sees the same envelope the
 	// telemetry row summarizes, including the paths that used to throw away both.
 	const settle = (
@@ -263,54 +295,64 @@ export async function runTaskMemoryPolicy(
 			bankOperations: parts.bankOperations ?? 0,
 			droppedOperations: parts.droppedOperations ?? 0,
 			reminder: parts.reminder ?? null,
-			inputTokens: parts.inputTokens ?? 0,
-			outputTokens: parts.outputTokens ?? 0,
+			inputTokens: parts.inputTokens ?? stepUsage?.input ?? 0,
+			outputTokens: parts.outputTokens ?? stepUsage?.output ?? 0,
 			usage: stepUsage,
 		};
 		try {
-			input.onEnvelope?.({
-				systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
-				userPrompt,
-				response: rawResponse,
-				decision,
-				reason,
-				bankOperations: result.bankOperations,
-				droppedOperations: result.droppedOperations,
-				reminder: result.reminder,
-				error: clientError,
-			});
+			if (input.isCurrent?.() !== false)
+				input.onEnvelope?.({
+					systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
+					userPrompt,
+					response: rawResponse,
+					decision,
+					reason,
+					bankOperations: result.bankOperations,
+					droppedOperations: result.droppedOperations,
+					reminder: result.reminder,
+					error: clientError,
+				});
 		} catch {
 			// A failing observer is an operator's diagnostic, never the policy's problem.
 		}
 		return result;
 	};
 	try {
+		if (input.signal?.aborted || input.isCurrent?.() === false) return settle("silent", "scope_changed");
 		userPrompt = buildMemoryInterventionUserPrompt({
 			task: input.task.slice(0, TASK_PROMPT_MAX_CHARS),
 			bank: bank.render(input.maxTokens),
 			trajectory: renderTrajectory(input.trajectory),
 		});
-		const completion = client.complete({
-			systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
-			userPrompt,
-			maxTokens: positiveInteger(input.modelMaxTokens, input.maxTokens),
-			signal: controller.signal,
-		});
+		const completion = client
+			.complete({
+				systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
+				userPrompt,
+				maxTokens: positiveInteger(input.modelMaxTokens, input.maxTokens),
+				signal: controller.signal,
+				onUsage: reportUsage,
+			})
+			.then((response) => {
+				if (response.usage !== undefined) reportUsage(response.usage);
+				return response;
+			});
 		const timeout = new Promise<typeof timeoutMarker>((resolve) => {
 			timer = setTimeout(() => resolve(timeoutMarker), timeoutMs);
 		});
-		const response = await Promise.race([completion, timeout]);
+		const response = await Promise.race([completion, timeout, cancelled]);
+		if (response === cancelledMarker) return settle("silent", "scope_changed");
 		if (response === timeoutMarker) {
 			controller.abort();
 			void completion.catch(() => undefined);
 			return settle("timeout", "deadline");
 		}
 		rawResponse = typeof response.text === "string" ? response.text : "";
-		stepUsage = response.usage ?? null;
+		stepUsage = response.usage ?? stepUsage;
 		const usage = {
 			inputTokens: nonNegativeInteger(response.inputTokens ?? stepUsage?.input),
 			outputTokens: nonNegativeInteger(response.outputTokens ?? stepUsage?.output),
 		};
+		if (input.signal?.aborted || input.isCurrent?.() === false) return settle("silent", "scope_changed", usage);
 		const read = readPolicyStep(rawResponse);
 		if (!read.ok) return settle("malformed", read.reason, { ...usage, droppedOperations: read.dropped });
 		const operations = resolveOperations(bank, read.step.operations);
@@ -336,6 +378,7 @@ export async function runTaskMemoryPolicy(
 		bank.recordInjection(citedIds);
 		return settle("injected", "intervened", { ...counts, reminder });
 	} catch (error) {
+		if (error instanceof TaskMemoryEndpointBusyError) return settle("silent", "endpoint_busy");
 		clientError = errorMessage(error);
 		// A transport that aborted at its own deadline spent the whole budget and
 		// produced nothing. Reporting it as silence made a step that held a local
@@ -345,6 +388,7 @@ export async function runTaskMemoryPolicy(
 		return settle("silent", "client_error");
 	} finally {
 		if (timer !== undefined) clearTimeout(timer);
+		input.signal?.removeEventListener("abort", cancel);
 	}
 }
 

package/src/domains/memory/task-memory-telemetry.ts

@@ -229,6 +229,7 @@ const REASONS = new Set<TaskMemoryPolicyReason>([
 	"llm_timeout_backoff",
 	"no_repeated_failure",
 	"bank_empty",
+	"scope_changed",
 ]);
 
 function entryDelta(

package/src/domains/middleware/index.ts

@@ -88,7 +88,6 @@ export {
 	createMarketplaceOfferRegistration,
 	MARKETPLACE_OFFER_REGISTRATION_ID,
 	type MarketplaceOfferDeps,
-	marketplaceAutoInstallReminder,
 	marketplaceOfferReminder,
 } from "./marketplace-offer.js";
 export {

package/src/domains/middleware/marketplace-offer.ts

@@ -15,7 +15,6 @@ import {
 	readPromotionDeclines,
 	recordPromotionNeverDecline,
 } from "../resources/skills/promotion.js";
-import type { AutonomyLevel } from "../safety/autonomy.js";
 import type { MiddlewareHookRegistration } from "./runtime.js";
 import { isSubstantiveUserTurn } from "./skills-reminder.js";
 import { type MiddlewareEffect, type MiddlewareHookInput, metadataNumber } from "./types.js";
@@ -34,9 +33,8 @@ import { type MiddlewareEffect, type MiddlewareHookInput, metadataNumber } from
  * becomes a nag. Detection is the local lexical matcher in
  * resources/skills/promotion.ts — no request text leaves the machine.
  *
- * At full-auto the offer collapses into an autonomous install, but ONLY from
- * Clio's own marketplace: every promotion-flow install (consented or
- * autonomous) passes `assertPromotionInstallSource`, the hard runtime gate
+ * Every autonomy level requires an explicit operator answer. Each consented
+ * promotion-flow install passes `assertPromotionInstallSource`, the hard runtime gate
  * that rejects public registries in code rather than prompt text.
  *
  * Coordinator-only by wiring: this registration is created in the
@@ -48,19 +46,19 @@ export const MARKETPLACE_OFFER_REGISTRATION_ID = "observer.marketplace-offer";
 
 export interface MarketplaceOfferInstallResult {
 	path: string;
-	/** The source the skill was fetched from; surfaced so an autonomous install stays auditable. */
+	/** The source the skill was fetched from; retained with the installation result for provenance. */
 	sourceUrl: string;
 	/** Normalized content hash of what was written; the integrity record the consent overlay would have shown. */
 	installedHash: string;
 }
 
 export interface MarketplaceOfferDeps {
+	/** Whether the session can render ask_user. Defaults to interactive offers. */
+	interactive?: boolean;
 	/** Installed skill names the matcher must exclude. */
 	listInstalledSkillNames(): ReadonlyArray<string>;
 	/** The local marketplace lookup (catalog + index); already local-only. */
 	listMarketplaceEntries(): ReadonlyArray<MarketplaceSkill>;
-	/** The session's effective autonomy at evaluation time. */
-	getAutonomy(): AutonomyLevel;
 	/** Perform the install; the registration gates the source before calling. */
 	installEntry(entry: MarketplaceSkill, scope: "user" | "project"): MarketplaceOfferInstallResult;
 	/** Decline persistence; defaults to the promotion module's config-dir store. Keyed by name+version. */
@@ -84,10 +82,18 @@ export function offerBindingTag(offerTag: string): string {
 	return `[clio-install:${offerTag}]`;
 }
 
+function boundedDescription(text: string): string {
+	return text
+		.replace(/\[[^[\]]*\]/gu, " ")
+		.replace(/\s+/gu, " ")
+		.trim()
+		.slice(0, 200);
+}
+
 export function marketplaceOfferReminder(entry: MarketplaceSkill, offerTag: string): string {
 	return (
 		`[Marketplace] This request may need expertise no installed skill covers. The local marketplace has ` +
-		`"${entry.name}" (not installed): ${entry.description} ` +
+		`"${entry.name}" (not installed): ${boundedDescription(entry.description)} ` +
 		`First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit ` +
 		`and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") ` +
 		`whether to install ${entry.name}, offering exactly these options in this order: ` +
@@ -100,19 +106,6 @@ export function marketplaceOfferReminder(entry: MarketplaceSkill, offerTag: stri
 	);
 }
 
-export function marketplaceAutoInstallReminder(entry: MarketplaceSkill, result: MarketplaceOfferInstallResult): string {
-	// Full-auto skips the operator's yes/no, never the integrity record. The
-	// consent overlay states the source and the SHA-256 of what it writes; the
-	// autonomous path computes the same hash and must surface it here, so an
-	// install nobody was asked about is still traceable to its source and bytes.
-	return (
-		`[Marketplace] Installed skill "${entry.name}" from Clio's own local marketplace (full-auto) to ${result.path}. ` +
-		`Source ${result.sourceUrl}, sha256 ${result.installedHash}. ${entry.description} ` +
-		`It is installed but not active — activation stays operator-gated. If it fits this task, ` +
-		`suggest /skill ${entry.name} to the operator; never load it yourself.`
-	);
-}
-
 interface AnswerLike {
 	question: string;
 	answer: string;
@@ -316,20 +309,14 @@ export function createMarketplaceOfferRegistration(deps: MarketplaceOfferDeps):
 			const match = bestMatch(input.text ?? "");
 			if (!match) return NO_EFFECTS;
 			offeredNames.add(match.entry.name);
-			if (deps.getAutonomy() === "full-auto") {
-				try {
-					const result = installGated(match.entry, "project");
-					return [
-						{
-							kind: "inject_reminder",
-							severity: "info",
-							message: marketplaceAutoInstallReminder(match.entry, result),
-						},
-					];
-				} catch {
-					// Gate refusal or install failure: fall back to the consent offer
-					// so the operator still hears about the match.
-				}
+			if (deps.interactive === false) {
+				return [
+					{
+						kind: "inject_reminder",
+						severity: "info",
+						message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder skills install ${match.entry.name}.`,
+					},
+				];
 			}
 			const tag = newOfferTag();
 			pendingOffer = { entry: match.entry, tag };

package/src/domains/middleware/memory-intervention.ts

@@ -78,13 +78,13 @@ export interface MemoryInterventionDeps {
 	everyNTools?: number;
 	/** Lazily resolves the explicitly configured background role. Null means rules-only. */
 	getModelClient?: () => TaskMemoryModelClient | null;
+	/** One alternative route after a client error; never used after timeout, cancellation or model output. */
+	getFallbackModelClient?: () => TaskMemoryModelClient | null;
 	/** Completion budget derived from the resolved background model capability. */
 	getModelMaxTokens?: (configuredMaxTokens: number) => number;
 	/**
-	 * True when the background target's inference endpoint is already serving the
-	 * chat target's stream. A memory step then either queues behind the operator's
-	 * own turn on a single-slot server or makes the server evict the resident
-	 * model to serve it, so the boundary is skipped and the skip is recorded.
+	 * True when known endpoint occupancy exhausts the resolved capacity bound.
+	 * A shared gateway URL alone is not evidence that its request slots are full.
 	 */
 	backgroundEndpointBusy?: () => boolean;
 	/**
@@ -92,6 +92,8 @@ export interface MemoryInterventionDeps {
 	 * routes it to the cost ledger; the middleware never prices anything.
 	 */
 	onStepUsage?: (usage: TaskMemoryStepUsage) => void;
+	/** Capture immutable accounting ownership at launch, before awaiting inference. */
+	captureStepUsage?: () => (usage: TaskMemoryStepUsage, isCurrent: boolean) => void;
 	/**
 	 * Bank entries an llm-tier reminder cited when it reached the operator. The
 	 * composition root proposes them into the durable memory store, which is what
@@ -139,6 +141,10 @@ export interface MemoryPromptedStepResult extends TaskMemoryPolicyResult {
 }
 
 export interface MemoryInterventionRegistration extends MiddlewareHookRegistration {
+	/** Invalidate pending content and discard all transient session/branch state. */
+	reset(): void;
+	/** Invalidate immediately without waiting for the model; refuse further work. */
+	dispose(): void;
 	evaluateAsync(
 		input: MiddlewareHookInput,
 		context?: MiddlewareHookEvaluationContext,
@@ -154,10 +160,9 @@ export interface MemoryInterventionRegistration extends MiddlewareHookRegistrati
 	/** True while a detached background memory step is still running. */
 	stepInFlight(): boolean;
 	/**
-	 * Resolves once no detached memory step is outstanding. Teardown does not
-	 * await it: a step runs tens of seconds on a local route and shutdown cannot
-	 * wait that long, which is why a surface with no next turn declines to start
-	 * one at all rather than starting one it will abandon.
+	 * Resolves when this generation's detached policy settles. Reset/shutdown
+	 * release the policy immediately; an abort-ignoring transport can still
+	 * finish later, with authority only to report its originating usage.
 	 */
 	whenIdle(): Promise<void>;
 }
@@ -167,6 +172,10 @@ export interface MemoryInterventionRegistration extends MiddlewareHookRegistrati
  * emits only cited, advisory reminders through the existing visible channel.
  */
 export function createMemoryInterventionRegistration(deps: MemoryInterventionDeps): MemoryInterventionRegistration {
+	let generation = 0;
+	let generationController = new AbortController();
+	let observedSessionId: string | undefined;
+	let disposed = false;
 	const pending = new Map<string, PendingToolStep>();
 	const trajectory: TrajectoryStep[] = [];
 	const failures = new Map<string, FailedAttempt>();
@@ -194,11 +203,17 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 	let consecutiveLlmTimeouts = 0;
 
 	return {
+		reset,
+		dispose(): void {
+			disposed = true;
+			reset();
+		},
 		id: MEMORY_INTERVENTION_REGISTRATION_ID,
 		description: "maintain bounded task execution memory and selectively remind after repeated failures or compaction",
 		hooks: ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"],
 		evaluate(input): ReadonlyArray<MiddlewareEffect> {
-			if (!settings().enabled) return NO_EFFECTS;
+			observeSession(input);
+			if (disposed || !settings().enabled) return NO_EFFECTS;
 			try {
 				switch (input.hook) {
 					case "before_tool":
@@ -274,7 +289,8 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		 * would have been buffered anyway.
 		 */
 		async evaluateAsync(input, context): Promise<ReadonlyArray<MiddlewareEffect>> {
-			if (!settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS;
+			observeSession(input);
+			if (disposed || !settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS;
 			const boundary = input.turnId ?? input.metadata?.userTurnId?.toString() ?? `tool-step:${toolStep}`;
 			if (boundary === lastPromptedBoundary) return NO_EFFECTS;
 			// One row rather than none, so a headless operator reading the log sees
@@ -316,6 +332,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 				) ??
 					false);
 			rulesInjectedSincePromptedStep = false;
+			const stepGeneration = generation;
 			promptedStepInFlight = true;
 			outstandingStep = runPromptedStep({
 				deterministicTrigger: triggers.some((trigger) => trigger !== "interval"),
@@ -323,6 +340,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 				triggerReasons: triggers,
 			})
 				.then((result) => {
+					if (stepGeneration !== generation || disposed) return;
 					// A rules-only reminder can win the visible boundary while the optional
 					// background route resolves to null. Preserve the operator-visible
 					// injected outcome instead of overwriting it with that no-client silence.
@@ -336,13 +354,13 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 					// covers a throwing delivery sink, which must not surface anywhere.
 				})
 				.finally(() => {
-					promptedStepInFlight = false;
+					if (stepGeneration === generation) promptedStepInFlight = false;
 				});
 			return NO_EFFECTS;
 		},
 		runPromptedStep,
 		signalLoop(): void {
-			if (settings().enabled) pendingTriggers.add("loop_signal");
+			if (!disposed && settings().enabled) pendingTriggers.add("loop_signal");
 		},
 		lastDecision: () => lastDecision,
 		recentActivity: () => [...activity],
@@ -350,6 +368,43 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		whenIdle: () => outstandingStep,
 	};
 
+	function observeSession(input: MiddlewareHookInput): void {
+		if (input.sessionId === undefined) return;
+		if (observedSessionId !== undefined && observedSessionId !== input.sessionId) reset();
+		observedSessionId = input.sessionId;
+	}
+
+	function reset(): void {
+		generation += 1;
+		generationController.abort();
+		generationController = new AbortController();
+		deps.bank.clear();
+		pending.clear();
+		trajectory.length = 0;
+		failures.clear();
+		toolStep = 0;
+		lastTurnEndStep = 0;
+		reactivateAfterCompaction = false;
+		lastInjectedOperationFingerprint = null;
+		currentTask = "(current task unavailable)";
+		toolsSinceMemoryStep = 0;
+		consecutiveErrors = 0;
+		lastPromptedBoundary = null;
+		lastInjectedMessage = null;
+		lastDecision = null;
+		pendingTriggers.clear();
+		activity.length = 0;
+		annotatedThisTurn.clear();
+		telemetryBankSnapshot = deps.bank.snapshot();
+		promptedStepInFlight = false;
+		promptedStepTier = "rules";
+		outstandingStep = Promise.resolve();
+		rulesInjectedSincePromptedStep = false;
+		annotatedSinceTurnEnd = false;
+		consecutiveLlmTimeouts = 0;
+		observedSessionId = undefined;
+	}
+
 	function settings(): MemoryInterventionSettings {
 		const live = deps.getSettings?.();
 		return {
@@ -377,12 +432,16 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 			effects: NO_EFFECTS,
 		});
 		const live = settings();
-		if (!live.enabled) {
+		const stepGeneration = generation;
+		const isCurrent = () => !disposed && stepGeneration === generation;
+		const usageSink = deps.captureStepUsage?.();
+		if (disposed || !live.enabled) {
 			const result = silent("no_client");
 			lastDecision = result.decision;
 			return result;
 		}
 		const started = process.hrtime.bigint();
+		let attemptStarted = started;
 		const triggers = input.triggerReasons?.length ? input.triggerReasons : ["manual" as const];
 		let tier: TaskMemoryTelemetryTier = "rules";
 		promptedStepTier = tier;
@@ -407,17 +466,58 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 				} else {
 					tier = "llm";
 					promptedStepTier = tier;
-					promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
-						task: input.task?.trim() || currentTask,
-						trajectory: [...trajectory],
-						deterministicTrigger: input.deterministicTrigger,
-						maxTokens: live.maxTokens,
-						modelMaxTokens: positiveInteger(deps.getModelMaxTokens?.(live.maxTokens), live.maxTokens),
-						...(input.suppressIntervention === undefined ? {} : { suppressIntervention: input.suppressIntervention }),
-						previousReminder: lastInjectedMessage,
-						timeoutMs: live.timeoutMs,
-						...(deps.onEnvelope === undefined ? {} : { onEnvelope: deps.onEnvelope }),
-					});
+					const runClient = (selected: TaskMemoryModelClient, timeoutMs: number) =>
+						runTaskMemoryPolicy(deps.bank, selected, {
+							isCurrent,
+							signal: generationController.signal,
+							onStepUsage: (usage) => {
+								if (usageSink) usageSink(usage, isCurrent());
+								else deps.onStepUsage?.(usage);
+							},
+							task: input.task?.trim() || currentTask,
+							trajectory: [...trajectory],
+							deterministicTrigger: input.deterministicTrigger,
+							maxTokens: live.maxTokens,
+							modelMaxTokens: positiveInteger(deps.getModelMaxTokens?.(live.maxTokens), live.maxTokens),
+							...(input.suppressIntervention === undefined ? {} : { suppressIntervention: input.suppressIntervention }),
+							previousReminder: lastInjectedMessage,
+							timeoutMs,
+							...(deps.onEnvelope === undefined ? {} : { onEnvelope: deps.onEnvelope }),
+						});
+					const remainingMs = () => Math.floor(live.timeoutMs - Number(process.hrtime.bigint() - started) / 1_000_000);
+					const initialTimeoutMs = remainingMs();
+					promptedResult =
+						initialTimeoutMs <= 0
+							? { ...silent("deadline"), decision: "timeout" }
+							: await runClient(client, initialTimeoutMs);
+					if (promptedResult.reason === "client_error" && isCurrent() && remainingMs() > 0) {
+						let fallback: TaskMemoryModelClient | null = null;
+						let fallbackReady = false;
+						try {
+							fallback = deps.getFallbackModelClient?.() ?? null;
+							fallbackReady = fallback !== null && deps.backgroundEndpointBusy?.() !== true;
+						} catch {
+							/* Fail closed and preserve the original call if routing or capacity is unreadable. */
+						}
+						const fallbackTimeoutMs = remainingMs();
+						if (fallback !== null && fallbackReady && isCurrent() && fallbackTimeoutMs > 0) {
+							// Each attempted call keeps its own telemetry and origin usage.
+							// The returned policy result describes the final attempt only.
+							emitTelemetry(
+								triggers,
+								tier,
+								promptedResult.decision,
+								promptedResult.reason,
+								0,
+								promptedResult.inputTokens,
+								promptedResult.outputTokens,
+								started,
+								{ bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations },
+							);
+							attemptStarted = process.hrtime.bigint();
+							promptedResult = await runClient(fallback, fallbackTimeoutMs);
+						}
+					}
 				}
 			}
 		} catch (error) {
@@ -436,16 +536,11 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 				error: error instanceof Error ? error.message : "resolving the background model client failed",
 			});
 		}
+		if (!isCurrent()) return { ...promptedResult, reminder: null, effects: NO_EFFECTS };
+		if (promptedResult.reason === "endpoint_busy") telemetryDecision = "dropped";
 		if (tier === "llm" && promptedResult.decision === "timeout") consecutiveLlmTimeouts += 1;
 		else if (tier === "llm" && telemetryDecision !== "dropped") consecutiveLlmTimeouts = 0;
 		lastDecision = promptedResult.decision;
-		if (promptedResult.usage !== null) {
-			try {
-				deps.onStepUsage?.(promptedResult.usage);
-			} catch {
-				// Accounting is bookkeeping. A failing sink never changes memory behavior.
-			}
-		}
 		if (promptedResult.decision === "injected") reportInjectedEntries(promptedResult.reminder);
 		emitTelemetry(
 			triggers,
@@ -455,7 +550,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 			citedEntryCount(promptedResult.reminder),
 			promptedResult.inputTokens,
 			promptedResult.outputTokens,
-			started,
+			attemptStarted,
 			{ bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations },
 		);
 		return {

package/src/domains/middleware/memory-step-endpoint.ts

@@ -50,8 +50,9 @@ export function announceMemoryStepEndpoint<Request, Response>(
 	const { bus, endpointKey, targetId } = deps;
 	if (endpointKey === null) return complete;
 	return async (request: Request): Promise<Response> => {
-		// `runPromptedStep` performs its busy check before it invokes `complete`,
-		// so this registration counts the outgoing request without self-refusing.
+		// The production client rechecks capacity after asynchronous preparation,
+		// immediately before calling this wrapper. Register synchronously so no
+		// local foreground launch can interleave between that check and this hold.
 		const releaseEndpointSlot = registerForegroundStream(endpointKey);
 		try {
 			return await complete(request);

package/src/domains/middleware/runtime.ts

@@ -110,9 +110,13 @@ export type MiddlewareDiagnostic =
 export type MiddlewareDiagnosticSink = (diagnostic: MiddlewareDiagnostic) => void;
 
 /**
- * Default diagnostic sink. stderr-only for now; once the typed bus lands a
- * `middleware.hookFailed` channel, the composition root supplies a sink that
- * also emits there.
+ * Default diagnostic sink, and the one the domain loader constructs the
+ * bundle with. It writes to stderr only. The composition root
+ * (src/entry/orchestrator.ts) replaces it through setDiagnosticSink with a
+ * sink that publishes every diagnostic on the typed bus as
+ * `middleware.hookFailed`, which the interactive warn notice consumes, and
+ * that still calls this writer for non-interactive runs, which have no
+ * notice subscriber.
  */
 export function writeMiddlewareDiagnosticToStderr(diagnostic: MiddlewareDiagnostic): void {
 	if (diagnostic.kind === "hook_failed") {