@p4code/cli 0.1.5 → 0.1.7

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$73 = () => {
 const layer$69 = Layer.sync(NetService, make$73);
 //#endregion
 //#region package.json
-var version = "0.1.5";
+var version = "0.1.7";
 //#endregion
 //#region src/config.ts
 /**
@@ -5724,6 +5724,13 @@ const TaskBoardSource = Schema$1.Literals(["local", "hub"]);
 const ServerSettings = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	enableProviderUpdateChecks: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* The Claude SDK preset system prompt omits the interactive CLI's
+	* terminal-tone sections, so the model tends to open a turn with a tool call
+	* instead of saying what it is about to do. This appends that instruction
+	* back for sessions started by the Claude provider.
+	*/
+	enableToolCallNarration: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	automaticGitFetchInterval: Schema$1.DurationFromMillis.pipe(Schema$1.withDecodingDefault(Effect.succeed(Duration.toMillis(DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL)))),
 	defaultThreadEnvMode: ThreadEnvMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("local"))),
 	newWorktreesStartFromOrigin: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
@@ -5850,6 +5857,7 @@ const OpenCodeSettingsPatch = Schema$1.Struct({
 const ServerSettingsPatch = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.optionalKey(Schema$1.Boolean),
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
+	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
 	automaticGitFetchInterval: Schema$1.optionalKey(Schema$1.DurationFromMillis),
 	defaultThreadEnvMode: Schema$1.optionalKey(ThreadEnvMode),
 	newWorktreesStartFromOrigin: Schema$1.optionalKey(Schema$1.Boolean),
@@ -31470,6 +31478,287 @@ const make$39 = Effect.gen(function* () {
 });
 const layer$34 = Layer.effect(CheckpointDiffQuery, make$39);
 //#endregion
+//#region ../../packages/shared/src/toolCategory.ts
+const TOOL_CATEGORY_TITLES = {
+	file_read: "File read",
+	file_search: "File search",
+	file_change: "File change",
+	command: "Command run",
+	version_control: "Version control",
+	build_test: "Build or test",
+	mcp_tool: "MCP tool call",
+	subagent: "Subagent task",
+	web_search: "Web search",
+	web_fetch: "Web fetch",
+	task_plan: "Task or plan",
+	image_view: "Image view",
+	tool: "Tool call"
+};
+new Set(Object.keys(TOOL_CATEGORY_TITLES));
+/** Exact tool names, lowercased, matched before the substring heuristics below. */
+const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read",
+	"readfile",
+	"read_file",
+	"view",
+	"viewfile",
+	"view_file",
+	"notebookread",
+	"notebook_read",
+	"openfile",
+	"open_file"
+]);
+const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"grep",
+	"glob",
+	"search",
+	"filesearch",
+	"file_search",
+	"codebasesearch",
+	"codebase_search",
+	"listdir",
+	"list_dir",
+	"list_directory",
+	"ls"
+]);
+const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"multiedit",
+	"multi_edit",
+	"notebookedit",
+	"notebook_edit",
+	"applypatch",
+	"apply_patch",
+	"patch",
+	"createfile",
+	"create_file",
+	"strreplace",
+	"str_replace",
+	"deletefile",
+	"delete_file"
+]);
+const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"shell",
+	"terminal",
+	"exec",
+	"execute",
+	"execcommand",
+	"exec_command",
+	"runcommand",
+	"run_command",
+	"local_shell"
+]);
+const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task",
+	"agent",
+	"subagent",
+	"sub_agent"
+]);
+const WEB_FETCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"webfetch",
+	"web_fetch",
+	"fetch",
+	"fetchurl",
+	"fetch_url",
+	"browse",
+	"openurl",
+	"open_url"
+]);
+/**
+* Matched before the subagent rules, so `task_create` is a board write while the
+* bare `Task` tool stays a subagent.
+*/
+const TASK_PLAN_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"todowrite",
+	"todo_write",
+	"todoread",
+	"todo_read",
+	"exitplanmode",
+	"exit_plan_mode",
+	"updateplan",
+	"update_plan",
+	"task_create",
+	"task_update",
+	"task_list",
+	"task_get",
+	"task_current",
+	"task_propose",
+	"taskcreate",
+	"taskupdate",
+	"tasklist",
+	"taskget"
+]);
+/** Shell builtins that say nothing about what the command as a whole does. */
+const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cd",
+	"echo",
+	"printf",
+	"pwd",
+	"true",
+	"false",
+	"time"
+]);
+/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
+const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cat",
+	"head",
+	"tail",
+	"less",
+	"more",
+	"bat",
+	"nl",
+	"jq",
+	"wc"
+]);
+const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"grep",
+	"egrep",
+	"fgrep",
+	"rg",
+	"ag",
+	"ack",
+	"find",
+	"fd",
+	"ls",
+	"tree",
+	"which"
+]);
+/** `git status` and `git diff` sort here too: the verb is what a reader scans for. */
+const VERSION_CONTROL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"git",
+	"gh",
+	"jj",
+	"hg",
+	"svn",
+	"glab"
+]);
+/**
+* Builds, tests, type checks, lint and install share one category: a test run is
+* what a person scans for when a turn goes long, and the rest is the same noise.
+*/
+const BUILD_TEST_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"npx",
+	"yarn",
+	"bun",
+	"bunx",
+	"vitest",
+	"jest",
+	"vp",
+	"tsc",
+	"tsgo",
+	"eslint",
+	"oxlint",
+	"biome",
+	"prettier",
+	"ruff",
+	"pytest",
+	"make",
+	"cargo",
+	"gradle",
+	"mvn",
+	"xcodebuild",
+	"swift",
+	"pip",
+	"uv",
+	"poetry"
+]);
+const WEB_FETCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"curl",
+	"wget",
+	"http",
+	"httpie"
+]);
+const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
+const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
+const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
+/** Redirect targets that discard output instead of writing a file. */
+const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
+	"/dev/null",
+	"&1",
+	"&2"
+]);
+function toolCategoryTitle(category) {
+	return TOOL_CATEGORY_TITLES[category];
+}
+function readCommandInput(toolInput) {
+	const raw = toolInput?.command ?? toolInput?.cmd;
+	if (typeof raw !== "string") return;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** `cat x > y` reads and writes; only the write matters for the row heading. */
+function redirectsToFile(segment) {
+	for (const match of segment.matchAll(REDIRECT_TARGET)) {
+		const target = match.groups?.target;
+		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
+	}
+	return false;
+}
+function classifyShellSegment(segment) {
+	if (redirectsToFile(segment)) return "command";
+	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
+	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
+	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
+	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
+	if (VERSION_CONTROL_SHELL_COMMANDS.has(head)) return "version_control";
+	if (BUILD_TEST_SHELL_COMMANDS.has(head)) return "build_test";
+	if (WEB_FETCH_SHELL_COMMANDS.has(head)) return "web_fetch";
+	return "command";
+}
+/**
+* A shell call only counts as anything narrower than a command when every
+* non-neutral segment agrees; anything unrecognized (or write-ish) keeps the
+* whole call a command, and so does a pipeline that mixes two categories — the
+* one exception being a read piped into a search, which is still a search.
+* Quoted separators split segments too, which can only downgrade to "command".
+*/
+function classifyShellCommand(command) {
+	const categories = new Set(command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0));
+	if (categories.size === 0 || categories.has("command")) return "command";
+	const [only] = categories;
+	if (categories.size === 1 && only) return only;
+	return [...categories].every((category) => category === "file_read" || category === "file_search") ? "file_search" : "command";
+}
+function classifyToolCategory(input) {
+	const normalized = input.toolName.trim().toLowerCase();
+	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
+	if (TASK_PLAN_TOOL_NAMES.has(normalized)) return "task_plan";
+	if (WEB_FETCH_TOOL_NAMES.has(normalized)) return "web_fetch";
+	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
+	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
+	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
+	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
+	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+		const command = readCommandInput(input.toolInput);
+		return command ? classifyShellCommand(command) : "command";
+	}
+	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
+	if (normalized.includes("webfetch") || normalized.includes("web_fetch")) return "web_fetch";
+	if (normalized.includes("todo") || normalized.includes("plan")) return "task_plan";
+	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
+	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
+	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
+	if (normalized.includes("image")) return "image_view";
+	return "tool";
+}
+function asRecord$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+/** Classify from a runtime item payload's `data` (`{ toolName, input }`). */
+function classifyToolCategoryFromToolData(data) {
+	const record = asRecord$2(data);
+	const toolName = record?.toolName;
+	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
+	return classifyToolCategory({
+		toolName,
+		toolInput: asRecord$2(record?.input)
+	});
+}
+//#endregion
 //#region src/orchestration/ActivityPayloadProjection.ts
 function asRecord$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -31571,9 +31860,13 @@ function projectActivityPayload(activity) {
 	const item = projectCommandData(data);
 	if (item) projectedData.item = item;
 	if ("command" in data) projectedData.command = data.command;
+	const input = asRecord$1(data.input);
+	if (input && "command" in input) projectedData.input = { command: input.command };
 	const changedFiles = [];
 	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
 	if (changedFiles.length > 0) projectedData.files = changedFiles.map((path) => ({ path }));
+	const toolCategory = classifyToolCategoryFromToolData(data);
+	if (toolCategory) projectedData.toolCategory = toolCategory;
 	if ("toolCallId" in data) projectedData.toolCallId = data.toolCallId;
 	if ("kind" in data) projectedData.kind = data.kind;
 	const rawOutput = projectRawOutput(data.rawOutput);
@@ -47043,17 +47336,17 @@ function summarizeToolRequest(toolName, input) {
 	if (serialized.length <= TOOL_SUMMARY_MAX_LENGTH) return `${toolName}: ${serialized}`;
 	return `${toolName}: ${serialized.slice(0, TOOL_SUMMARY_MAX_LENGTH - 3)}...`;
 }
-function titleForTool(itemType) {
-	switch (itemType) {
-		case "command_execution": return "Command run";
-		case "file_change": return "File change";
-		case "mcp_tool_call": return "MCP tool call";
-		case "collab_agent_tool_call": return "Subagent task";
-		case "web_search": return "Web search";
-		case "image_view": return "Image view";
-		case "dynamic_tool_call": return "Tool call";
-		default: return "Item";
-	}
+/**
+* Heading for a tool row. Derived from the tool name plus its input so a `Read`
+* reads as "File read" instead of a bare "Tool call", and a `Bash` that only
+* inspects a file (`sed -n 1,20p src/x.ts`) reads as "File read" instead of
+* "Command run". Recomputed as streamed input arrives.
+*/
+function titleForTool(toolName, toolInput) {
+	return toolCategoryTitle(classifyToolCategory({
+		toolName,
+		toolInput
+	}));
 }
 const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/gif",
@@ -47061,6 +47354,14 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 	"image/png",
 	"image/webp"
 ]);
