ryco-cli 0.1.29 → 0.1.31

package/dist/{ClaudeDriver-r0lJ9vmE.cjs → ClaudeDriver-DCrqouOR.cjs}

@@ -1,23 +1,22 @@
 #!/usr/bin/env node
 
-const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
-const require_src = require("./src-BzVJd3Me.cjs");
-const require_Metrics = require("./Metrics-Bf96NJ4j.cjs");
-const require_git = require("./git-Dn5wrgFY.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-HbSU0i7K.cjs");
+const require_Metrics = require("./Metrics-DjRPLE98.cjs");
+const require_src = require("./src-FmeCeBJ9.cjs");
 const require_bin = require("./bin.cjs");
 const require_runtimeSession = require("./runtimeSession-Bj0OUcNJ.cjs");
 const require_ProviderDriver = require("./ProviderDriver--rNeAi3B.cjs");
-const require_SideQuestionIsolation = require("./SideQuestionIsolation-CMPkCUP0.cjs");
+const require_SideQuestionIsolation = require("./SideQuestionIsolation-BPC-Bxsz.cjs");
 const require_sourceControlContextFormatter = require("./sourceControlContextFormatter-BDZqn-4T.cjs");
 const require_ProjectCustomSystemPrompt = require("./ProjectCustomSystemPrompt-B8SUlNGa.cjs");
-const require_makeManagedServerProvider = require("./makeManagedServerProvider-CUwxc0Pn.cjs");
+const require_makeManagedServerProvider = require("./makeManagedServerProvider-B5tP7tvg.cjs");
 let effect = require("effect");
-let effect_unstable_http = require("effect/unstable/http");
+let node_child_process = require("node:child_process");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let effect_unstable_http = require("effect/unstable/http");
 let node_os = require("node:os");
 node_os = require_rolldown_runtime.__toESM(node_os, 1);
-let node_child_process = require("node:child_process");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises, 1);
 let effect_unstable_process = require("effect/unstable/process");