+/**
+* Appended to the preset system prompt when `narrateBeforeTools` is on. The SDK
+* preset drops the interactive CLI's terminal-tone sections, so without this the
+* model opens a turn with a tool call rather than a line saying what it is doing.
+*/
+/** Emitted by the CLI but absent from the SDK's `SDKMessage` union. */
+const UNTYPED_COMMAND_LIFECYCLE_MESSAGE = "command_lifecycle";
+const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
 	"project",
@@ -47786,6 +48087,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		});
 		const updatedAt = yield* nowIso;
 		context.turnState = void 0;
+		context.steeredMessages.clear();
 		context.session = {
 			...context.session,
 			status: "ready",
@@ -47832,6 +48134,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const updatedAt = yield* nowIso;
 		context.turnState = turnState;
 		context.interruptRequested = false;
+		context.steeredMessages.clear();
 		context.session = {
 			...context.session,
 			status: "running",
@@ -47853,24 +48156,49 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	/**
 	* Start the queued sendTurn, if the session has gone idle.
 	*
-	* Runs after every turn completion. Messages sent during a running turn wait
-	* here for the agent loop to end; pressing Stop ends the loop early, and the
-	* same drain is what makes Stop mean "and run my messages now". Everything
-	* queued during that turn is already merged into one request by `sendTurn`,
-	* so it starts as a single turn.
+	* Runs after every turn completion. What waits here are the steers Stop took
+	* back from the CLI before they ran (see `reclaimSteeredMessages`); they are
+	* already merged into one request, so they start as a single turn the moment
+	* the interrupted loop ends.
 	*/
 	const drainPendingTurns = Effect.fn("drainPendingTurns")(function* (context) {
 		if (context.stopped || context.turnState !== void 0) return;
 		const pending = context.pendingTurnRequest;
 		if (pending === void 0) return;
 		context.pendingTurnRequest = void 0;
-		yield* applyTurnSessionOptions(context, pending.modelSelection, pending.interactionMode).pipe(Effect.catchCause((cause) => Effect.logWarning("claude pending turn session options failed", { cause })));
-		yield* beginTurn(context, pending.turnId, pending.modelSelection?.model);
+		yield* beginTurn(context, pending.turnId, context.session.model);
 		yield* Queue.offer(context.promptQueue, {
 			type: "message",
 			message: pending.message
 		}).pipe(Effect.ignore);
 	});
+	/**
+	* Take back the steers the CLI has not started yet, so Stop still runs them.
+	*
+	* A steer sits in the CLI's async-message queue until the agent loop reaches
+	* its next boundary. `cancelAsyncMessage` answers true only while it is still
+	* waiting there: those never reached the model and become the next turn
+	* together, while an already-dequeued one is part of the turn being stopped
+	* and must not run a second time.
+	*/
+	const reclaimSteeredMessages = Effect.fn("reclaimSteeredMessages")(function* (context) {
+		const steered = Array.from(context.steeredMessages);
+		context.steeredMessages.clear();
+		const cancelAsyncMessage = context.query.cancelAsyncMessage;
+		if (steered.length === 0 || cancelAsyncMessage === void 0) return;
+		const reclaimed = [];
+		for (const [messageUuid, message] of steered) if (yield* Effect.tryPromise({
+			try: () => cancelAsyncMessage(messageUuid),
+			catch: (cause) => toRequestError$1(context.session.threadId, "turn/cancelAsyncMessage", cause)
+		}).pipe(Effect.catchCause((cause) => Effect.logWarning("claude steer cancel failed", { cause }).pipe(Effect.as(false))))) reclaimed.push(message);
+		if (reclaimed.length === 0) return;
+		const merged = reclaimed.reduce((left, right) => mergeUserMessages(left, right));
+		const pending = context.pendingTurnRequest;
+		context.pendingTurnRequest = {
+			turnId: pending?.turnId ?? TurnId.make(yield* randomUUIDv4),
+			message: pending ? mergeUserMessages(pending.message, merged) : merged
+		};
+	});
 	const handleStreamEvent = Effect.fn("handleStreamEvent")(function* (context, message) {
 		if (message.type !== "stream_event") return;
 		const { event } = message;
@@ -47921,11 +48249,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				const partialInputJson = tool.partialInputJson + event.delta.partial_json;
 				const parsedInput = tryParseJsonRecord(partialInputJson);
 				const detail = parsedInput ? summarizeToolRequest(tool.toolName, parsedInput) : tool.detail;
+				const title = parsedInput ? titleForTool(tool.toolName, parsedInput) : tool.title;
 				let nextTool = {
 					...tool,
 					partialInputJson,
 					...parsedInput ? { input: parsedInput } : {},
-					...detail ? { detail } : {}
+					...detail ? { detail } : {},
+					title
 				};
 				const nextFingerprint = parsedInput && Object.keys(parsedInput).length > 0 ? toolInputFingerprint(parsedInput) : void 0;
 				context.inFlightTools.set(event.index, nextTool);
@@ -47998,7 +48328,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				itemId,
 				itemType,
 				toolName,
-				title: titleForTool(itemType),
+				title: titleForTool(toolName, toolInput),
 				detail,
 				input: toolInput,
 				partialInputJson: "",
@@ -48476,6 +48806,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const handleSdkMessage = Effect.fn("handleSdkMessage")(function* (context, message) {
 		yield* logNativeSdkMessage(context, message);
 		yield* ensureThreadId(context, message);
+		if (message.type === UNTYPED_COMMAND_LIFECYCLE_MESSAGE) return;
 		switch (message.type) {
 			case "stream_event":
 				yield* handleStreamEvent(context, message);
@@ -48858,13 +49189,15 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		};
 		const mcpSession = readMcpProviderSession(input.threadId);
 		const externalMcpServers = options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers;
+		const narrateBeforeTools = options?.resolveToolCallNarration === void 0 ? DEFAULT_SERVER_SETTINGS.enableToolCallNarration : yield* options.resolveToolCallNarration;
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
 			pathToClaudeCodeExecutable: claudeBinaryPath,
 			systemPrompt: {
 				type: "preset",
-				preset: "claude_code"
+				preset: "claude_code",
+				...narrateBeforeTools ? { append: NARRATE_BEFORE_TOOLS_PROMPT } : {}
 			},
 			settingSources: [...CLAUDE_SETTING_SOURCES],
 			...effectiveEffort ? { effort: effectiveEffort } : {},
@@ -48906,6 +49239,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			"claude.query.include_partial_messages": true,
 			"claude.query.additional_directories": input.cwd ? [input.cwd] : [],
 			"claude.query.setting_sources": [...CLAUDE_SETTING_SOURCES],
+			"claude.query.narrate_before_tools": narrateBeforeTools,
 			"claude.query.settings_json": encodeJsonStringForDiagnostics$2(settings) ?? "",
 			"claude.query.extra_args_json": encodeJsonStringForDiagnostics$2(extraArgs) ?? "",
 			"claude.query.path_to_executable": claudeBinaryPath
@@ -48956,6 +49290,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			claudeTasks,
 			turnState: void 0,
 			pendingTurnRequest: void 0,
+			steeredMessages: /* @__PURE__ */ new Map(),
 			lastKnownContextWindow: initialContextWindow,
 			lastKnownTokenUsage: void 0,
 			lastKnownTotalProcessedTokens: void 0,
@@ -49024,17 +49359,19 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			boundInstanceId
 		});
 		if (context.turnState) {
-			const pending = context.pendingTurnRequest;
-			const turnId = pending?.turnId ?? TurnId.make(yield* randomUUIDv4);
-			context.pendingTurnRequest = {
-				turnId,
-				message: pending ? mergeUserMessages(pending.message, message) : message,
-				modelSelection,
-				interactionMode: input.interactionMode
+			const steerUuid = yield* randomUUIDv4;
+			const steered = {
+				...message,
+				uuid: steerUuid
 			};
+			context.steeredMessages.set(steerUuid, steered);
+			yield* Queue.offer(context.promptQueue, {
+				type: "message",
+				message: steered
+			}).pipe(Effect.mapError((cause) => toRequestError$1(input.threadId, "turn/start", cause)));
 			return {
 				threadId: context.session.threadId,
-				turnId,
+				turnId: context.turnState.turnId,
 				...context.session.resumeCursor !== void 0 ? { resumeCursor: context.session.resumeCursor } : {}
 			};
 		}
@@ -49054,6 +49391,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const interruptTurn = Effect.fn("interruptTurn")(function* (threadId, _turnId) {
 		const context = yield* requireSession(threadId);
 		context.interruptRequested = true;
+		yield* reclaimSteeredMessages(context);
 		yield* Effect.tryPromise({
 			try: () => context.query.interrupt(),
 			catch: (cause) => toRequestError$1(threadId, "turn/interrupt", cause)
@@ -49312,11 +49650,13 @@ const ClaudeDriver = {
 		});
 		const mcpRegistry = yield* McpRegistry;
 		const resolveDisabledSkills = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => []));
+		const resolveToolCallNarration = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableToolCallNarration), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableToolCallNarration));
 		const adapter = yield* makeClaudeAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
 			resolveMcpServers: mcpRegistry.resolveForSession,
 			resolveDisabledSkills,
+			resolveToolCallNarration,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeClaudeTextGeneration(effectiveConfig, processEnv);
@@ -82205,6 +82545,31 @@ const make$2 = Effect.gen(function* () {
 		},
 		createdAt: input.createdAt
 	})));
+	/**
+	* A successful interrupt otherwise leaves nothing behind: the only row the
+	* timeline ever got was the failure case above, and the turn fold's "You
+	* stopped after Xs" is invisible while the fold is open and says nothing in
+	* the work log. The turn id comes from the request rather than the provider
+	* because orchestration turn ids are not provider turn ids.
+	*/
+	const appendTurnInterruptedActivity = (input) => Effect.all({
+		commandId: serverCommandId("provider-interrupt-activity"),
+		eventId: serverEventId()
+	}).pipe(Effect.flatMap(({ commandId, eventId }) => orchestrationEngine.dispatch({
+		type: "thread.activity.append",
+		commandId,
+		threadId: input.threadId,
+		activity: {
+			id: eventId,
+			tone: "info",
+			kind: "provider.turn.interrupted",
+			summary: "Interrupted by user",
+			payload: {},
+			turnId: input.turnId,
+			createdAt: input.createdAt
+		},
+		createdAt: input.createdAt
+	})));
 	const formatFailureDetail = (cause) => {
 		const failReason = cause.reasons.find(Cause.isFailReason);
 		const providerError = isProviderAdapterRequestError(failReason?.error) ? failReason.error : void 0;
@@ -82591,6 +82956,11 @@ const make$2 = Effect.gen(function* () {
 			createdAt: event.payload.createdAt
 		});
 		yield* providerService.interruptTurn({ threadId: event.payload.threadId });
+		yield* appendTurnInterruptedActivity({
+			threadId: event.payload.threadId,
+			turnId: event.payload.turnId ?? null,
+			createdAt: event.payload.createdAt
+		});
 	});
 	const processApprovalResponseRequested = Effect.fn("processApprovalResponseRequested")(function* (event) {
 		const thread = yield* resolveThread(event.payload.threadId);