@@ -28,7 +27,8 @@ const PROVIDER$1 = require_src.ProviderDriverKind.make("claudeAgent");
 const CLAUDE_PRESENTATION = {
 	displayName: "Claude",
 	showInteractionModeToggle: true,
-	supportsAskMode: true
+	supportsAskMode: true,
+	supportsTurnSteering: true
 };
 function getClaudeModelCapabilities(model) {
 	const capabilities = require_bin.getClaudeCatalogModelCapabilities(require_bin.getActiveClaudeModelCatalog(), model);
@@ -488,7 +488,7 @@ const makeClaudeTextGeneration = effect.Effect.fn("makeClaudeTextGeneration")(fu
 		return {
 			subject: require_bin.sanitizeCommitSubject(generated.subject),
 			body: generated.body.trim(),
-			..."branch" in generated && typeof generated.branch === "string" ? { branch: require_git.sanitizeFeatureBranchName(generated.branch) } : {}
+			..."branch" in generated && typeof generated.branch === "string" ? { branch: require_bin.sanitizeFeatureBranchName(generated.branch) } : {}
 		};
 	});
 	const generatePrContent = effect.Effect.fn("ClaudeTextGeneration.generatePrContent")(function* (input) {
@@ -523,7 +523,7 @@ const makeClaudeTextGeneration = effect.Effect.fn("makeClaudeTextGeneration")(fu
 			outputSchemaJson: outputSchema,
 			modelSelection: input.modelSelection
 		});
-		return { branch: require_git.sanitizeBranchFragment(generated.branch) };
+		return { branch: require_bin.sanitizeBranchFragment(generated.branch) };
 	});
 	const generateThreadTitle = effect.Effect.fn("ClaudeTextGeneration.generateThreadTitle")(function* (input) {
 		const { prompt, outputSchema } = require_bin.buildThreadTitlePrompt({
@@ -629,6 +629,7 @@ function observeClaudeCache(input) {
 		providerInstanceId: input.providerInstanceId,
 		model: input.model,
 		...input.modelSelection ? { modelSelection: input.modelSelection } : {},
+		...input.cwd ? { cwd: input.cwd } : {},
 		messageId: input.messageId,
 		directInputTokens: counts.directInputTokens,
 		cacheReadInputTokens: counts.cacheReadInputTokens,
@@ -637,6 +638,278 @@ function observeClaudeCache(input) {
 	};
 }
 //#endregion
+//#region src/provider/claudeContextUsage.ts
+function knownContextWindow(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+/**
+* `compact_boundary.compact_metadata.post_tokens` as a context gauge; undefined when absent or
+* invalid. Compaction invalidated the cache evidence, so the gauge never carries `claudeCache`.
+*/
+function claudePostCompactionUsage(compactMetadata, contextWindow) {
+	if (compactMetadata === null || typeof compactMetadata !== "object") return;
+	const postTokens = compactMetadata.post_tokens;
+	if (typeof postTokens !== "number" || !Number.isFinite(postTokens)) return;
+	const rounded = Math.round(postTokens);
+	if (rounded <= 0) return;
+	const maxTokens = knownContextWindow(contextWindow);
+	return {
+		usedTokens: maxTokens !== void 0 ? Math.min(rounded, maxTokens) : rounded,
+		...maxTokens !== void 0 ? { maxTokens } : {}
+	};
+}
+/**
+* The gauge a Claude result publishes. `result.usage` is cumulative across every API call of the
+* turn, so the last main-loop gauge wins and the cumulative figure only rides along as
+* `totalProcessedTokens`. Without a gauge the cumulative snapshot is a fallback, but never for a
+* turn that crossed a compaction boundary: its cumulative input is the pre-compaction size.
+*/
+function selectClaudeResultUsageGauge(input) {
+	const { lastGauge, cumulative, maxTokens } = input;
+	if (lastGauge === void 0) return input.cumulativeIsGauge ? cumulative : void 0;
+	const cumulativeTotal = cumulative?.totalProcessedTokens ?? cumulative?.usedTokens;
+	return {
+		...lastGauge,
+		...typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0 ? { maxTokens } : {},
+		...typeof cumulativeTotal === "number" && Number.isFinite(cumulativeTotal) && cumulativeTotal > lastGauge.usedTokens ? { totalProcessedTokens: cumulativeTotal } : {}
+	};
+}
+const ABORT_TERMINAL_REASONS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
+function resultErrorsText(result) {
+	return "errors" in result && Array.isArray(result.errors) ? result.errors.join(" ").toLowerCase() : "";
+}
+function isInterruptedResult(result) {
+	const errors = resultErrorsText(result);
+	if (errors.includes("interrupt")) return true;
+	return result.subtype === "error_during_execution" && result.is_error === false && (errors.includes("request was aborted") || errors.includes("interrupted by user") || errors.includes("aborted"));
+}
+/** The CLI ended the segment by aborting it (a Stop or a `priority: "now"` steer). */
+function isClaudeAbortTerminalReason(result) {
+	const terminalReason = Reflect.get(result, "terminal_reason");
+	return typeof terminalReason === "string" && ABORT_TERMINAL_REASONS.has(terminalReason);
+}
+function readStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+}
+function isRootFrame$1(message) {
+	const parentToolUseId = Reflect.get(message, "parent_tool_use_id");
+	return parentToolUseId === null || parentToolUseId === void 0;
+}
+/**
+* The prompt uuids a frame echoes. Results echo every user message the CLI turn consumed. The
+* CLI turn's first reply frame echoes the messages that started it (early echo): its first
+* non-ping stream event, or its first root assistant message when it streamed nothing (a request
+* that failed at the API replies with a synthetic error message).
+*/
+function claudeEchoedPromptUuids(message) {
+	if (message.type !== "result" && message.type !== "stream_event" && !(message.type === "assistant" && isRootFrame$1(message))) return [];
+	const uuids = readStringArray(Reflect.get(message, "user_message_uuids"));
+	if (uuids !== void 0 && uuids.length > 0) return uuids;
+	const uuid = Reflect.get(message, "user_message_uuid");
+	return typeof uuid === "string" && uuid.length > 0 ? [uuid] : [];
+}
+function classifyClaudeResultKind(result) {
+	if (result.subtype === "success" && !result.is_error) return "success";
+	if (isClaudeAbortTerminalReason(result)) return "abort";
+	if (Reflect.get(result, "terminal_reason") === void 0 && isInterruptedResult(result)) return "abort";
+	return "failure";
+}
+/** Whether an echo names the turn's prompt or one of its steers. */
+function claudeEchoNamesTurn(input) {
+	return input.echoed.some((uuid) => uuid === input.promptUuid || input.steerPromptUuids.has(uuid));
+}
+/**
+* Whether a result belongs to the open prompt turn. It does when it echoes the prompt or any of
+* the turn's steers. Without an echo (older CLIs) it belongs unless its origin is not human.
+* Callers skip the check for provider turns (no prompt uuid).
+*/
+function claudeResultBelongsToTurn(input) {
+	if (input.echoed.length > 0) return claudeEchoNamesTurn(input);
+	return input.origin === void 0 || input.origin.kind === "human";
+}
+/**
+* The turn waits only when Stop was not requested, a steer is still unsettled, the segment ended
+* by abort or success, and the CLI positively promised another result (`queued_turn_count > 0`).
+* Every other result completes the turn, so no waiting is unbounded.
+*/
+function decideClaudeTurnResult(input) {
+	const echoed = new Set(input.echoedPromptUuids);
+	const newlySettled = [];
+	const unsettled = [];
+	for (const uuid of input.steerPromptUuids) {
+		if (input.settledSteerPromptUuids.has(uuid)) continue;
+		if (echoed.has(uuid)) newlySettled.push(uuid);
+		else unsettled.push(uuid);
+	}
+	const awaitSteer = !input.interruptRequested && unsettled.length > 0 && (input.kind === "abort" || input.kind === "success") && typeof input.queuedTurnCount === "number" && input.queuedTurnCount > 0;
+	const completingWithSteers = !awaitSteer && unsettled.length > 0;
+	return {
+		decision: awaitSteer ? "await-steer" : "complete",
+		newlySettled,
+		unsettled,
+		discardUnsettled: completingWithSteers && (input.interruptRequested || input.kind === "failure"),
+		abortedBySteer: completingWithSteers && !input.interruptRequested && input.kind === "abort"
+	};
+}
+/**
+* The status a completing turn reports. It follows the result except where the result's status
+* would misstate what happened to the turn: Ryco's own discard re-interrupt or a steer's abort is
+* never a Stop (which would hold the client queue), a Stop always ends as interrupted, and a
+* failure that drops a pending steer is always reported as one (so the queue holds and the user
+* sees why the steer got no reply).
+*/
+function decideClaudeTurnClose(input) {
+	if (input.foldedIntoDiscardedCliTurn) return input.interruptRequested ? {
+		status: "interrupted",
+		cause: "stopped"
+	} : {
+		status: "failed",
+		cause: "folded-into-discarded-cli-turn"
+	};
+	if (input.resultStatus === "completed") {
+		const endsSteerSegment = input.echoedPromptUuids.some((uuid) => input.steerPromptUuids.has(uuid)) && (input.promptUuid === void 0 || !input.echoedPromptUuids.includes(input.promptUuid));
+		if (input.interruptRequested && endsSteerSegment) return {
+			status: "interrupted",
+			cause: "stopped"
+		};
+		if (!input.interruptRequested && input.decision.discardUnsettled) return {
+			status: "failed",
+			cause: "failed-segment-dropped-steers"
+		};
+	}
+	if (input.decision.abortedBySteer) return {
+		status: "completed",
+		cause: "aborted-by-steer"
+	};
+	return {
+		status: input.resultStatus,
+		cause: "result"
+	};
+}
+/** Defensive: anything but a `still_queued` string array is "no receipt" (older CLIs). */
+function readClaudeInterruptReceipt(value) {
+	if (value === null || typeof value !== "object") return void 0;
+	const stillQueued = readStringArray(Reflect.get(value, "still_queued"));
+	if (stillQueued === void 0) return void 0;
+	return {
+		stillQueued,
+		cancelled: readStringArray(Reflect.get(value, "cancelled"))
+	};
+}
+/**
+* Stop with steers pending. A steer that already streamed into the turn, or that the receipt
+* does not list as queued or cancelled (in transit), counts as running, so its own aborted
+* result closes the turn. The discard and release lists hold whether or not the stopped turn is
+* still open.
+*/
+function decideClaudeStop(input) {
+	if (input.receipt === void 0) return {
+		forceClose: input.awaitingSteerContinuation,
+		discard: [...input.unsettledSteers],
+		release: []
+	};
+	const cancelled = new Set(input.receipt.cancelled ?? []);
+	const outstanding = /* @__PURE__ */ new Set([...input.receipt.stillQueued, ...cancelled]);
+	const runningSteers = input.unsettledSteers.filter((uuid) => input.startedSteers.has(uuid) || !outstanding.has(uuid));
+	const isReleased = (uuid) => cancelled.has(uuid) && !input.startedSteers.has(uuid);
+	return {
+		forceClose: (input.sealedSegmentCount > 0 || input.promptUuid !== void 0 && cancelled.has(input.promptUuid)) && runningSteers.length === 0,
+		discard: input.unsettledSteers.filter((uuid) => !isReleased(uuid)),
+		release: input.unsettledSteers.filter(isReleased)
+	};
+}
+/** FIFO-bounded insert. */
+function rememberDiscardedSteer(set, uuid, cap = 64) {
+	if (set.has(uuid)) return;
+	while (set.size >= cap) {
+		const oldest = set.values().next();
+		if (oldest.done) break;
+		set.delete(oldest.value);
+	}
+	set.add(uuid);
+}
+/** Capabilities a CLI advertises on `system/init`; empty when the field is absent. */
+function parseClaudeCliCapabilities(initMessage) {
+	const capabilities = Reflect.get(initMessage, "capabilities");
+	return new Set(Array.isArray(capabilities) ? capabilities.filter((entry) => typeof entry === "string") : []);
+}
+/**
+* Root model-turn content frames: a CLI segment's output, as opposed to system, subagent or
+* keep-alive frames. A CLI turn's first such frame carries its echo: a stream event, or the
+* assistant message when nothing streamed. System frames (`api_retry`, compaction) carry no
+* echo, so they never qualify.
+*/
+function isClaudeRootTurnFrame(message) {
+	if (message.type !== "stream_event" && message.type !== "assistant" && message.type !== "user") return false;
+	if (message.type === "stream_event") {
+		const event = Reflect.get(message, "event");
+		if (typeof event === "object" && event !== null && Reflect.get(event, "type") === "ping") return false;
+	}
+	return isRootFrame$1(message);
+}
+/**
+* A synthetic API-error reply: the request failed after its retries and the CLI turn ends with
+* the next result, so interrupting it again could only reach whatever the CLI runs next.
+* `max_output_tokens` is excluded because the CLI can continue that turn.
+*/
+function isClaudeApiErrorReply(message) {
+	if (message.type !== "assistant") return false;
+	const error = Reflect.get(message, "error");
+	return typeof error === "string" && error !== "max_output_tokens";
+}
+//#endregion
+//#region src/provider/claudeWakeTurn.ts
+/**
+* Claude can start a turn without a prompt (a "wake"): background work finished, a schedule or
+* monitor fired, a rate limit lifted. These rules decide when such a provider turn opens and
+* which frames prove it is alive.
+*/
+/** Longest a wake-signal turn may stay open without any root output before it is aborted. */
+const CLAUDE_WAKE_TURN_FIRST_OUTPUT_TIMEOUT_MS = 12e4;
+/** How long Stop waits for the CLI to end a provider turn before finishing it locally. */
+const CLAUDE_PROVIDER_TURN_STOP_GRACE_MS = 5e3;
+function isRootFrame(message) {
+	const parentToolUseId = message.parent_tool_use_id;
+	return parentToolUseId === null || parentToolUseId === void 0;
+}
+/**
+* Root system/status (requesting|compacting) → "status"; root system/init → "init"; else
+* undefined. A frame with a non-null parent_tool_use_id is never a signal.
+*/
+function claudeWakeSignal(message) {
+	if (message.type !== "system" || !isRootFrame(message)) return;
+	if (message.subtype === "status") return message.status === "requesting" || message.status === "compacting" ? "status" : void 0;
+	return message.subtype === "init" ? "init" : void 0;
+}
+/**
+* Deny-list gate; "init" opens only when the CLI was never seen to emit `status: requesting`
+* (legacy CLIs). There is deliberately no allow list: every kind of wake is covered.
+*/
+function shouldOpenClaudeWakeTurn(gate) {
+	if (gate.hasOpenTurn || gate.sessionStopped || !gate.promptSent || gate.turnInstallsInFlight > 0) return false;
+	return gate.signal === "status" || !gate.requestingStatusObserved;
+}
+/**
+* Root frames that prove Claude is producing the current turn (watchdog liveness). A positive
+* list, so a future periodic background frame cannot keep a phantom turn alive.
+*/
+function isClaudeRootTurnOutput(message) {
+	if (!isRootFrame(message)) return false;
+	switch (message.type) {
+		case "stream_event":
+		case "assistant":
+		case "user":
+		case "result": return true;
+		case "system": switch (message.subtype) {
+			case "compact_boundary":
+			case "api_retry": return true;
+			case "status": return message.status === "compacting";
+			default: return false;
+		}
+		default: return false;
+	}
+}
+//#endregion
 //#region ../../packages/shared/src/cliArgs.ts
 /**
 * Parse CLI-style arguments into flags and positionals.
@@ -772,6 +1045,70 @@ function disableContextCompaction(state, generation) {
 	};
 }
 //#endregion
+//#region src/provider/Layers/claudeUsageLimits.ts
+const CLAUDE_USAGE_LIMIT_FALLBACK_MESSAGE = "Claude usage limit reached.";
+const MESSAGE_MAX_LENGTH = 500;
+function resetIso(resetsAtSeconds) {
+	if (resetsAtSeconds === void 0 || !Number.isFinite(resetsAtSeconds)) return null;
+	const ms = resetsAtSeconds * 1e3;
+	return require_bin.isRepresentableEpochMs(ms) ? new Date(ms).toISOString() : null;
+}
+/** Applies one `rate_limit_event` to the session's rejected windows. */
+function applyClaudeRateLimitInfo(windows, info) {
+	const limitType = info.rateLimitType ?? "unknown";
+	const overageAllowed = info.overageStatus === "allowed" || info.overageStatus === "allowed_warning" || info.isUsingOverage === true || info.overageInUse === true;
+	const blocked = info.status === "rejected" && !overageAllowed;
+	const resetAt = resetIso(info.resetsAt);
+	if (blocked) windows.set(limitType, resetAt);
+	else windows.delete(limitType);
+	return {
+		blocked,
+		key: `${limitType}:${info.resetsAt ?? "unknown"}`,
+		limitType,
+		resetAt
+	};
+}
+/** Current state of the rejected windows; windows whose known reset passed are ignored. */
+function claudeUsageLimitState(windows, nowMs) {
+	return require_bin.usageLimitStateFromWindows([...windows.values()].map((resetAt) => ({
+		exhausted: true,
+		resetAtMs: resetAt === null ? null : Date.parse(resetAt)
+	})), nowMs);
+}
+function trimmed(value) {
+	if (typeof value !== "string") return void 0;
+	const text = value.trim();
+	return text.length > 0 ? text : void 0;
+}
+function limitMessage(result) {
+	const message = (result.subtype === "success" ? trimmed(result.result) : trimmed(result.errors?.[0] ?? "")) ?? "Claude usage limit reached.";
+	return message.length > MESSAGE_MAX_LENGTH ? message.slice(0, MESSAGE_MAX_LENGTH) : message;
+}
+/**
+* Whether a turn's result is a usage-limit stop. Only call it for a result that belongs
+* to an open turn and was not interrupted or cancelled.
+*/
+function classifyClaudeUsageLimitResult(input) {
+	const { result } = input;
+	const state = claudeUsageLimitState(input.windows, input.nowMs);
+	const terminalReason = result.terminal_reason;
+	if (terminalReason === "blocking_limit") return {
+		message: limitMessage(result),
+		resetAt: state.resetAt
+	};
+	if (!state.exhausted) return null;
+	if (!(result.subtype !== "success" || result.is_error === true)) return null;
+	if (terminalReason !== void 0 && terminalReason !== null && terminalReason !== "api_error") return null;
+	if (result.subtype === "success") {
+		const status = result.api_error_status;
+		if (status !== void 0 && status !== null && status !== 429) return null;
+	}
+	return {
+		message: limitMessage(result),
+		resetAt: state.resetAt
+	};
+}
+//#endregion
 //#region src/provider/Layers/ClaudeAdapter.ts
 /**
 * ClaudeAdapterLive - Scoped live implementation for the Claude Agent provider adapter.
@@ -782,20 +1119,49 @@ function disableContextCompaction(state, generation) {
 * @module ClaudeAdapterLive
 */
 const PROVIDER = require_src.ProviderDriverKind.make("claudeAgent");
-const CLAUDE_SUBAGENT_ATTRIBUTION_CACHE_CAP = 256;
-function rememberClaudeSubagentLaunchInput(context, toolUseId, input) {
-	if (!context.subagentLaunchInputByToolUseId.has(toolUseId) && context.subagentLaunchInputByToolUseId.size >= CLAUDE_SUBAGENT_ATTRIBUTION_CACHE_CAP) {
-		const oldestToolUseId = context.subagentLaunchInputByToolUseId.keys().next().value;
-		if (oldestToolUseId !== void 0) context.subagentLaunchInputByToolUseId.delete(oldestToolUseId);
-	}
-	context.subagentLaunchInputByToolUseId.set(toolUseId, input);
+const WAKE_NO_OUTPUT_REASON = "Claude started a background turn but produced no output.";
+const PROVIDER_TURN_STOP_REASON = "Claude did not end the background turn after Stop.";
+const DISCARDED_STEER_TURN_REASON = "Claude started a turn for a message Stop cancelled.";
+const FOLDED_INTO_DISCARDED_STEER_REASON = "Claude Code merged this message into a cancelled steer's request, so no reply is shown. Send it again.";
+const STEER_TURN_ENDED_DETAIL = "The turn finished before this message could be steered. It stays queued and is sent next.";
+const CLAUDE_TURN_HEADS_CAP = 64;
+const CLAUDE_REWIND_PROBE_TIMEOUT = "30 seconds";
+const CLAUDE_REWIND_TRANSCRIPT_TIMEOUT = "10 seconds";
+const CLAUDE_REWIND_QUERY_EXIT_MS = 5e3;
+/** The only turn-state constructor: prompt and provider turns must share one shape. */
+function makeClaudeTurnState(input) {
+	return {
+		turnId: input.turnId,
+		...input.promptUuid !== void 0 ? { promptUuid: input.promptUuid } : {},
+		openedBy: input.openedBy,
+		startedAt: input.startedAt,
+		items: [],
+		assistantTextBlocks: /* @__PURE__ */ new Map(),
+		assistantTextBlockOrder: [],
+		capturedProposedPlanKeys: /* @__PURE__ */ new Set(),
+		nextSyntheticAssistantBlockIndex: -1,
+		reasoningBlocks: /* @__PURE__ */ new Map(),
+		reasoningBlockCount: 0,
+		rootOutputObserved: input.openedBy !== "wake-signal",
+		lastChainUuid: void 0,
+		rootContentObserved: input.openedBy !== "wake-signal",
+		completion: void 0,
+		steerPromptUuids: /* @__PURE__ */ new Set(),
+		settledSteerPromptUuids: /* @__PURE__ */ new Set(),
+		startedSteerPromptUuids: /* @__PURE__ */ new Set(),
+		reinterruptedEchoKeys: /* @__PURE__ */ new Set(),
+		interruptRequested: false,
+		sealedSegmentCount: 0,
+		awaitingSteerContinuation: void 0
+	};
 }
-function rememberClaudeSubagentModel(context, toolUseId, model) {
-	if (!context.subagentModelByToolUseId.has(toolUseId) && context.subagentModelByToolUseId.size >= CLAUDE_SUBAGENT_ATTRIBUTION_CACHE_CAP) {
-		const oldestToolUseId = context.subagentModelByToolUseId.keys().next().value;
-		if (oldestToolUseId !== void 0) context.subagentModelByToolUseId.delete(oldestToolUseId);
+const CLAUDE_SUBAGENT_ATTRIBUTION_CACHE_CAP = 256;
+function rememberClaudeSubagentAttribution(cache, toolUseId, value) {
+	if (!cache.has(toolUseId) && cache.size >= CLAUDE_SUBAGENT_ATTRIBUTION_CACHE_CAP) {
+		const oldestToolUseId = cache.keys().next().value;
+		if (oldestToolUseId !== void 0) cache.delete(oldestToolUseId);
 	}
-	context.subagentModelByToolUseId.set(toolUseId, model);
+	cache.set(toolUseId, value);
 }
 function claudeSubagentLaunchModel(input) {
 	const model = trimmedClaudeString(input?.model);
@@ -815,6 +1181,12 @@ function toMessage(cause, fallback) {
 	if (cause instanceof Error && cause.message.length > 0) return cause.message;
 	return fallback;
 }
+/** A typed adapter error's user-level text: its `detail` or `issue`, not its prefixed message. */
+function adapterFailureDetail(error) {
+	const fields = error;
+	for (const value of [fields.detail, fields.issue]) if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	return error.message;
+}
 function toError(cause, fallback) {
 	return cause instanceof Error ? cause : new Error(toMessage(cause, fallback));
 }
@@ -848,14 +1220,6 @@ function interruptionMessageFromClaudeCause(cause) {
 	const message = messageFromClaudeStreamCause(cause, "Claude runtime interrupted.");
 	return isClaudeInterruptedMessage(message) ? "Claude runtime interrupted." : message;
 }
-function resultErrorsText(result) {
-	return "errors" in result && Array.isArray(result.errors) ? result.errors.join(" ").toLowerCase() : "";
-}
-function isInterruptedResult(result) {
-	const errors = resultErrorsText(result);
-	if (errors.includes("interrupt")) return true;
-	return result.subtype === "error_during_execution" && result.is_error === false && (errors.includes("request was aborted") || errors.includes("interrupted by user") || errors.includes("aborted"));
-}
 function asRuntimeItemId(value) {
 	return require_src.RuntimeItemId.make(value);
 }
@@ -909,14 +1273,27 @@ function readClaudeResumeState(resumeCursor) {
 	const resumeCandidate = typeof cursor.resume === "string" ? cursor.resume : typeof cursor.sessionId === "string" ? cursor.sessionId : void 0;
 	const resume = resumeCandidate && isUuid(resumeCandidate) ? resumeCandidate : void 0;
 	const resumeSessionAt = typeof cursor.resumeSessionAt === "string" ? cursor.resumeSessionAt : void 0;
+	const rewind = resumeCursor.rewind;
+	const rewindAt = rewind !== null && typeof rewind === "object" && typeof rewind.at === "string" && rewind.at.length > 0 ? rewind.at : void 0;
 	const turnCountValue = typeof cursor.turnCount === "number" ? cursor.turnCount : void 0;
 	return {
 		...threadId ? { threadId } : {},
 		...resume ? { resume } : {},
 		...resumeSessionAt ? { resumeSessionAt } : {},
+		...rewindAt ? { rewindAt } : {},
 		...turnCountValue !== void 0 && Number.isInteger(turnCountValue) && turnCountValue >= 0 ? { turnCount: turnCountValue } : {}
 	};
 }
+/**
+* The uuid of a main-chain transcript entry (user, assistant, compaction
+* boundary), or undefined for subagent sidechains and non-chain frames.
+*/
+function claudeMainChainUuid(message) {
+	if (!(message.type === "user" || message.type === "assistant" || message.type === "system" && message.subtype === "compact_boundary")) return void 0;
+	const uuid = message.uuid;
+	const parentToolUseId = message.parent_tool_use_id;
+	return typeof uuid === "string" && uuid.length > 0 && (parentToolUseId === null || parentToolUseId === void 0) ? uuid : void 0;
+}
 function trimmedClaudeString(value) {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
@@ -1165,6 +1542,11 @@ function extractPlanStepsFromTodoInput(input) {
 	}));
 }
 function summarizeToolRequest(toolName, input) {
+	const htmlRender = require_bin.resolveHtmlRenderToolPresentation({
+		toolName,
+		input
+	});
+	if (htmlRender) return htmlRender.detail ? `${toolName}: ${htmlRender.detail}` : toolName;
 	const commandValue = input.command ?? input.cmd;
 	const command = typeof commandValue === "string" ? commandValue : void 0;
 	if (command && command.trim().length > 0) return `${toolName}: ${command.trim().slice(0, 400)}`;
@@ -1178,6 +1560,24 @@ function summarizeToolRequest(toolName, input) {
 	if (serialized.length <= 400) return `${toolName}: ${serialized}`;
 	return `${toolName}: ${serialized.slice(0, 397)}...`;
 }
+/** Work-log detail of a tool item: an HTML tool shows its page title or viewport alone. */
+function toolItemDetail(toolName, input) {
+	const htmlRender = require_bin.resolveHtmlRenderToolPresentation({
+		toolName,
+		input
+	});
+	return htmlRender ? htmlRender.detail : summarizeToolRequest(toolName, input);
+}
+function toolItemTitle(toolName, itemType) {
+	return require_bin.resolveHtmlRenderToolPresentation({
+		toolName,
+		input: void 0
+	})?.title ?? titleForTool(itemType);
+}
+/** Tool input as carried on runtime events: an HTML tool's page is reduced to its length. */
+function toolEventInput(toolName, input) {
+	return require_bin.resolveHtmlRenderToolKind(toolName) === void 0 ? input : require_bin.withoutHtmlRenderMarkup(input);
+}
 function titleForTool(itemType) {
 	switch (itemType) {
 		case "command_execution": return "Command run";
@@ -1295,11 +1695,25 @@ const buildUserMessageEffect = effect.Effect.fn("buildUserMessageEffect")(functi
 });
 function turnStatusFromResult(result) {
 	if (result.subtype === "success") return "completed";
+	if (isClaudeAbortTerminalReason(result)) return "interrupted";
 	const errors = resultErrorsText(result);
 	if (isInterruptedResult(result)) return "interrupted";
 	if (errors.includes("cancel")) return "cancelled";
 	return "failed";
 }
+/** The error a completing turn reports, by why it reports its status (`decideClaudeTurnClose`). */
+function claudeTurnCloseErrorMessage(cause, result) {
+	switch (cause) {
+		case "result": return result.subtype === "success" ? void 0 : result.errors[0];
+		case "aborted-by-steer": return;
+		case "stopped": return "Interrupted by user.";
+		case "failed-segment-dropped-steers": {
+			const text = result.subtype === "success" ? result.result.trim() : result.errors[0];
+			return text !== void 0 && text.length > 0 ? text : "Claude turn failed.";
+		}
+		case "folded-into-discarded-cli-turn": return FOLDED_INTO_DISCARDED_STEER_REASON;
+	}
+}
 function streamKindFromDeltaType(deltaType) {
 	return deltaType.includes("thinking") ? "reasoning_text" : "assistant_text";
 }
@@ -1340,6 +1754,35 @@ function extractExitPlanModePlan(value) {
 function exitPlanCaptureKey(input) {
 	return input.toolUseId && input.toolUseId.length > 0 ? `tool:${input.toolUseId}` : `plan:${input.planMarkdown}`;
 }
+const EMPTY_STREAMED_JSON_SCAN = {
+	depth: 0,
+	inString: false,
+	escaped: false,
+	opened: false
+};
+function scanStreamedJson(scan, chunk) {
+	let { depth, inString, escaped, opened } = scan;
+	for (let index = 0; index < chunk.length; index += 1) {
+		const code = chunk.charCodeAt(index);
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (code === 92) escaped = true;
+			else if (code === 34) inString = false;
+		} else if (code === 34) inString = true;
+		else if (code === 123 || code === 91) {
+			depth += 1;
+			opened = true;
+		} else if (code === 125 || code === 93) depth -= 1;
+	}
+	return {
+		depth,
+		inString,
+		escaped,
+		opened
+	};
+}
+/** Every complete JSON object passes this, so skipping the parse otherwise changes nothing. */
+const mayBeCompleteJson = (scan) => scan.opened && scan.depth === 0 && !scan.inString;
 function tryParseJsonRecord(value) {
 	try {
 		const parsed = JSON.parse(value);
@@ -1447,13 +1890,19 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 	const serverConfig = yield* require_Metrics.ServerConfig;
 	const claudeEnvironment = yield* require_bin.makeClaudeEnvironment(claudeSettings, options?.environment).pipe(effect.Effect.provideService(effect.Path.Path, path));
 	const nativeEventLogger = options?.nativeEventLogger ?? (options?.nativeEventLogPath !== void 0 ? yield* require_bin.makeEventNdjsonLogger(options.nativeEventLogPath, { stream: "native" }) : void 0);
+	const readSessionMessages = options?.readSessionMessages ?? ((sessionId, readOptions) => (0, _anthropic_ai_claude_agent_sdk.getSessionMessages)(sessionId, {
+		...readOptions.dir !== void 0 ? { dir: readOptions.dir } : {},
+		includeSystemMessages: readOptions.includeSystemMessages
+	}));
+	/** Threads whose session is being closed and reopened by a checkpoint revert. */
+	const rewindingThreads = /* @__PURE__ */ new Set();
 	const createQuery = options?.createQuery ?? ((input) => (0, _anthropic_ai_claude_agent_sdk.query)({
 		prompt: input.prompt,
 		options: input.options
 	}));
 	const sessions = /* @__PURE__ */ new Map();
 	let nextSessionGeneration = 0;
-	const runtimeEventQueue = yield* effect.Queue.bounded(2048);
+	const runtimeEventQueue = yield* effect.Queue.bounded(options?.runtimeEventQueueCapacity ?? 2048);
 	const runtimeEventQueueMetrics = yield* require_bin.makeServerQueueMetrics({
 		queue: "provider.adapter.runtimeEvents",
 		component: "ClaudeAdapter",
@@ -1595,18 +2044,19 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		};
 	});
 	const updateResumeCursor = effect.Effect.fn("updateResumeCursor")(function* (context) {
-		const threadId = context.session.threadId;
-		if (!threadId) return;
+		if (!context.session.threadId) return;
+		const updatedAt = yield* nowIso;
 		const resumeCursor = {
-			threadId,
+			threadId: context.session.threadId,
 			...context.resumeSessionId ? { resume: context.resumeSessionId } : {},
 			...context.lastAssistantUuid ? { resumeSessionAt: context.lastAssistantUuid } : {},
+			...context.pendingRewind ? { rewind: { at: context.pendingRewind.at } } : {},
 			turnCount: context.turns.length
 		};
 		context.session = {
 			...context.session,
 			resumeCursor,
-			updatedAt: yield* nowIso
+			updatedAt
 		};
 	});
 	const ensureAssistantTextBlock = effect.Effect.fn("ensureAssistantTextBlock")(function* (context, blockIndex, options) {
@@ -1745,7 +2195,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			});
 		}
 	});
-	const emitRuntimeError = effect.Effect.fn("emitRuntimeError")(function* (context, message, cause) {
+	const emitRuntimeError = effect.Effect.fn("emitRuntimeError")(function* (context, message, cause, options) {
 		if (cause !== void 0) {}
 		const turnState = context.turnState;
 		const stamp = yield* makeEventStamp();
@@ -1758,8 +2208,9 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			...turnState ? { turnId: asCanonicalTurnId(turnState.turnId) } : {},
 			payload: {
 				message,
-				class: "provider_error",
-				...cause !== void 0 ? { detail: cause } : {}
+				class: options?.class ?? "provider_error",
+				...cause !== void 0 ? { detail: cause } : {},
+				...options?.resetAt !== void 0 ? { resetAt: options.resetAt } : {}
 			},
 			providerRefs: nativeProviderRefs(context)
 		});
@@ -1842,7 +2293,8 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			yield* emitCompactionUnavailableWarning(context);
 		}
 	});
-	const completeTurn = effect.Effect.fn("completeTurn")(function* (context, status, errorMessage, result) {
+	/** The context gauge a result (or a local close without one) publishes. */
+	const resolveResultUsageSnapshot = effect.Effect.fn("resolveResultUsageSnapshot")(function* (context, result) {
 		const resultCounts = readClaudeCacheCounts(result?.usage);
 		if (context.cacheObservation && resultCounts?.outputTokens !== void 0) context.cacheObservation = {
 			...context.cacheObservation,
@@ -1856,41 +2308,46 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		const resultContextWindow = mainClaudeContextWindowFromModelUsage(result?.modelUsage, context.cacheObservation?.model ?? context.currentApiModelId);
 		if (resultContextWindow !== void 0) context.lastKnownContextWindow = resultContextWindow;
 		const accumulatedSnapshot = normalizeClaudeTokenUsage(result?.usage, resultContextWindow ?? context.lastKnownContextWindow);
-		const accumulatedTotalProcessedTokens = accumulatedSnapshot?.totalProcessedTokens ?? accumulatedSnapshot?.usedTokens;
-		const lastGoodUsage = context.lastKnownTokenUsage;
-		const maxTokens = resultContextWindow ?? context.lastKnownContextWindow;
-		const rawUsageSnapshot = lastGoodUsage ? {
-			...lastGoodUsage,
-			...typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0 ? { maxTokens } : {},
-			...typeof accumulatedTotalProcessedTokens === "number" && Number.isFinite(accumulatedTotalProcessedTokens) && accumulatedTotalProcessedTokens > lastGoodUsage.usedTokens ? { totalProcessedTokens: accumulatedTotalProcessedTokens } : {}
-		} : accumulatedSnapshot;
-		const usageSnapshot = rawUsageSnapshot ? withAutomaticCompactionCapability({
+		const rawUsageSnapshot = selectClaudeResultUsageGauge({
+			lastGauge: context.lastKnownTokenUsage,
+			cumulative: accumulatedSnapshot,
+			maxTokens: resultContextWindow ?? context.lastKnownContextWindow,
+			cumulativeIsGauge: !context.cumulativeUsageSpansCompaction
+		});
+		if (result !== void 0) context.cumulativeUsageSpansCompaction = false;
+		return rawUsageSnapshot ? withAutomaticCompactionCapability({
 			...rawUsageSnapshot,
+			...accumulatedSnapshot ? { processedUsage: {
+				scope: "turn",
+				inputTokens: accumulatedSnapshot.inputTokens ?? 0,
+				cachedInputTokens: accumulatedSnapshot.cachedInputTokens ?? 0,
+				outputTokens: accumulatedSnapshot.outputTokens ?? 0,
+				reasoningOutputTokens: accumulatedSnapshot.reasoningOutputTokens ?? 0,
+				totalTokens: accumulatedSnapshot.totalProcessedTokens ?? accumulatedSnapshot.usedTokens
+			} } : {},
 			...context.cacheObservation ? { claudeCache: context.cacheObservation } : {}
 		}, context.supportsAutomaticCompaction) : void 0;
-		const turnState = context.turnState;
-		if (!turnState) {
-			if (usageSnapshot) {
-				const usageStamp = yield* makeEventStamp();
-				yield* offerRuntimeEventForContext(context, {
-					type: "thread.token-usage.updated",
-					eventId: usageStamp.eventId,
-					provider: PROVIDER,
-					createdAt: usageStamp.createdAt,
-					threadId: context.session.threadId,
-					payload: { usage: usageSnapshot },
-					providerRefs: {}
-				});
-			}
-			yield* effect.Effect.logInfo("claude.turn.result-without-active-turn", {
-				threadId: context.session.threadId,
-				status,
-				numTurns: result?.num_turns,
-				hasUsage: result?.usage !== void 0,
-				...errorMessage ? { errorMessage } : {}
-			});
-			return;
-		}
+	});
+	/** Publishes a context-gauge snapshot, attributed to a turn when one is given. */
+	const emitTokenUsageSnapshot = effect.Effect.fn("emitTokenUsageSnapshot")(function* (context, usageSnapshot, turnId) {
+		if (!usageSnapshot) return;
+		const usageStamp = yield* makeEventStamp();
+		yield* offerRuntimeEventForContext(context, {
+			type: "thread.token-usage.updated",
+			eventId: usageStamp.eventId,
+			provider: PROVIDER,
+			createdAt: usageStamp.createdAt,
+			threadId: context.session.threadId,
+			...turnId !== void 0 ? { turnId } : {},
+			payload: { usage: usageSnapshot },
+			providerRefs: nativeProviderRefs(context)
+		});
+	});
+	/**
+	* Closes everything a CLI segment left open (in-flight tools, assistant text and reasoning
+	* blocks) while the turn itself may stay open: between a steer's segments and at completion.
+	*/
+	const sealTurnSegment = effect.Effect.fn("sealTurnSegment")(function* (context, turnState, status, result) {
 		for (const [index, tool] of context.inFlightTools.entries()) {
 			const toolStamp = yield* makeEventStamp();
 			yield* offerRuntimeEventForContext(context, {
@@ -1908,7 +2365,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 					...tool.detail ? { detail: tool.detail } : {},
 					data: {
 						toolName: tool.toolName,
-						input: tool.input
+						input: toolEventInput(tool.toolName, tool.input)
 					}
 				},
 				providerRefs: nativeProviderRefs(context, { providerItemId: tool.itemId }),
@@ -1927,25 +2384,73 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			rawMethod: "claude/result",
 			rawPayload: result ?? { status }
 		});
+		turnState.assistantTextBlockOrder.length = 0;
+		for (const reasoningBlock of turnState.reasoningBlocks.values()) {
+			const stamp = yield* makeEventStamp();
+			yield* offerRuntimeEventForContext(context, {
+				type: "item.completed",
+				eventId: stamp.eventId,
+				provider: PROVIDER,
+				createdAt: stamp.createdAt,
+				threadId: context.session.threadId,
+				turnId: asCanonicalTurnId(turnState.turnId),
+				itemId: asRuntimeItemId(reasoningBlock.itemId),
+				payload: {
+					itemType: "reasoning",
+					status: status === "failed" ? "failed" : "completed",
+					title: "Reasoning"
+				},
+				providerRefs: nativeProviderRefs(context),
+				raw: {
+					source: "claude.sdk.message",
+					method: "claude/result",
+					payload: result ?? { status }
+				}
+			});
+		}
+		turnState.reasoningBlocks.clear();
+	});
+	/** A result (or local close) with no open turn: keep usage, never publish a lifecycle event. */
+	const publishTurnlessResult = effect.Effect.fn("publishTurnlessResult")(function* (context, status, errorMessage, result) {
+		yield* emitTokenUsageSnapshot(context, yield* resolveResultUsageSnapshot(context, result), void 0);
+		yield* effect.Effect.logInfo("claude.turn.result-without-active-turn", {
+			threadId: context.session.threadId,
+			status,
+			numTurns: result?.num_turns,
+			hasUsage: result?.usage !== void 0,
+			...errorMessage ? { errorMessage } : {}
+		});
+	});
+	/** Finishes a turn this fiber claimed in `completeTurn`. Never call it directly. */
+	const finishClaimedTurn = effect.Effect.fn("finishClaimedTurn")(function* (context, turnState, completion, status, errorMessage, result, options) {
+		const usageSnapshot = yield* resolveResultUsageSnapshot(context, result);
+		yield* sealTurnSegment(context, turnState, status, result);
 		context.turns.push({
 			id: turnState.turnId,
 			items: [...turnState.items]
 		});
-		if (usageSnapshot) {
-			const usageStamp = yield* makeEventStamp();
-			yield* offerRuntimeEventForContext(context, {
-				type: "thread.token-usage.updated",
-				eventId: usageStamp.eventId,
-				provider: PROVIDER,
-				createdAt: usageStamp.createdAt,
-				threadId: context.session.threadId,
+		if (turnState.lastChainUuid !== void 0) {
+			context.turnHeads.push({
 				turnId: turnState.turnId,
-				payload: { usage: usageSnapshot },
-				providerRefs: nativeProviderRefs(context)
+				head: turnState.lastChainUuid
 			});
+			if (context.turnHeads.length > CLAUDE_TURN_HEADS_CAP) context.turnHeads.shift();
 		}
+		if (status === "completed") context.pendingRewind = void 0;
+		yield* updateResumeCursor(context);
+		yield* emitTokenUsageSnapshot(context, usageSnapshot, turnState.turnId);
 		const stamp = yield* makeEventStamp();
-		yield* offerRuntimeEventForContext(context, {
+		if (options?.abortReason !== void 0) yield* offerRuntimeEventForContext(context, {
+			type: "turn.aborted",
+			eventId: stamp.eventId,
+			provider: PROVIDER,
+			createdAt: stamp.createdAt,
+			threadId: context.session.threadId,
+			turnId: turnState.turnId,
+			payload: { reason: options.abortReason },
+			providerRefs: nativeProviderRefs(context)
+		});
+		else yield* offerRuntimeEventForContext(context, {
 			type: "turn.completed",
 			eventId: stamp.eventId,
 			provider: PROVIDER,
@@ -1963,18 +2468,45 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			providerRefs: nativeProviderRefs(context)
 		});
 		const updatedAt = yield* nowIso;
-		context.turnState = void 0;
-		context.session = {
-			...context.session,
-			status: "ready",
-			activeTurnId: void 0,
-			updatedAt,
-			...status === "failed" && errorMessage ? { lastError: errorMessage } : {}
-		};
+		if (context.turnState === turnState) {
+			context.turnState = void 0;
+			context.session = {
+				...context.session,
+				status: "ready",
+				activeTurnId: void 0,
+				updatedAt,
+				...status === "failed" && errorMessage ? { lastError: errorMessage } : {}
+			};
+		}
+		effect.Deferred.doneUnsafe(completion, effect.Effect.void);
 		if (context.agentControl) yield* context.agentControl.retireTurn(turnState.turnId);
-		yield* updateResumeCursor(context);
 		if (status === "completed" && usageSnapshot) yield* maybeEnableAutomaticCompaction(context, usageSnapshot);
 	});
+	/**
+	* The single owner of turn completion. The open turn is claimed synchronously at entry, so a
+	* concurrent close (sendTurn, Stop grace, watchdog, stream exit) waits for the claimer instead
+	* of emitting a second lifecycle event.
+	*/
+	const completeTurn = effect.Effect.fn("completeTurn")(function* (context, status, errorMessage, result, options) {
+		const turnState = context.turnState;
+		if (options?.expectedTurnState !== void 0 && turnState !== options.expectedTurnState) return;
+		if (turnState?.completion !== void 0) {
+			if (result !== void 0) yield* effect.Effect.logInfo("claude.turn.result-during-completion", {
+				threadId: context.session.threadId,
+				turnId: turnState.turnId,
+				status
+			});
+			yield* effect.Deferred.await(turnState.completion);
+			return;
+		}
+		if (turnState === void 0) return yield* publishTurnlessResult(context, status, errorMessage, result);
+		const completion = effect.Deferred.makeUnsafe();
+		turnState.completion = completion;
+		yield* finishClaimedTurn(context, turnState, completion, status, errorMessage, result, options).pipe(effect.Effect.ensuring(effect.Effect.sync(() => {
+			if (context.turnState === turnState) turnState.completion = void 0;
+			effect.Deferred.doneUnsafe(completion, effect.Effect.void);
+		})));
+	});
 	const handleStreamEvent = effect.Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
@@ -2003,10 +2535,8 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				const deltaText = event.delta.type === "text_delta" ? event.delta.text : typeof event.delta.thinking === "string" ? event.delta.thinking : "";
 				if (deltaText.length === 0) return;
 				const streamKind = streamKindFromDeltaType(event.delta.type);
-				const assistantBlockEntry = event.delta.type === "text_delta" ? yield* ensureAssistantTextBlock(context, event.index) : context.turnState.assistantTextBlocks.get(event.index) ? {
-					blockIndex: event.index,
-					block: context.turnState.assistantTextBlocks.get(event.index)
-				} : void 0;
+				const reasoningBlock = event.delta.type === "thinking_delta" ? context.turnState.reasoningBlocks.get(event.index) : void 0;
+				const assistantBlockEntry = event.delta.type === "text_delta" ? yield* ensureAssistantTextBlock(context, event.index) : void 0;
 				if (assistantBlockEntry?.block && event.delta.type === "text_delta") assistantBlockEntry.block.emittedTextDelta = true;
 				const stamp = yield* makeEventStamp();
 				yield* offerRuntimeEventForContext(context, {
@@ -2016,7 +2546,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 					createdAt: stamp.createdAt,
 					threadId: context.session.threadId,
 					turnId: context.turnState.turnId,
-					...assistantBlockEntry?.block ? { itemId: asRuntimeItemId(assistantBlockEntry.block.itemId) } : {},
+					...assistantBlockEntry?.block ? { itemId: asRuntimeItemId(assistantBlockEntry.block.itemId) } : reasoningBlock ? { itemId: asRuntimeItemId(reasoningBlock.itemId) } : {},
 					payload: {
 						streamKind,
 						delta: deltaText
@@ -2034,17 +2564,19 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				const tool = context.inFlightTools.get(event.index);
 				if (!tool || typeof event.delta.partial_json !== "string") return;
 				const partialInputJson = tool.partialInputJson + event.delta.partial_json;
-				const parsedInput = tryParseJsonRecord(partialInputJson);
-				const detail = parsedInput ? summarizeToolRequest(tool.toolName, parsedInput) : tool.detail;
+				const partialInputScan = scanStreamedJson(tool.partialInputScan, event.delta.partial_json);
+				const parsedInput = mayBeCompleteJson(partialInputScan) ? tryParseJsonRecord(partialInputJson) : void 0;
+				const detail = parsedInput ? toolItemDetail(tool.toolName, parsedInput) : tool.detail;
 				let nextTool = {
 					...tool,
 					partialInputJson,
+					partialInputScan,
 					...parsedInput ? { input: parsedInput } : {},
 					...detail ? { detail } : {}
 				};
 				const nextFingerprint = parsedInput && Object.keys(parsedInput).length > 0 ? toolInputFingerprint(parsedInput) : void 0;
 				context.inFlightTools.set(event.index, nextTool);
-				if (nextTool.itemType === "collab_agent_tool_call" && parsedInput) rememberClaudeSubagentLaunchInput(context, nextTool.itemId, parsedInput);
+				if (nextTool.itemType === "collab_agent_tool_call" && parsedInput) rememberClaudeSubagentAttribution(context.subagentLaunchInputByToolUseId, nextTool.itemId, parsedInput);
 				if (!parsedInput || !nextFingerprint || tool.lastEmittedInputFingerprint === nextFingerprint) return;
 				nextTool = {
 					...nextTool,
@@ -2069,7 +2601,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 						...nextTool.parentToolUseId ? { parentToolUseId: nextTool.parentToolUseId } : {},
 						data: {
 							toolName: nextTool.toolName,
-							input: nextTool.input
+							input: toolEventInput(nextTool.toolName, nextTool.input)
 						}
 					},
 					providerRefs: nativeProviderRefs(context, { providerItemId: nextTool.itemId }),
@@ -2104,12 +2636,40 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				yield* ensureAssistantTextBlock(context, index, { fallbackText: extractContentBlockText(block) });
 				return;
 			}
+			if (block.type === "thinking" && context.turnState) {
+				const turnState = context.turnState;
+				turnState.reasoningBlockCount += 1;
+				const itemId = `${turnState.turnId}:thinking:${turnState.reasoningBlockCount}`;
+				turnState.reasoningBlocks.set(index, { itemId });
+				const stamp = yield* makeEventStamp();
+				yield* offerRuntimeEventForContext(context, {
+					type: "item.started",
+					eventId: stamp.eventId,
+					provider: PROVIDER,
+					createdAt: stamp.createdAt,
+					threadId: context.session.threadId,
+					turnId: asCanonicalTurnId(turnState.turnId),
+					itemId: asRuntimeItemId(itemId),
+					payload: {
+						itemType: "reasoning",
+						status: "inProgress",
+						title: "Reasoning"
+					},
+					providerRefs: nativeProviderRefs(context),
+					raw: {
+						source: "claude.sdk.message",
+						method: "claude/stream_event/content_block_start",
+						payload: message
+					}
+				});
+				return;
+			}
 			if (block.type !== "tool_use" && block.type !== "server_tool_use" && block.type !== "mcp_tool_use") return;
 			const toolName = block.name;
 			const itemType = classifyToolItemType(toolName);
 			const toolInput = typeof block.input === "object" && block.input !== null ? block.input : {};
 			const itemId = block.id;
-			const detail = summarizeToolRequest(toolName, toolInput);
+			const detail = toolItemDetail(toolName, toolInput);
 			const inputFingerprint = Object.keys(toolInput).length > 0 ? toolInputFingerprint(toolInput) : void 0;
 			const parentToolUseId = message.parent_tool_use_id ?? void 0;
 			const owningAgentId = agentIdForParentToolUse(context.taskAgents, parentToolUseId);
@@ -2117,16 +2677,17 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				itemId,
 				itemType,
 				toolName,
-				title: titleForTool(itemType),
-				detail,
+				title: toolItemTitle(toolName, itemType),
+				...detail ? { detail } : {},
 				input: toolInput,
 				partialInputJson: "",
+				partialInputScan: EMPTY_STREAMED_JSON_SCAN,
 				...inputFingerprint ? { lastEmittedInputFingerprint: inputFingerprint } : {},
 				...owningAgentId ? { agentId: owningAgentId } : {},
 				...parentToolUseId ? { parentToolUseId } : {}
 			};
 			context.inFlightTools.set(index, tool);
-			if (itemType === "collab_agent_tool_call") rememberClaudeSubagentLaunchInput(context, itemId, toolInput);
+			if (itemType === "collab_agent_tool_call") rememberClaudeSubagentAttribution(context.subagentLaunchInputByToolUseId, itemId, toolInput);
 			const stamp = yield* makeEventStamp();
 			yield* offerRuntimeEventForContext(context, {
 				type: "item.started",
@@ -2145,7 +2706,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 					...tool.parentToolUseId ? { parentToolUseId: tool.parentToolUseId } : {},
 					data: {
 						toolName: tool.toolName,
-						input: toolInput
+						input: toolEventInput(tool.toolName, toolInput)
 					}
 				},
 				providerRefs: nativeProviderRefs(context, { providerItemId: tool.itemId }),
@@ -2159,6 +2720,32 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		}
 		if (event.type === "content_block_stop") {
 			const { index } = event;
+			const reasoningBlock = context.turnState?.reasoningBlocks.get(index);
+			if (reasoningBlock && context.turnState) {
+				context.turnState.reasoningBlocks.delete(index);
+				const stamp = yield* makeEventStamp();
+				yield* offerRuntimeEventForContext(context, {
+					type: "item.completed",
+					eventId: stamp.eventId,
+					provider: PROVIDER,
+					createdAt: stamp.createdAt,
+					threadId: context.session.threadId,
+					turnId: asCanonicalTurnId(context.turnState.turnId),
+					itemId: asRuntimeItemId(reasoningBlock.itemId),
+					payload: {
+						itemType: "reasoning",
+						status: "completed",
+						title: "Reasoning"
+					},
+					providerRefs: nativeProviderRefs(context),
+					raw: {
+						source: "claude.sdk.message",
+						method: "claude/stream_event/content_block_stop",
+						payload: message
+					}
+				});
+				return;
+			}
 			const assistantBlock = context.turnState?.assistantTextBlocks.get(index);
 			if (assistantBlock) {
 				assistantBlock.streamClosed = true;
@@ -2181,7 +2768,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			const itemStatus = toolResult.isError ? "failed" : "completed";
 			const toolData = {
 				toolName: tool.toolName,
-				input: tool.input,
+				input: toolEventInput(tool.toolName, tool.input),
 				result: toolResult.block
 			};
 			const updatedStamp = yield* makeEventStamp();
@@ -2286,6 +2873,49 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			context.inFlightTools.delete(index);
 		}
 	});
+	/**
+	* Opens a provider turn: one Claude started without a prompt, either at its turn-start signal
+	* ("wake-signal") or, when no signal opened one, at its first root assistant output. Never
+	* bound to Agent Control authority; exact-turn binding stays prompt-only.
+	*/
+	const startProviderTurn = effect.Effect.fn("startProviderTurn")(function* (context, openedBy) {
+		const turnId = require_src.TurnId.make(yield* effect.Effect.sync(() => crypto.randomUUID()));
+		const startedAt = yield* nowIso;
+		if (context.turnState !== void 0 || context.stopped) return;
+		if (openedBy === "wake-signal" && (context.turnInstallsInFlight > 0 || !context.promptSent)) return;
+		const turnState = makeClaudeTurnState({
+			turnId,
+			startedAt,
+			openedBy
+		});
+		context.turnState = turnState;
+		context.session = {
+			...context.session,
+			status: "running",
+			activeTurnId: turnId,
+			updatedAt: startedAt
+		};
+		const turnStartedStamp = yield* makeEventStamp();
+		yield* offerRuntimeEventForContext(context, {
+			type: "turn.started",
+			eventId: turnStartedStamp.eventId,
+			provider: PROVIDER,
+			createdAt: turnStartedStamp.createdAt,
+			threadId: context.session.threadId,
+			turnId,
+			payload: {},
+			providerRefs: {
+				...nativeProviderRefs(context),
+				providerTurnId: turnId
+			},
+			raw: {
+				source: "claude.sdk.message",
+				method: "claude/synthetic-turn-start",
+				payload: { openedBy }
+			}
+		});
+		if (openedBy === "wake-signal") yield* effect.Effect.sleep(effect.Duration.millis(CLAUDE_WAKE_TURN_FIRST_OUTPUT_TIMEOUT_MS)).pipe(effect.Effect.andThen(effect.Effect.suspend(() => context.turnState === turnState && !turnState.rootOutputObserved && !context.stopped ? completeTurn(context, "interrupted", WAKE_NO_OUTPUT_REASON, void 0, { abortReason: WAKE_NO_OUTPUT_REASON }) : effect.Effect.void)), effect.Effect.ignoreCause({ log: true }), effect.Effect.forkDetach);
+	});
 	const handleAssistantMessage = effect.Effect.fn("handleAssistantMessage")(function* (context, message) {
 		if (message.type !== "assistant") return;
 		const assistantParentToolUseId = message.parent_tool_use_id;
@@ -2293,8 +2923,39 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			const owningTaskId = agentIdForParentToolUse(context.taskAgents, assistantParentToolUseId);
 			const snapshotModel = trimmedClaudeString(message.message.model);
 			const owningAgent = owningTaskId ? context.taskAgents.get(owningTaskId) : void 0;
-			if (owningAgent && snapshotModel) owningAgent.model = snapshotModel;
-			else if (snapshotModel) rememberClaudeSubagentModel(context, assistantParentToolUseId, snapshotModel);
+			if (owningAgent && snapshotModel && owningAgent.model !== snapshotModel) {
+				owningAgent.model = snapshotModel;
+				const stamp = yield* makeEventStamp();
+				yield* offerRuntimeEventForContext(context, {
+					...stamp,
+					type: "task.updated",
+					provider: PROVIDER,
+					threadId: context.session.threadId,
+					...context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {},
+					providerRefs: nativeProviderRefs(context),
+					payload: {
+						taskId: require_src.RuntimeTaskId.make(owningAgent.taskId),
+						...taskLinkageFor(context.taskAgents, owningAgent.taskId)
+					}
+				});
+				const existingSubagent = context.subagentByTaskId.get(owningAgent.taskId);
+				if (existingSubagent) {
+					const subagent = {
+						...existingSubagent,
+						model: snapshotModel
+					};
+					context.subagentByTaskId.set(owningAgent.taskId, subagent);
+					yield* emitClaudeSubagentUpdated(context, {
+						subagent,
+						raw: message
+					});
+				}
+			} else if (!owningAgent && snapshotModel) rememberClaudeSubagentAttribution(context.subagentModelByToolUseId, assistantParentToolUseId, snapshotModel);
+			for (const block of message.message.content) {
+				if (block.type !== "tool_use") continue;
+				rememberClaudeSubagentAttribution(context.subagentParentByToolUseId, block.id, assistantParentToolUseId);
+				if (classifyToolItemType(block.name) === "collab_agent_tool_call" && block.input !== null && typeof block.input === "object" && !Array.isArray(block.input)) rememberClaudeSubagentAttribution(context.subagentLaunchInputByToolUseId, block.id, block.input);
+			}
 			context.lastAssistantUuid = message.uuid;
 			yield* updateResumeCursor(context);
 			return;
@@ -2306,11 +2967,13 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			messageId: message.message.id,
 			model: message.message.model,
 			...context.cacheModelSelection ? { modelSelection: context.cacheModelSelection } : {},
+			...context.session.cwd ? { cwd: context.session.cwd } : {},
 			runtimeSessionId: context.session.runtimeSessionId,
 			providerInstanceId: context.session.providerInstanceId,
 			observedAt: cacheStamp.createdAt,
 			...previousCache ? { previous: previousCache } : {}
 		});
+		if (context.cacheObservation) context.mainLoopUsageObserved = true;
 		if (context.cacheObservation && context.cacheObservation !== previousCache) {
 			const observation = context.cacheObservation;
 			const usedTokens = observation.directInputTokens + observation.cacheReadInputTokens + observation.cacheWriteInputTokens;
@@ -2333,44 +2996,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				providerRefs: {}
 			});
 		}
-		if (!context.turnState) {
-			const turnId = require_src.TurnId.make(yield* effect.Effect.sync(() => crypto.randomUUID()));
-			const startedAt = yield* nowIso;
-			context.turnState = {
-				turnId,
-				startedAt,
-				items: [],
-				assistantTextBlocks: /* @__PURE__ */ new Map(),
-				assistantTextBlockOrder: [],
-				capturedProposedPlanKeys: /* @__PURE__ */ new Set(),
-				nextSyntheticAssistantBlockIndex: -1
-			};
-			context.session = {
-				...context.session,
-				status: "running",
-				activeTurnId: turnId,
-				updatedAt: startedAt
-			};
-			const turnStartedStamp = yield* makeEventStamp();
-			yield* offerRuntimeEventForContext(context, {
-				type: "turn.started",
-				eventId: turnStartedStamp.eventId,
-				provider: PROVIDER,
-				createdAt: turnStartedStamp.createdAt,
-				threadId: context.session.threadId,
-				turnId,
-				payload: {},
-				providerRefs: {
-					...nativeProviderRefs(context),
-					providerTurnId: turnId
-				},
-				raw: {
-					source: "claude.sdk.message",
-					method: "claude/synthetic-turn-start",
-					payload: {}
-				}
-			});
-		}
+		if (!context.turnState) yield* startProviderTurn(context, "assistant-output");
 		const content = message.message?.content;
 		if (Array.isArray(content)) for (const block of content) {
 			if (!block || typeof block !== "object") continue;
@@ -2393,12 +3019,106 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		context.lastAssistantUuid = message.uuid;
 		yield* updateResumeCursor(context);
 	});
-	const handleResultMessage = effect.Effect.fn("handleResultMessage")(function* (context, message) {
+	const handleResultMessage = effect.Effect.fn("handleResultMessage")(function* (context, message, options) {
 		if (message.type !== "result") return;
-		const status = turnStatusFromResult(message);
-		const errorMessage = message.subtype === "success" ? void 0 : message.errors[0];
-		if (status === "failed") yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed.");
-		yield* completeTurn(context, status, errorMessage, message);
+		if (context.probing && context.turnState === void 0) {
+			if (message.subtype !== "success" || message.is_error) {
+				const detail = (message.subtype !== "success" ? message.errors[0] : void 0) ?? `Claude reported ${message.subtype} while reopening the conversation.`;
+				if (context.probeFailure) yield* effect.Deferred.succeed(context.probeFailure, detail);
+			}
+			return;
+		}
+		const turnState = context.turnState;
+		const echoedPromptUuids = claudeEchoedPromptUuids(message);
+		if (turnState?.promptUuid !== void 0 && !claudeResultBelongsToTurn({
+			echoed: echoedPromptUuids,
+			origin: message.origin,
+			promptUuid: turnState.promptUuid,
+			steerPromptUuids: turnState.steerPromptUuids
+		})) {
+			yield* effect.Effect.logInfo("claude.turn.result-for-other-prompt", {
+				threadId: context.session.threadId,
+				turnId: turnState.turnId,
+				origin: message.origin?.kind
+			});
+			return;
+		}
+		const resultStatus = turnStatusFromResult(message);
+		let close = {
+			status: resultStatus,
+			cause: "result"
+		};
+		if (turnState) {
+			const decision = decideClaudeTurnResult({
+				kind: classifyClaudeResultKind(message),
+				echoedPromptUuids,
+				queuedTurnCount: message.queued_turn_count,
+				steerPromptUuids: turnState.steerPromptUuids,
+				settledSteerPromptUuids: turnState.settledSteerPromptUuids,
+				interruptRequested: turnState.interruptRequested
+			});
+			for (const uuid of decision.newlySettled) {
+				turnState.settledSteerPromptUuids.add(uuid);
+				context.discardedSteerPromptUuids.delete(uuid);
+			}
+			if (decision.decision === "await-steer") {
+				yield* sealTurnSegment(context, turnState, resultStatus, message);
+				yield* emitTokenUsageSnapshot(context, yield* resolveResultUsageSnapshot(context, message), turnState.turnId);
+				turnState.sealedSegmentCount += 1;
+				turnState.awaitingSteerContinuation = {
+					since: yield* nowIso,
+					segmentStatus: resultStatus
+				};
+				yield* effect.Effect.logInfo("claude.turn.awaiting-steer-continuation", {
+					threadId: context.session.threadId,
+					turnId: turnState.turnId,
+					queuedTurnCount: message.queued_turn_count,
+					unsettled: decision.unsettled.length,
+					terminalReason: message.terminal_reason
+				});
+				return;
+			}
+			if (decision.discardUnsettled) for (const uuid of decision.unsettled) rememberDiscardedSteer(context.discardedSteerPromptUuids, uuid);
+			close = decideClaudeTurnClose({
+				resultStatus,
+				decision,
+				interruptRequested: turnState.interruptRequested,
+				echoedPromptUuids,
+				promptUuid: turnState.promptUuid,
+				steerPromptUuids: turnState.steerPromptUuids,
+				foldedIntoDiscardedCliTurn: options?.foldedIntoDiscardedCliTurn === true
+			});
+			if (close.cause !== "result") {
+				if (close.status !== "failed") yield* sealTurnSegment(context, turnState, resultStatus, message);
+				yield* effect.Effect.logInfo("claude.turn.closed-as", {
+					threadId: context.session.threadId,
+					turnId: turnState.turnId,
+					cause: close.cause,
+					resultStatus,
+					status: close.status,
+					queuedTurnCount: message.queued_turn_count,
+					unsettled: decision.unsettled.length,
+					terminalReason: message.terminal_reason
+				});
+			}
+		}
+		const notInterrupted = (status) => status !== "interrupted" && status !== "cancelled";
+		const usageLimit = context.turnState && notInterrupted(resultStatus) && notInterrupted(close.status) ? classifyClaudeUsageLimitResult({
+			result: message,
+			windows: context.rejectedRateLimitWindows,
+			nowMs: yield* effect.Clock.currentTimeMillis
+		}) : null;
+		if (usageLimit) {
+			yield* emitRuntimeError(context, usageLimit.message, void 0, {
+				class: "usage_limit",
+				resetAt: usageLimit.resetAt
+			});
+			yield* completeTurn(context, "failed", usageLimit.message, message);
+			return;
+		}
+		const errorMessage = claudeTurnCloseErrorMessage(close.cause, message);
+		if (close.status === "failed") yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed.");
+		yield* completeTurn(context, close.status, errorMessage, message);
 	});
 	/**
 	* Synthesizes per-member task.progress rows from the coordinator's
@@ -2467,6 +3187,19 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 	});
 	const handleSystemMessage = effect.Effect.fn("handleSystemMessage")(function* (context, message) {
 		if (message.type !== "system") return;
+		if (message.subtype === "status" && message.status === "requesting") context.requestingStatusObserved = true;
+		const wakeSignal = claudeWakeSignal(message);
+		if (wakeSignal !== void 0 && shouldOpenClaudeWakeTurn({
+			signal: wakeSignal,
+			hasOpenTurn: context.turnState !== void 0,
+			sessionStopped: context.stopped,
+			promptSent: context.promptSent,
+			turnInstallsInFlight: context.turnInstallsInFlight,
+			requestingStatusObserved: context.requestingStatusObserved
+		})) {
+			if (context.discardedSteerPromptUuids.size > 0) context.wakeSignalDeferred = true;
+			else yield* startProviderTurn(context, "wake-signal");
+		}
 		const stamp = yield* makeEventStamp();
 		const base = {
 			eventId: stamp.eventId,
@@ -2580,6 +3313,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		}
 		switch (message.subtype) {
 			case "init":
+				context.cliCapabilities = parseClaudeCliCapabilities(message);
 				yield* offerRuntimeEventForContext(context, {
 					...base,
 					type: "session.configured",
@@ -2602,10 +3336,12 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 					}
 				});
 				return;
-			case "compact_boundary":
+			case "compact_boundary": {
 				context.compactionPolicy = settleContextCompaction(context.compactionPolicy, context.generation);
-				context.lastKnownTokenUsage = void 0;
+				const postCompactionUsage = claudePostCompactionUsage(message.compact_metadata, context.lastKnownContextWindow);
+				context.lastKnownTokenUsage = postCompactionUsage;
 				context.cacheObservation = void 0;
+				context.cumulativeUsageSpansCompaction = true;
 				yield* offerRuntimeEventForContext(context, {
 					...base,
 					type: "thread.state.changed",
@@ -2614,7 +3350,18 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 						detail: message
 					}
 				});
+				if (postCompactionUsage) {
+					const usageStamp = yield* makeEventStamp();
+					yield* offerRuntimeEventForContext(context, {
+						...base,
+						eventId: usageStamp.eventId,
+						createdAt: usageStamp.createdAt,
+						type: "thread.token-usage.updated",
+						payload: { usage: withAutomaticCompactionCapability(postCompactionUsage, context.supportsAutomaticCompaction) }
+					});
+				}
 				return;
+			}
 			case "hook_started":
 				yield* offerRuntimeEventForContext(context, {
 					...base,
@@ -2654,7 +3401,9 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				return;
 			case "task_started": {
 				const launchingTool = message.tool_use_id ? Array.from(context.inFlightTools.values()).find((tool) => tool.itemId === message.tool_use_id) : void 0;
-				const owningAgentId = launchingTool?.agentId;
+				const parentToolUseId = message.tool_use_id ? context.subagentParentByToolUseId.get(message.tool_use_id) : void 0;
+				const owningAgentId = launchingTool?.agentId ?? agentIdForParentToolUse(context.taskAgents, parentToolUseId);
+				if (message.tool_use_id) context.subagentParentByToolUseId.delete(message.tool_use_id);
 				const launchInput = launchingTool?.input ?? (message.tool_use_id ? context.subagentLaunchInputByToolUseId.get(message.tool_use_id) : void 0);
 				const backgroundFlag = message.is_backgrounded;
 				if (backgroundFlag === true || backgroundFlag === void 0 && launchInput?.run_in_background === true) context.backgroundedTaskIds.add(message.task_id);
@@ -2711,7 +3460,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				return;
 			}
 			case "task_progress": {
-				if (message.usage && !context.cacheObservation && !isClaudeSubagentTaskMessage(message) && !context.taskAgents.get(message.task_id)?.toolUseId) {
+				if (message.usage && !context.mainLoopUsageObserved && !isClaudeSubagentTaskMessage(message) && !context.taskAgents.get(message.task_id)?.toolUseId) {
 					const normalizedUsage = normalizeClaudeTokenUsage(message.usage, context.lastKnownContextWindow);
 					if (normalizedUsage) {
 						context.lastKnownTokenUsage = normalizedUsage;
@@ -2793,7 +3542,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			case "task_notification": {
 				context.liveTaskIds.delete(message.task_id);
 				context.backgroundedTaskIds.delete(message.task_id);
-				if (message.usage && !context.cacheObservation && !isClaudeSubagentTaskMessage(message) && !context.taskAgents.get(message.task_id)?.toolUseId) {
+				if (message.usage && !context.mainLoopUsageObserved && !isClaudeSubagentTaskMessage(message) && !context.taskAgents.get(message.task_id)?.toolUseId) {
 					const normalizedUsage = normalizeClaudeTokenUsage(message.usage, context.lastKnownContextWindow);
 					if (normalizedUsage) {
 						context.lastKnownTokenUsage = normalizedUsage;
@@ -2928,17 +3677,175 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			return;
 		}
 		if (message.type === "rate_limit_event") {
+			const transition = message.rate_limit_info ? applyClaudeRateLimitInfo(context.rejectedRateLimitWindows, message.rate_limit_info) : void 0;
 			yield* offerRuntimeEventForContext(context, {
 				...base,
 				type: "account.rate-limits.updated",
-				payload: { rateLimits: message }
+				payload: {
+					rateLimits: message,
+					usageLimitState: claudeUsageLimitState(context.rejectedRateLimitWindows, yield* effect.Clock.currentTimeMillis)
+				}
 			});
+			const turnState = context.turnState;
+			if (transition?.blocked && turnState) {
+				const announced = turnState.announcedUsageLimitKeys ??= /* @__PURE__ */ new Set();
+				if (!announced.has(transition.key)) {
+					announced.add(transition.key);
+					yield* emitRuntimeWarning(context, CLAUDE_USAGE_LIMIT_FALLBACK_MESSAGE, { usageLimit: {
+						limitType: transition.limitType,
+						resetAt: transition.resetAt
+					} });
+				}
+			}
 			return;
 		}
 	});
+	/** Plain interrupt for a CLI segment Stop already ended; bounded, failures only logged. */
+	const forkReinterrupt = (context, reason) => effect.Effect.tryPromise({
+		try: () => context.query.interrupt(),
+		catch: (cause) => toRequestError(context.session.threadId, "turn/interrupt", cause)
+	}).pipe(effect.Effect.timeoutOption("5 seconds"), effect.Effect.tap(() => effect.Effect.logInfo("claude.turn.reinterrupted", {
+		threadId: context.session.threadId,
+		reason
+	})), effect.Effect.ignoreCause({ log: true }), effect.Effect.forkDetach, effect.Effect.asVoid);
+	/**
+	* A discarded steer's CLI turn turned out to be the one a provider turn was opened for (by its
+	* `status: requesting`, legacy `init`, `api_retry` or compaction frame, before its echo). That
+	* turn has routed no content: retract it.
+	*/
+	const retractDiscardedSteerWakeTurn = effect.Effect.fn("retractDiscardedSteerWakeTurn")(function* (context) {
+		const turnState = context.turnState;
+		if (turnState === void 0 || turnState.openedBy !== "wake-signal" || turnState.rootContentObserved || turnState.steerPromptUuids.size > 0) return;
+		yield* completeTurn(context, "interrupted", DISCARDED_STEER_TURN_REASON, void 0, {
+			abortReason: DISCARDED_STEER_TURN_REASON,
+			expectedTurnState: turnState
+		});
+	});
+	/**
+	* The discarded CLI turn's result: forget its uuids, then drop it (keeping its usage). Returns
+	* whether it was consumed. Only this result can end the open turn when:
+	* - it echoes the open turn's prompt or steer, which the CLI folded into the discarded CLI turn
+	*   (a fold shows only on the result). That turn's reply went with the dropped frames, and the
+	*   discard's re-interrupt usually aborted it, so the result closes it here as failed (never as
+	*   a Stop the user did not press);
+	* - the CLI turn's output already reached an open provider turn (its frames carried no echo,
+	*   or beat Stop's bookkeeping). The result is routed on and completes that turn.
+	*/
+	const endDiscardedSteerCliTurn = effect.Effect.fn("endDiscardedSteerCliTurn")(function* (context, message, uuids) {
+		let count = 0;
+		for (const uuid of uuids) {
+			context.discardedSteerPromptUuids.delete(uuid);
+			count += 1;
+		}
+		context.discardingCliTurn = void 0;
+		context.wakeSignalDeferred = false;
+		const open = context.turnState;
+		if (open !== void 0) {
+			const logContext = {
+				threadId: context.session.threadId,
+				turnId: open.turnId,
+				openedBy: open.openedBy,
+				uuids: count
+			};
+			if (claudeEchoNamesTurn({
+				echoed: claudeEchoedPromptUuids(message),
+				promptUuid: open.promptUuid,
+				steerPromptUuids: open.steerPromptUuids
+			})) {
+				yield* effect.Effect.logInfo("claude.turn.discarded-steer-folded-open-turn", logContext);
+				yield* handleResultMessage(context, message, { foldedIntoDiscardedCliTurn: true });
+				return true;
+			}
+			if (open.promptUuid === void 0 && open.rootContentObserved) {
+				yield* effect.Effect.logInfo("claude.turn.discarded-steer-output-leaked", logContext);
+				return false;
+			}
+		}
+		yield* emitTokenUsageSnapshot(context, yield* resolveResultUsageSnapshot(context, message), void 0);
+		yield* retractDiscardedSteerWakeTurn(context);
+		yield* effect.Effect.logInfo("claude.turn.discarded-cancelled-steer", {
+			threadId: context.session.threadId,
+			uuids: count
+		});
+		return true;
+	});
+	/**
+	* Routes frames of CLI segments started by steers. Returns true when the frame was consumed
+	* (dropped, or a result that already closed the open turn). The echo is read on a CLI turn's
+	* first reply frame (its first stream event, or its first root assistant message when it
+	* streamed nothing) and on its result. A CLI turn whose echo holds only steers Stop (or a failed
+	* segment) discarded is interrupted again (unless its reply is an API error, which ends it
+	* anyway) and dropped up to and including its result; a result with such an echo and no reply
+	* before it is dropped alone. Either result still ends the open turn when only it can (see
+	* `endDiscardedSteerCliTurn`). The open turn owns its own steers' segments; after Stop, one that
+	* starts is interrupted again too, with the same API-error exception.
+	*/
+	const routeSteerFrame = effect.Effect.fn("routeSteerFrame")(function* (context, message) {
+		const discarding = context.discardingCliTurn;
+		if (discarding !== void 0) switch (message.type) {
+			case "result": return yield* endDiscardedSteerCliTurn(context, message, [...discarding.uuids, ...claudeEchoedPromptUuids(message)]);
+			case "stream_event":
+			case "assistant":
+			case "user":
+			case "tool_progress":
+			case "tool_use_summary": return true;
+			default: return false;
+		}
+		if (message.type !== "stream_event" && message.type !== "assistant" && message.type !== "result") return false;
+		const echoed = claudeEchoedPromptUuids(message);
+		if (echoed.length === 0) return false;
+		const discarded = context.discardedSteerPromptUuids;
+		const turnState = context.turnState;
+		const owned = turnState !== void 0 && claudeEchoNamesTurn({
+			echoed,
+			promptUuid: turnState.promptUuid,
+			steerPromptUuids: turnState.steerPromptUuids
+		});
+		const reinterruptable = !isClaudeApiErrorReply(message);
+		if (owned || !echoed.every((uuid) => discarded.has(uuid))) {
+			if (owned && message.type !== "result") {
+				for (const uuid of echoed) if (turnState.steerPromptUuids.has(uuid)) turnState.startedSteerPromptUuids.add(uuid);
+				const echoKey = [...echoed].toSorted().join(" ");
+				if (reinterruptable && turnState.interruptRequested && echoed.some((uuid) => turnState.steerPromptUuids.has(uuid) && !turnState.settledSteerPromptUuids.has(uuid)) && !turnState.reinterruptedEchoKeys.has(echoKey)) {
+					turnState.reinterruptedEchoKeys.add(echoKey);
+					yield* forkReinterrupt(context, "steer-segment-after-stop");
+				}
+			}
+			for (const uuid of echoed) discarded.delete(uuid);
+			return false;
+		}
+		if (message.type === "result") return yield* endDiscardedSteerCliTurn(context, message, echoed);
+		context.discardingCliTurn = { uuids: new Set(echoed) };
+		context.wakeSignalDeferred = false;
+		if (reinterruptable) yield* forkReinterrupt(context, "discarded-steer-segment");
+		yield* effect.Effect.logInfo("claude.turn.discarding-cancelled-steer", {
+			threadId: context.session.threadId,
+			uuids: echoed.length
+		});
+		yield* retractDiscardedSteerWakeTurn(context);
+		return true;
+	});
 	const handleSdkMessage = effect.Effect.fn("handleSdkMessage")(function* (context, message) {
 		yield* logNativeSdkMessage(context, message);
 		yield* ensureThreadId(context, message);
+		if (yield* routeSteerFrame(context, message)) return;
+		const chainUuid = claudeMainChainUuid(message);
+		if (chainUuid !== void 0 && context.turnState) context.turnState.lastChainUuid = chainUuid;
+		const rootContent = isClaudeRootTurnFrame(message);
+		if (context.wakeSignalDeferred) {
+			if (rootContent) {
+				context.wakeSignalDeferred = false;
+				if (context.turnState === void 0) yield* startProviderTurn(context, "wake-signal");
+			} else if (message.type === "result") context.wakeSignalDeferred = false;
+		}
+		const waiting = context.turnState;
+		if (waiting?.awaitingSteerContinuation !== void 0 && rootContent) waiting.awaitingSteerContinuation = void 0;
+		yield* routeSdkMessage(context, message);
+		const open = context.turnState;
+		if (open && !open.rootOutputObserved && isClaudeRootTurnOutput(message)) open.rootOutputObserved = true;
+		if (open && rootContent) open.rootContentObserved = true;
+	});
+	const routeSdkMessage = effect.Effect.fn("routeSdkMessage")(function* (context, message) {
 		switch (message.type) {
 			case "stream_event":
 				yield* handleStreamEvent(context, message);
@@ -2966,7 +3873,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				return;
 		}
 	});
-	const runSdkStream = (context) => effect.Stream.fromAsyncIterable(context.query, (cause) => toError(cause, "Claude runtime stream failed.")).pipe(effect.Stream.takeWhile(() => !context.stopped), effect.Stream.runForEach((message) => handleSdkMessage(context, message)));
+	const runSdkStream = (context) => effect.Stream.fromAsyncIterable(context.query, (cause) => toError(cause, "Claude runtime stream failed.")).pipe(effect.Stream.takeWhile(() => !context.stopped), effect.Stream.runForEach((message) => context.turnLock.withPermits(1)(handleSdkMessage(context, message))));
 	const handleStreamExit = effect.Effect.fn("handleStreamExit")(function* (context, exit) {
 		if (context.stopped) return;
 		if (effect.Exit.isFailure(exit)) {
@@ -2983,6 +3890,9 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 	const stopSessionInternal = effect.Effect.fn("stopSessionInternal")(function* (context, options) {
 		if (context.stopped) return;
 		context.stopped = true;
+		context.discardedSteerPromptUuids.clear();
+		context.discardingCliTurn = void 0;
+		context.wakeSignalDeferred = false;
 		context.deviceToolBinding?.dispose();
 		if (context.agentControl) yield* context.agentControl.revoke("runtime-teardown");
 		for (const [requestId, pending] of context.pendingApprovals) {
@@ -3009,11 +3919,22 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		yield* effect.Queue.shutdown(context.promptQueue);
 		const streamFiber = context.streamFiber;
 		context.streamFiber = void 0;
-		if (streamFiber && streamFiber.pollUnsafe() === void 0) yield* effect.Fiber.interrupt(streamFiber);
-		try {
-			context.query.close();
-		} catch (cause) {
-			yield* emitRuntimeError(context, "Failed to close Claude runtime query.", cause);
+		const closeQuery = effect.Effect.gen(function* () {
+			try {
+				context.query.close();
+			} catch (cause) {
+				yield* emitRuntimeError(context, "Failed to close Claude runtime query.", cause);
+			}
+		});
+		if (options?.awaitQueryExitMs !== void 0) {
+			yield* closeQuery;
+			if (streamFiber && streamFiber.pollUnsafe() === void 0) {
+				const exited = yield* effect.Fiber.await(streamFiber).pipe(effect.Effect.timeoutOption(effect.Duration.millis(options.awaitQueryExitMs)));
+				if (effect.Option.isNone(exited)) yield* effect.Fiber.interrupt(streamFiber);
+			}
+		} else {
+			if (streamFiber && streamFiber.pollUnsafe() === void 0) yield* effect.Fiber.interrupt(streamFiber);
+			yield* closeQuery;
 		}
 		const updatedAt = yield* nowIso;
 		context.session = {
@@ -3063,6 +3984,11 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			issue: `Expected provider instance '${boundInstanceId}' but received '${input.providerInstanceId}'.`
 		});
 		const runtimeSessionId = yield* require_runtimeSession.requireRuntimeSessionId(PROVIDER, input);
+		if (rewindingThreads.has(input.threadId)) return yield* new require_bin.ProviderAdapterValidationError({
+			provider: PROVIDER,
+			operation: "startSession",
+			issue: "Claude is rewinding this thread; try again in a moment."
+		});
 		const existingContext = sessions.get(input.threadId);
 		if (existingContext) {
 			if (existingContext.session.runtimeSessionId === runtimeSessionId) return existingContext.session;
@@ -3072,6 +3998,15 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				issue: `Thread '${input.threadId}' still has runtime '${existingContext.session.runtimeSessionId ?? "legacy"}'; stop it before starting '${runtimeSessionId}'.`
 			});
 		}
+		return { ...(yield* openSessionContext(input, {})).session };
+	});
+	/**
+	* Opens a query for `input` and registers its context. With `probe`, the
+	* reopened CLI must accept a control request before this succeeds; a failed
+	* probe stops the context silently (no runtime.error or session.exited).
+	*/
+	const openSessionContext = effect.Effect.fn("openSessionContext")(function* (input, openOptions) {
+		const runtimeSessionId = yield* require_runtimeSession.requireRuntimeSessionId(PROVIDER, input);
 		const startedAt = yield* nowIso;
 		const effectiveResumeCursor = input.resumePolicy === "fresh" ? void 0 : input.resumeCursor;
 		const resumeState = readClaudeResumeState(effectiveResumeCursor);
@@ -3303,7 +4238,10 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		});
 		const canUseTool = (toolName, toolInput, callbackOptions) => runPromise(canUseToolEffect(toolName, toolInput, callbackOptions));
 		const claudeBinaryPath = claudeSettings.binaryPath;
-		const extraArgs = parseCliArgs(claudeSettings.launchArgs).flags;
+		const extraArgs = {
+			"thinking-display": "summarized",
+			...parseCliArgs(claudeSettings.launchArgs).flags
+		};
 		const modelSelection = input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : void 0;
 		const caps = getClaudeModelCapabilities(modelSelection?.model);
 		const descriptors = require_Metrics.getProviderOptionDescriptors({ caps });
@@ -3360,6 +4298,8 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			...permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {},
 			...Object.keys(settings).length > 0 ? { settings } : {},
 			...existingResumeSessionId ? { resume: existingResumeSessionId } : {},
+			...existingResumeSessionId && resumeState?.rewindAt ? { resumeSessionAt: resumeState.rewindAt } : {},
+			...existingResumeSessionId && resumeState?.rewindAt && openOptions.resumeDropsTurn ? { resumeDropsTurn: openOptions.resumeDropsTurn } : {},
 			...newSessionId ? { sessionId: newSessionId } : {},
 			includePartialMessages: true,
 			canUseTool,
@@ -3433,6 +4373,7 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				...threadId ? { threadId } : {},
 				...sessionId ? { resume: sessionId } : {},
 				...resumeState?.resumeSessionAt ? { resumeSessionAt: resumeState.resumeSessionAt } : {},
+				...existingResumeSessionId && resumeState?.rewindAt ? { rewind: { at: resumeState.rewindAt } } : {},
 				turnCount: resumeState?.turnCount ?? 0
 			},
 			createdAt: startedAt,
@@ -3440,9 +4381,15 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		};
 		const generation = ++nextSessionGeneration;
 		const supportsAutomaticCompaction = typeof queryRuntime.applyFlagSettings === "function";
+		const { resumeCursor: _resumeCursor, resumePolicy: _resumePolicy, ...startInput } = input;
 		const context = {
 			generation,
 			session,
+			startInput,
+			turnHeads: [...openOptions.turnHeads ?? []],
+			pendingRewind: existingResumeSessionId && resumeState?.rewindAt ? { at: resumeState.rewindAt } : void 0,
+			probing: openOptions.probe === true,
+			probeFailure: openOptions.probe === true ? effect.Deferred.makeUnsafe() : void 0,
 			promptQueue,
 			query: queryRuntime,
 			deviceToolBinding,
@@ -3463,7 +4410,9 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			taskAgents: /* @__PURE__ */ new Map(),
 			subagentLaunchInputByToolUseId: /* @__PURE__ */ new Map(),
 			subagentModelByToolUseId: /* @__PURE__ */ new Map(),
+			subagentParentByToolUseId: /* @__PURE__ */ new Map(),
 			workflowMemberFingerprints: /* @__PURE__ */ new Map(),
+			rejectedRateLimitWindows: /* @__PURE__ */ new Map(),
 			workflowPhasesByTaskId: /* @__PURE__ */ new Map(),
 			liveTaskIds: /* @__PURE__ */ new Set(),
 			backgroundedTaskIds: /* @__PURE__ */ new Set(),
@@ -3471,6 +4420,8 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			lastKnownContextWindow: void 0,
 			lastKnownTokenUsage: void 0,
 			cacheObservation: void 0,
+			mainLoopUsageObserved: false,
+			cumulativeUsageSpansCompaction: false,
 			cacheModelSelection: modelSelection,
 			compactionPolicy: initialContextCompactionPolicyState(generation),
 			supportsAutomaticCompaction,
@@ -3480,7 +4431,15 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			subagentByTaskId: /* @__PURE__ */ new Map(),
 			startedSubagentIds: /* @__PURE__ */ new Set(),
 			completedSubagentIds: /* @__PURE__ */ new Set(),
-			stopped: false
+			stopped: false,
+			promptSent: false,
+			turnInstallsInFlight: 0,
+			requestingStatusObserved: false,
+			cliCapabilities: void 0,
+			discardedSteerPromptUuids: /* @__PURE__ */ new Set(),
+			discardingCliTurn: void 0,
+			wakeSignalDeferred: false,
+			turnLock: yield* effect.Semaphore.make(1)
 		};
 		deviceToolContext = context;
 		yield* effect.Ref.set(contextRef, context);
@@ -3525,18 +4484,35 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		streamFiber = runFork(effect.Effect.exit(runSdkStream(context)).pipe(effect.Effect.flatMap((exit) => {
 			if (context.stopped) return effect.Effect.void;
 			if (context.streamFiber === streamFiber) context.streamFiber = void 0;
+			if (context.probing && context.probeFailure) return effect.Deferred.succeed(context.probeFailure, effect.Exit.isFailure(exit) ? messageFromClaudeStreamCause(exit.cause, "Claude runtime stream failed.") : "Claude exited while reopening the conversation.").pipe(effect.Effect.asVoid);
 			return handleStreamExit(context, exit);
 		})));
 		context.streamFiber = streamFiber;
 		streamFiber.addObserver(() => {
 			if (context.streamFiber === streamFiber) context.streamFiber = void 0;
 		});
-		return { ...session };
+		if (context.probing && context.probeFailure) {
+			const probeFailure = context.probeFailure;
+			const controlRequest = effect.Effect.tryPromise({
+				try: () => queryRuntime.initializationResult?.() ?? queryRuntime.mcpServerStatus?.() ?? Promise.resolve(),
+				catch: (cause) => toMessage(cause, "Claude rejected the reopened conversation.")
+			});
+			const probe = yield* effect.Effect.raceFirst(controlRequest.pipe(effect.Effect.asVoid), effect.Deferred.await(probeFailure).pipe(effect.Effect.flatMap((detail) => effect.Effect.fail(detail)))).pipe(effect.Effect.timeoutOption(CLAUDE_REWIND_PROBE_TIMEOUT), effect.Effect.result);
+			context.probing = false;
+			const failure = probe._tag === "Failure" ? probe.failure : effect.Option.isNone(probe.success) ? "Claude did not respond while reopening the conversation." : effect.Deferred.isDoneUnsafe(probeFailure) ? "Claude exited while reopening the conversation." : void 0;
+			if (failure !== void 0) {
+				yield* stopSessionInternal(context, { emitExitEvent: false });
+				return yield* new require_bin.ProviderAdapterProcessError({
+					provider: PROVIDER,
+					threadId,
+					detail: failure
+				});
+			}
+		}
+		return context;
 	});
-	const sendTurn = effect.Effect.fn("sendTurn")(function* (input) {
-		const context = yield* requireSession(input.threadId);
+	const sendTurnOnContext = effect.Effect.fn("sendTurnOnContext")(function* (context, input) {
 		const modelSelection = input.modelSelection !== void 0 && input.modelSelection.instanceId === boundInstanceId ? input.modelSelection : void 0;
-		if (context.turnState) yield* completeTurn(context, "completed");
 		if (modelSelection?.model) {
 			const apiModelId = resolveClaudeApiModelId(modelSelection);
 			if (context.currentApiModelId !== apiModelId) {
@@ -3563,24 +4539,23 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			try: () => context.query.setPermissionMode(context.basePermissionMode ?? "default"),
 			catch: (cause) => toRequestError(input.threadId, "turn/setPermissionMode", cause)
 		});
-		const turnId = require_src.TurnId.make(yield* effect.Effect.sync(() => crypto.randomUUID()));
-		const turnState = {
+		const promptUuid = yield* effect.Effect.sync(() => crypto.randomUUID());
+		const turnId = require_src.TurnId.make(promptUuid);
+		const startedAt = yield* nowIso;
+		while (context.turnState !== void 0) yield* completeTurn(context, "completed");
+		context.turnState = makeClaudeTurnState({
 			turnId,
-			startedAt: yield* nowIso,
-			items: [],
-			assistantTextBlocks: /* @__PURE__ */ new Map(),
-			assistantTextBlockOrder: [],
-			capturedProposedPlanKeys: /* @__PURE__ */ new Set(),
-			nextSyntheticAssistantBlockIndex: -1
-		};
-		const updatedAt = yield* nowIso;
-		context.turnState = turnState;
+			promptUuid,
+			startedAt,
+			openedBy: "prompt"
+		});
 		context.session = {
 			...context.session,
 			status: "running",
 			activeTurnId: turnId,
-			updatedAt
+			updatedAt: startedAt
 		};
+		context.promptSent = true;
 		const turnStartedStamp = yield* makeEventStamp();
 		yield* offerRuntimeEventForContext(context, {
 			type: "turn.started",
@@ -3604,7 +4579,10 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		});
 		yield* effect.Queue.offer(context.promptQueue, {
 			type: "message",
-			message
+			message: {
+				...message,
+				uuid: promptUuid
+			}
 		}).pipe(effect.Effect.mapError((cause) => toRequestError(input.threadId, "turn/start", cause)));
 		if (context.agentControl) yield* context.agentControl.bindTurn(turnId).pipe(effect.Effect.catchCause((cause) => effect.Effect.logWarning("failed to bind Agent Control turn authority", {
 			threadId: input.threadId,
@@ -3617,9 +4595,73 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 			...context.session.resumeCursor !== void 0 ? { resumeCursor: context.session.resumeCursor } : {}
 		};
 	});
-	const interruptTurn = effect.Effect.fn("interruptTurn")(function* (threadId, _turnId) {
+	const sendTurn = effect.Effect.fn("sendTurn")(function* (input) {
+		const context = yield* requireSession(input.threadId);
+		return yield* effect.Effect.acquireUseRelease(effect.Effect.sync(() => {
+			context.turnInstallsInFlight += 1;
+		}), () => sendTurnOnContext(context, input), () => effect.Effect.sync(() => {
+			context.turnInstallsInFlight -= 1;
+		}));
+	});
+	/**
+	* Adds a user message to the exact running turn: an SDK user message with `priority: "now"`
+	* and its own uuid. The Ryco turn keeps its id and absorbs the CLI segments the steer starts.
+	* Refusals are `ProviderTurnNotSteerableError`, so the message stays queued as the next turn.
+	*/
+	const steerTurn = effect.Effect.fn("steerTurn")(function* (input) {
+		const context = yield* requireSession(input.threadId);
+		const refuse = (reason, detail) => new require_bin.ProviderTurnNotSteerableError({
+			provider: PROVIDER,
+			threadId: input.threadId,
+			turnId: input.expectedTurnId,
+			reason,
+			detail
+		});
+		const turnState = context.turnState;
+		if (!turnState || turnState.turnId !== input.expectedTurnId || context.session.activeTurnId !== input.expectedTurnId || turnState.interruptRequested) return yield* refuse("turn-ended", STEER_TURN_ENDED_DETAIL);
+		if (context.pendingApprovals.size > 0 || context.pendingUserInputs.size > 0) return yield* refuse("busy", "Claude is waiting for an approval or answer. The message stays queued.");
+		if (!context.cliCapabilities?.has("interrupt_receipt_v1")) return yield* refuse("unsupported", "This Claude Code version can't steer a running turn. The message stays queued.");
+		if (input.input?.trimStart().startsWith("/")) return yield* refuse("unsupported", "Slash commands can't be steered into a running turn. The message stays queued.");
+		const message = yield* buildUserMessageEffect({
+			threadId: input.threadId,
+			...input.input ? { input: input.input } : {},
+			attachments: input.attachments ?? [],
+			...context.cacheModelSelection ? { modelSelection: context.cacheModelSelection } : {}
+		}, {
+			fileSystem,
+			attachmentsDir: serverConfig.attachmentsDir,
+			boundInstanceId
+		});
+		const steerUuid = yield* effect.Effect.sync(() => crypto.randomUUID());
+		if (!(yield* context.turnLock.withPermits(1)(effect.Effect.gen(function* () {
+			if (sessions.get(input.threadId) !== context || context.stopped || context.turnState !== turnState || turnState.interruptRequested || turnState.completion !== void 0) return false;
+			turnState.steerPromptUuids.add(steerUuid);
+			const offered = yield* effect.Queue.offer(context.promptQueue, {
+				type: "message",
+				message: {
+					...message,
+					uuid: steerUuid,
+					priority: "now"
+				}
+			});
+			if (!offered) turnState.steerPromptUuids.delete(steerUuid);
+			return offered;
+		})))) return yield* refuse("turn-ended", STEER_TURN_ENDED_DETAIL);
+		yield* effect.Effect.logInfo("claude.turn.steered", {
+			threadId: input.threadId,
+			turnId: turnState.turnId,
+			awaiting: turnState.awaitingSteerContinuation !== void 0
+		});
+		return {
+			threadId: context.session.threadId,
+			turnId: turnState.turnId
+		};
+	});
+	const interruptTurn = effect.Effect.fn("interruptTurn")(function* (threadId, turnId) {
 		const context = yield* requireSession(threadId);
-		if (context.agentControl) yield* context.agentControl.retireTurn(_turnId);
+		const target = context.turnState;
+		if (target) target.interruptRequested = true;
+		if (context.agentControl) yield* context.agentControl.retireTurn(turnId);
 		if (context.query.stopTask && context.liveTaskIds.size > 0) {
 			const liveIds = Array.from(context.liveTaskIds);
 			yield* effect.Effect.forEach(liveIds, (taskId) => effect.Effect.gen(function* () {
@@ -3648,10 +4690,47 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 				discard: true
 			}).pipe(effect.Effect.timeoutOption("10 seconds"), effect.Effect.ignore);
 		}
-		yield* effect.Effect.tryPromise({
-			try: () => context.query.interrupt(),
+		const cancelQueued = (target ? [...target.steerPromptUuids].filter((uuid) => !target.settledSteerPromptUuids.has(uuid)) : []).length > 0 && context.cliCapabilities?.has("interrupt_cancel_queued_v1") === true;
+		const rawReceipt = yield* effect.Effect.tryPromise({
+			try: () => cancelQueued ? context.query.interrupt({ cancelQueued: true }) : context.query.interrupt(),
 			catch: (cause) => toRequestError(threadId, "turn/interrupt", cause)
 		});
+		if (target !== void 0 && target.steerPromptUuids.size > 0) {
+			const receipt = readClaudeInterruptReceipt(rawReceipt);
+			yield* effect.Effect.logInfo("claude.turn.interrupt-receipt", {
+				threadId: context.session.threadId,
+				turnId: target.turnId,
+				cancelQueued,
+				hasReceipt: receipt !== void 0,
+				stillQueued: receipt?.stillQueued.length ?? 0,
+				cancelled: receipt?.cancelled?.length ?? 0
+			});
+			yield* context.turnLock.withPermits(1)(effect.Effect.gen(function* () {
+				if (context.stopped) return;
+				const stop = decideClaudeStop({
+					unsettledSteers: [...target.steerPromptUuids].filter((uuid) => !target.settledSteerPromptUuids.has(uuid)),
+					startedSteers: target.startedSteerPromptUuids,
+					promptUuid: target.promptUuid,
+					sealedSegmentCount: target.sealedSegmentCount,
+					awaitingSteerContinuation: target.awaitingSteerContinuation !== void 0,
+					receipt
+				});
+				if (context.turnState === target) for (const uuid of stop.discard) rememberDiscardedSteer(context.discardedSteerPromptUuids, uuid);
+				for (const uuid of stop.release) {
+					context.discardedSteerPromptUuids.delete(uuid);
+					target.settledSteerPromptUuids.add(uuid);
+				}
+				if (stop.forceClose && context.turnState === target) yield* completeTurn(context, "interrupted", "Interrupted by user.", void 0, { expectedTurnState: target });
+			}));
+		}
+		if (target !== void 0 && target.openedBy !== "prompt" && (turnId === void 0 || target.turnId === turnId)) yield* effect.Effect.sleep(effect.Duration.millis(CLAUDE_PROVIDER_TURN_STOP_GRACE_MS)).pipe(effect.Effect.andThen(effect.Effect.suspend(() => {
+			if (context.turnState !== target || target.completion !== void 0 || context.stopped) return effect.Effect.void;
+			return effect.Effect.logInfo("claude.turn.provider-turn-finalized-after-stop", {
+				threadId: context.session.threadId,
+				turnId: target.turnId,
+				openedBy: target.openedBy
+			}).pipe(effect.Effect.andThen(completeTurn(context, "interrupted", PROVIDER_TURN_STOP_REASON)));
+		})), effect.Effect.ignoreCause({ log: true }), effect.Effect.forkDetach);
 	});
 	const stopBackgroundTask = effect.Effect.fn("stopBackgroundTask")(function* (threadId, taskId, expected) {
 		const context = yield* requireSession(threadId);
@@ -3686,12 +4765,109 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 		const context = yield* requireSession(threadId);
 		return yield* snapshotThread(context);
 	});
-	const rollbackThread = effect.Effect.fn("rollbackThread")(function* (threadId, numTurns) {
+	/** The session's main transcript chain, oldest first. Errors and timeouts read as empty. */
+	const readMainTranscriptChain = effect.Effect.fn("readMainTranscriptChain")(function* (sessionId, cwd) {
+		const read = (dir) => effect.Effect.tryPromise(() => readSessionMessages(sessionId, {
+			...dir !== void 0 ? { dir } : {},
+			includeSystemMessages: true
+		})).pipe(effect.Effect.timeoutOption(CLAUDE_REWIND_TRANSCRIPT_TIMEOUT), effect.Effect.map((entries) => effect.Option.getOrElse(entries, () => [])), effect.Effect.catch(() => effect.Effect.succeed([])), effect.Effect.map((entries) => entries.filter((entry) => typeof entry.uuid === "string" && (entry.parent_tool_use_id === null || entry.parent_tool_use_id === void 0))));
+		const inCwd = yield* read(cwd);
+		return inCwd.length > 0 || cwd === void 0 ? inCwd : yield* read(void 0);
+	});
+	/**
+	* Makes Claude forget the newest turns: close the live query, wait for the
+	* CLI to exit, and reopen the transcript truncated just before the first
+	* dropped prompt (or a fresh session for checkpoint 0). A reopen the CLI
+	* refuses restores the previous conversation and reports the refusal.
+	*/
+	const rollbackThread = effect.Effect.fn("rollbackThread")(function* (threadId, input) {
 		const context = yield* requireSession(threadId);
-		const nextLength = Math.max(0, context.turns.length - numTurns);
-		context.turns.splice(nextLength);
-		yield* updateResumeCursor(context);
-		return yield* snapshotThread(context);
+		const refuse = (detail) => new require_bin.ProviderAdapterRequestError({
+			provider: PROVIDER,
+			method: "thread/rollback",
+			detail
+		});
+		if (context.turnState) return yield* refuse("A Claude turn is still running.");
+		if (context.liveTaskIds.size > 0) return yield* refuse("Claude still has background tasks running. Stop them, then revert again.");
+		if (context.pendingApprovals.size > 0 || context.pendingUserInputs.size > 0) return yield* refuse("Claude is waiting for your answer. Answer it, then revert again.");
+		if (rewindingThreads.has(threadId)) return yield* refuse("Claude is already rewinding this thread.");
+		let plan;
+		if (input.targetTurnId === null) plan = { kind: "fresh" };
+		else {
+			const firstDropped = input.droppedTurnIds[0];
+			const chain = context.resumeSessionId !== void 0 && firstDropped !== void 0 ? yield* readMainTranscriptChain(context.resumeSessionId, context.session.cwd) : [];
+			const index = firstDropped === void 0 ? -1 : chain.findIndex((entry) => entry.uuid === firstDropped);
+			if (index > 0) plan = {
+				kind: "rewind",
+				at: chain[index - 1].uuid,
+				...input.droppedTurnIds.length === 1 && firstDropped !== void 0 ? { dropsTurn: firstDropped } : {}
+			};
+			else if (index === 0) plan = { kind: "fresh" };
+			else {
+				const head = context.turnHeads.find((entry) => entry.turnId === input.targetTurnId)?.head;
+				if (head !== void 0) plan = {
+					kind: "rewind",
+					at: head
+				};
+			}
+		}
+		if (plan === void 0) return yield* refuse("Claude has no recorded transcript position for this checkpoint. Revert to an earlier checkpoint or start a new thread.");
+		const rewindPlan = plan;
+		rewindingThreads.add(threadId);
+		return yield* effect.Effect.gen(function* () {
+			const previousCursor = context.session.resumeCursor;
+			const dropped = new Set(input.droppedTurnIds);
+			const keptTurnHeads = context.turnHeads.filter((entry) => !dropped.has(entry.turnId));
+			yield* stopSessionInternal(context, {
+				emitExitEvent: false,
+				awaitQueryExitMs: CLAUDE_REWIND_QUERY_EXIT_MS
+			});
+			const previousTurnCount = readClaudeResumeState(previousCursor)?.turnCount ?? context.turns.length;
+			const nextCursor = rewindPlan.kind === "fresh" || context.resumeSessionId === void 0 ? { threadId } : {
+				threadId,
+				resume: context.resumeSessionId,
+				rewind: { at: rewindPlan.at },
+				turnCount: Math.max(0, previousTurnCount - input.numTurns)
+			};
+			const reopenInput = {
+				...context.startInput,
+				runtimeMode: context.session.runtimeMode,
+				...context.session.tokenMode !== void 0 ? { tokenMode: context.session.tokenMode } : {},
+				...context.cacheModelSelection ?? context.startInput.modelSelection ? { modelSelection: context.cacheModelSelection ?? context.startInput.modelSelection } : {},
+				...context.session.runtimeSessionId !== void 0 ? { runtimeSessionId: context.session.runtimeSessionId } : {}
+			};
+			const reopened = yield* effect.Effect.result(openSessionContext({
+				...reopenInput,
+				resumeCursor: nextCursor
+			}, {
+				probe: true,
+				turnHeads: keptTurnHeads
+			}));
+			if (reopened._tag === "Success") return yield* snapshotThread(reopened.success);
+			const refusal = adapterFailureDetail(reopened.failure);
+			if ((yield* effect.Effect.result(openSessionContext({
+				...reopenInput,
+				resumeCursor: previousCursor
+			}, {
+				probe: true,
+				turnHeads: context.turnHeads
+			})))._tag === "Failure") {
+				const stamp = yield* makeEventStamp();
+				yield* offerRuntimeEventForContext(context, {
+					type: "session.exited",
+					eventId: stamp.eventId,
+					provider: PROVIDER,
+					createdAt: stamp.createdAt,
+					threadId,
+					payload: {
+						reason: "Claude could not restart after a failed rewind",
+						exitKind: "error"
+					},
+					providerRefs: {}
+				});
+			}
+			return yield* refuse(`Claude refused to rewind this conversation, so nothing was changed. ${refusal}`);
+		}).pipe(effect.Effect.ensuring(effect.Effect.sync(() => rewindingThreads.delete(threadId))));
 	});
 	const respondToRequest = effect.Effect.fn("respondToRequest")(function* (threadId, requestId, decision) {
 		const context = yield* requireSession(threadId);
@@ -3728,9 +4904,15 @@ const makeClaudeAdapter = effect.Effect.fn("makeClaudeAdapter")(function* (claud
 	yield* effect.Effect.addFinalizer(() => effect.Effect.forEach(sessions, ([, context]) => stopSessionInternal(context, { emitExitEvent: false }), { discard: true }).pipe(effect.Effect.tap(() => runtimeEventQueueMetrics.reset), effect.Effect.tap(() => effect.Queue.shutdown(runtimeEventQueue))));
 	return {
 		provider: PROVIDER,
-		capabilities: { sessionModelSwitch: "in-session" },
+		capabilities: {
+			sessionModelSwitch: "in-session",
+			conversationRollback: "native",
+			turnSteering: "native",
+			resumeSurvivesCwdChange: false
+		},
 		startSession,
 		sendTurn,
+		steerTurn,
 		interruptTurn,
 		stopBackgroundTask,
 		readThread,