@couralabs/claudin 0.1.4 → 0.1.6

package/claudin.js

@@ -5928,6 +5928,12 @@ var backgroundColorSchema = object({
   a: channelSchema
 });
 var TRANSPARENT_BACKGROUND = { r: 0, g: 0, b: 0, a: 0 };
+// packages/events/src/models/customTools.ts
+var CUSTOM_SERVER_NAME = "claudin";
+var BATCH_EDIT_BASE_NAME = "BatchEdit";
+var BATCH_EDIT_TOOL_NAME = `mcp__${CUSTOM_SERVER_NAME}__${BATCH_EDIT_BASE_NAME}`;
+var CUSTOM_PREFIX = `mcp__${CUSTOM_SERVER_NAME}__`;
+var stripCustomPrefix = (toolName) => toolName.startsWith(CUSTOM_PREFIX) ? toolName.slice(CUSTOM_PREFIX.length) : toolName;
 // packages/events/src/models/fileDiff.ts
 var fileDiffSchema = object({
   path: string2(),
@@ -6064,6 +6070,7 @@ function appendEntry(state, entry) {
   };
 }
 var appendNotice = (state, text) => appendEntry(state, { kind: "notice", text });
+var appendMarkdownNotice = (state, text) => appendEntry(state, { kind: "notice", text, markdown: true });
 
 // packages/events/src/reducers/reduceHistory.ts
 var NO_MATCH_NOTICE = "No earlier prompt matches";
@@ -6111,6 +6118,7 @@ var agentSessionId = string2();
 var content = sdkValue();
 var agentOptions = sdkValue().optional();
 var effortLevelSchema = _enum(["low", "medium", "high", "xhigh", "max"]);
+var DEFAULT_EFFORT = "high";
 var permissionModeSchema = _enum(["auto", "acceptEdits", "bypassPermissions", "dontAsk"]);
 var DEFAULT_PERMISSION_MODE = "bypassPermissions";
 var PERMISSION_MODE_LABELS = {
@@ -6145,9 +6153,8 @@ var agentRequestSchemas = [
     options: agentOptions
   }),
   object({ type: literal("agent.prompt.requested"), agentSessionId, content }),
-  object({ type: literal("agent.prompt.queue.requested"), agentSessionId, content }),
-  object({ type: literal("agent.prompt.steer.requested"), agentSessionId, content }),
   object({ type: literal("agent.prompt.cancel.requested"), agentSessionId }),
+  object({ type: literal("agent.task.stop.requested"), agentSessionId, taskId: string2() }),
   object({
     type: literal("agent.tool.approval.answered"),
     agentSessionId,
@@ -6217,6 +6224,8 @@ var createSessionState = (sessionId) => ({
   models: [],
   sessionList: [],
   queuedTurns: 0,
+  queuedPrompts: [],
+  tasks: [],
   transcript: [],
   entryCounter: 0,
   now: Date.now(),
@@ -6315,10 +6324,11 @@ function describeSystemMessage(message) {
 var OPEN_STATUSES = new Set(["running", "awaiting_approval", "awaiting_answer"]);
 var isToolsEntry = (entry) => entry.kind === "tools";
 var listToolCalls = (state) => state.transcript.filter(isToolsEntry).flatMap((entry) => entry.calls);
-var EDIT_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
-var readEditedPath = ({ input }) => input.file_path ?? input.notebook_path;
+var EDIT_TOOLS = new Set(["Write", "Edit", "MultiEdit", "mcp__claudin__BatchEdit"]);
+var listBatchEditPaths = (input) => Array.isArray(input.edits) ? input.edits.map((edit) => edit?.file_path) : [];
+var readEditedPaths = (call) => call.name === BATCH_EDIT_TOOL_NAME ? listBatchEditPaths(call.input) : EDIT_TOOLS.has(call.name) ? [call.input.file_path ?? call.input.notebook_path] : [];
 var listEditedFiles = (state) => [
-  ...new Set(listToolCalls(state).filter((call) => EDIT_TOOLS.has(call.name) && call.status === "completed").map(readEditedPath).filter((path) => typeof path === "string"))
+  ...new Set(listToolCalls(state).filter((call) => call.status === "completed").flatMap(readEditedPaths).filter((path) => typeof path === "string"))
 ];
 function countTurnTools(state) {
   const lastUser = state.transcript.findLastIndex((entry) => entry.kind === "user");
@@ -6517,6 +6527,43 @@ function reduceStreamEvent(state, event) {
   }
 }
 
+// packages/events/src/reducers/reduceTaskModel.ts
+var readMessageModel = (message) => {
+  if (message.type === "assistant")
+    return message.message.model;
+  if (message.type !== "stream_event")
+    return;
+  const event = message.event;
+  return event.type === "message_start" ? event.message?.model : undefined;
+};
+var readRequestedModel = (state, toolUseId) => {
+  const model = listToolCalls(state).find((call) => call.id === toolUseId)?.input.model;
+  return typeof model === "string" ? model : undefined;
+};
+function reduceTaskModel(state, message) {
+  if (message.type !== "assistant" && message.type !== "stream_event")
+    return state;
+  const model = readMessageModel(message);
+  const parentId = message.parent_tool_use_id;
+  const stale = (task) => task.toolUseId === parentId && task.model !== model;
+  if (!model || !parentId || !state.tasks.some(stale))
+    return state;
+  const tasks = state.tasks.map((task) => stale(task) ? { ...task, model } : task);
+  return { ...state, tasks };
+}
+
+// packages/events/src/reducers/reduceTaskToolUse.ts
+function reduceTaskToolUse(state, message) {
+  if (message.type !== "assistant" || !message.parent_tool_use_id)
+    return state;
+  const call = message.message.content.findLast((block) => block.type === "tool_use");
+  if (call?.type !== "tool_use")
+    return state;
+  const lastToolCall = { name: call.name, input: call.input ?? {} };
+  const tasks = state.tasks.map((task) => task.toolUseId === message.parent_tool_use_id ? { ...task, lastToolCall } : task);
+  return { ...state, tasks };
+}
+
 // packages/events/src/reducers/reduceTaskProgress.ts
 function reduceTaskProgress(state, message) {
   const { tool_use_id: toolUseId, summary } = message;
@@ -6525,6 +6572,58 @@ function reduceTaskProgress(state, message) {
   return updateToolCall(state, toolUseId, (call) => ({ ...call, progress: summary }));
 }
 
+// packages/events/src/reducers/reduceTasks.ts
+var FINISHED_STATUSES = ["completed", "failed", "killed"];
+var isTaskMessage = (message) => message.type === "system" && ["task_started", "task_progress", "task_updated", "task_notification"].includes(message.subtype);
+var patchTask = (tasks, id, patch) => tasks.map((task) => task.id === id ? patch(task) : task);
+var startTask = (state, message) => {
+  if (message.ambient || message.skip_transcript)
+    return state.tasks;
+  const task = {
+    id: message.task_id,
+    kind: message.subagent_type ?? message.task_type ?? "task",
+    description: message.description,
+    startedAt: state.now,
+    toolUseId: message.tool_use_id,
+    model: readRequestedModel(state, message.tool_use_id),
+    tokens: 0,
+    paused: false
+  };
+  return [...state.tasks.filter(({ id }) => id !== task.id), task];
+};
+var updateTask = (tasks, message) => {
+  const { status, description } = message.patch;
+  if (status && FINISHED_STATUSES.includes(status)) {
+    return tasks.filter(({ id }) => id !== message.task_id);
+  }
+  return patchTask(tasks, message.task_id, (task) => ({
+    ...task,
+    description: description ?? task.description,
+    paused: status ? status === "paused" : task.paused
+  }));
+};
+var readTasks = (state, message) => {
+  switch (message.subtype) {
+    case "task_started":
+      return startTask(state, message);
+    case "task_progress":
+      return patchTask(state.tasks, message.task_id, (task) => ({
+        ...task,
+        lastToolName: message.last_tool_name ?? task.lastToolName,
+        summary: message.summary ?? task.summary,
+        tokens: message.usage.total_tokens
+      }));
+    case "task_updated":
+      return updateTask(state.tasks, message);
+    case "task_notification":
+      return state.tasks.filter(({ id }) => id !== message.task_id);
+  }
+};
+var reduceTasks = (state, message) => ({
+  ...state,
+  tasks: readTasks(state, message)
+});
+
 // packages/events/src/reducers/reduceToolResults.ts
 function applyResult(state, block) {
   if (block.type !== "tool_result" || !block.tool_use_id)
@@ -6542,10 +6641,10 @@ function reduceToolResults(state, message) {
 
 // packages/events/src/reducers/reduceAgentMessage.ts
 function reduceAgentMessage(state, message) {
+  if (isTaskMessage(message))
+    return reduceTaskMessage(reduceTasks(state, message), message);
   switch (message.type) {
     case "system":
-      if (message.subtype === "task_progress")
-        return reduceTaskProgress(state, message);
       if (message.subtype !== "init")
         return reduceNoticeMessage(state, message);
       return {
@@ -6557,9 +6656,12 @@ function reduceAgentMessage(state, message) {
       };
     case "stream_event":
       if (message.parent_tool_use_id)
-        return state;
+        return reduceTaskModel(state, message);
       return reduceStreamEvent(state, message.event);
     case "assistant":
+      if (message.parent_tool_use_id) {
+        return reduceTaskToolUse(reduceTaskModel(state, message), message);
+      }
       return reduceAssistant(state, message);
     case "user":
       return isPromptEcho(message) ? reduceCheckpoint(state, message) : reduceToolResults(state, message);
@@ -6571,6 +6673,16 @@ function reduceAgentMessage(state, message) {
       return reduceNoticeMessage(state, message);
   }
 }
+function reduceTaskMessage(state, message) {
+  if (message.type === "system" && message.subtype === "task_progress") {
+    return reduceTaskProgress(state, message);
+  }
+  if (message.type === "system" && message.subtype === "task_notification") {
+    const text = describeSystemMessage(message);
+    return text ? appendMarkdownNotice(state, text) : state;
+  }
+  return state;
+}
 function reduceNoticeMessage(state, message) {
   const text = describeSystemMessage(message);
   return text ? appendNotice(state, text) : state;
@@ -6751,6 +6863,23 @@ function changeQuestionCustom(state, text) {
   return question ? withDraft(state, { ...question, custom: text }) : state;
 }
 
+// packages/events/src/reducers/reduceTheme.ts
+var applyLoadedTheme = (state, theme = state.theme) => ({
+  ...state,
+  theme
+});
+var applySavedTheme = (state, theme) => appendNotice({ ...state, theme }, `Theme set to ${theme}`);
+
+// packages/events/src/reducers/reducePromptQueue.ts
+var queuePrompt = (state, content) => ({
+  ...state,
+  queuedPrompts: [...state.queuedPrompts, content]
+});
+var dequeuePrompt = (state) => ({
+  ...state,
+  queuedPrompts: state.queuedPrompts.slice(1)
+});
+
 // packages/events/src/reducers/reduceToast.ts
 var withToast = (state, toast) => ({
   ...state,
@@ -6778,6 +6907,8 @@ var pickerSize = (state, kind) => {
     return state.models.length;
   if (kind === "theme")
     return THEME_NAMES.length;
+  if (kind === "effort")
+    return effortLevelSchema.options.length;
   if (kind === "rewind")
     return listCheckpoints(state).length;
   return state.sessionList.length;
@@ -6796,6 +6927,11 @@ var openThemePicker = (state) => {
   const selected = Math.max(THEME_NAMES.indexOf(state.theme), 0);
   return { ...state, ui: { ...state.ui, picker: { kind: "theme", selected } } };
 };
+var openEffortPicker = (state) => {
+  const current = state.effort || DEFAULT_EFFORT;
+  const selected = Math.max(effortLevelSchema.options.findIndex((level) => level === current), 0);
+  return { ...state, ui: { ...state.ui, picker: { kind: "effort", selected } } };
+};
 function openRewindPicker(state) {
   const size = listCheckpoints(state).length;
   if (size === 0)
@@ -6820,8 +6956,12 @@ function reduceUi(state, event) {
       return { ...state, ui: { ...state.ui, picker: null } };
     case "ui.theme.picker.opened":
       return openThemePicker(state);
-    case "ui.theme.selected":
-      return appendNotice({ ...state, theme: event.theme }, `Theme set to ${event.theme}`);
+    case "ui.effort.picker.opened":
+      return openEffortPicker(state);
+    case "ui.prompt.queued":
+      return queuePrompt(state, event.content);
+    case "ui.prompt.dequeued":
+      return dequeuePrompt(state);
     case "ui.rewind.picker.opened":
       return openRewindPicker(state);
     case "ui.history.moved":
@@ -6855,6 +6995,7 @@ function reduceUi(state, event) {
     case "ui.question.recorded":
       return recordQuestionAnswer(state, event);
     case "ui.exit.requested":
+    case "ui.title.set":
       return state;
     case "ui.notice.posted":
       return appendNotice(state, event.text);
@@ -6899,9 +7040,6 @@ var reduceTimedEvent = (state, event, at) => reduceSessionState({ ...state, now:
 function reduceSessionState(state, event) {
   switch (event.type) {
     case "agent.prompt.requested":
-      return reducePrompt(state, event.content, false);
-    case "agent.prompt.queue.requested":
-    case "agent.prompt.steer.requested":
       return reducePrompt(state, event.content, state.status !== "idle");
     case "agent.message.received":
       return reduceAgentMessage(state, event.message);
@@ -6978,9 +7116,11 @@ function reduceSessionState(state, event) {
     case "workspace.info.received":
       return { ...state, cwd: event.cwd, gitBranch: event.gitBranch, gitStats: event.gitStats };
     case "options.loaded":
-      return applyLoadedBackground(state, event.background);
+      return applyLoadedTheme(applyLoadedBackground(state, event.background), event.theme);
     case "options.background.saved":
       return applySavedBackground(state, event.color);
+    case "options.theme.saved":
+      return applySavedTheme(state, event.theme);
     case "workspace.files.received":
       return updateFileMatches(state, event.query, event.matches);
     default:
@@ -6993,13 +7133,22 @@ var optionsRequestSchemas = [
   object({
     type: literal("options.background.save.requested"),
     color: backgroundColorSchema
-  })
+  }),
+  object({ type: literal("options.theme.save.requested"), theme: themeNameSchema })
 ];
 var optionsResponseSchemas = [
-  object({ type: literal("options.loaded"), background: backgroundColorSchema.optional() }),
-  object({ type: literal("options.background.saved"), color: backgroundColorSchema })
+  object({
+    type: literal("options.loaded"),
+    background: backgroundColorSchema.optional(),
+    theme: themeNameSchema.optional()
+  }),
+  object({ type: literal("options.background.saved"), color: backgroundColorSchema }),
+  object({ type: literal("options.theme.saved"), theme: themeNameSchema })
 ];
-var optionsFileSchema = looseObject({ background: backgroundColorSchema.optional() });
+var optionsFileSchema = looseObject({
+  background: backgroundColorSchema.optional(),
+  theme: themeNameSchema.optional()
+});
 // packages/events/src/requests/sessionRequestEvents.ts
 var sessionRequestSchemas = [
   object({ type: literal("session.create.requested") }),
@@ -7060,7 +7209,6 @@ var agentResponseSchemas = [
   }),
   object({ type: literal("agent.session.created"), agentSessionId: agentSessionId2 }),
   object({ type: literal("agent.message.received"), message: unknown() }),
-  object({ type: literal("agent.prompt.accepted"), agentSessionId: agentSessionId2 }),
   object({ type: literal("agent.prompt.cancelled"), agentSessionId: agentSessionId2 }),
   object({
     type: literal("agent.tool.approval.required"),
@@ -7470,11 +7618,10 @@ var sdkRuntime = {
 };
 // packages/agent/src/runtime/buildUserMessage.ts
 var isSlashCommand = (content) => readPromptText(content).trimStart().startsWith("/");
-var buildUserMessage = (content, priority) => ({
+var buildUserMessage = (content) => ({
   type: "user",
   message: { role: "user", content },
   parent_tool_use_id: null,
-  priority,
   client_composed: isSlashCommand(content) ? undefined : true
 });
 // node_modules/.bun/p-defer@4.0.1/node_modules/p-defer/index.js
@@ -8699,6 +8846,110 @@ class PermissionGate {
   }
 }
 
+// packages/agent/src/tools/customToolsServer.ts
+import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+
+// packages/agent/src/tools/batchEdit/batchEditTool.ts
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+
+// packages/agent/src/tools/batchEdit/batchEditSchema.ts
+var textEditSchema = object({
+  file_path: string2().describe("Absolute path of the file to modify"),
+  old_string: string2().describe("Exact text to replace; empty only to create a new file with new_string"),
+  new_string: string2().describe("Replacement text; must differ from old_string"),
+  replace_all: boolean2().optional().describe("Replace every occurrence of old_string")
+});
+var batchEditShape = {
+  edits: array(textEditSchema).min(1).describe("Edits applied in order; edits to one file see the result of earlier ones")
+};
+
+// packages/agent/src/tools/batchEdit/stageEdits.ts
+import { isAbsolute, resolve } from "path";
+
+// packages/agent/src/tools/batchEdit/applyTextEdit.ts
+var failEdit = (reason) => ({ ok: false, reason });
+function applyTextEdit(content, edit) {
+  const { old_string: oldText, new_string: newText, replace_all: replaceAll } = edit;
+  if (oldText === newText)
+    return failEdit("old_string and new_string are identical");
+  if (oldText === "") {
+    return content === "" ? { ok: true, content: newText, replacements: 1 } : failEdit("old_string is empty but the file already has content");
+  }
+  const parts = content.split(oldText);
+  const matches = parts.length - 1;
+  if (matches === 0)
+    return failEdit("old_string was not found in the file");
+  if (matches > 1 && !replaceAll) {
+    return failEdit(`old_string matches ${matches} times; add context or set replace_all`);
+  }
+  return { ok: true, content: parts.join(newText), replacements: matches };
+}
+
+// packages/agent/src/tools/batchEdit/stageEdits.ts
+var failStage = (index, edit, reason) => ({
+  ok: false,
+  message: `Edit ${index + 1} (${edit.file_path}): ${reason}`
+});
+async function stageEdits(edits, readFile) {
+  const files = new Map;
+  for (const [index, edit] of edits.entries()) {
+    if (!isAbsolute(edit.file_path))
+      return failStage(index, edit, "file_path must be absolute");
+    const path = resolve(edit.file_path);
+    const current = files.get(path)?.content ?? await readFile(path);
+    if (current === undefined && edit.old_string !== "") {
+      return failStage(index, edit, "the file does not exist");
+    }
+    const outcome = applyTextEdit(current ?? "", edit);
+    if (!outcome.ok)
+      return failStage(index, edit, outcome.reason);
+    const replacements = (files.get(path)?.replacements ?? 0) + outcome.replacements;
+    files.set(path, { content: outcome.content, replacements });
+  }
+  return { ok: true, files };
+}
+
+// packages/agent/src/tools/batchEdit/runBatchEdit.ts
+var readFileText = async (path) => {
+  const file = Bun.file(path);
+  return await file.exists() ? file.text() : undefined;
+};
+var describeFiles = (files) => [...files].map(([path, { replacements }]) => `- ${path}: ${replacements} replacement(s)`).join(`
+`);
+async function runBatchEdit(edits, readFile = readFileText) {
+  const staged = await stageEdits(edits, readFile);
+  if (!staged.ok) {
+    return { isError: true, text: `${staged.message}
+No files were changed.` };
+  }
+  try {
+    await Promise.all([...staged.files].map(([path, { content }]) => Bun.write(path, content)));
+  } catch (error) {
+    return { isError: true, text: `Writing failed, files may be partly changed: ${error}` };
+  }
+  return {
+    isError: false,
+    text: `Applied ${edits.length} edit(s) to ${staged.files.size} file(s):
+${describeFiles(staged.files)}`
+  };
+}
+
+// packages/agent/src/tools/batchEdit/batchEditTool.ts
+var DESCRIPTION = `Apply many exact-string edits across one or more files in a single call. Each edit works like Edit (file_path, old_string, new_string, replace_all). Edits run in order, and edits to the same file build on each other. The batch is all-or-nothing: if any edit fails validation, no file is changed.`;
+var batchEditTool = tool(BATCH_EDIT_BASE_NAME, DESCRIPTION, batchEditShape, async ({ edits }) => {
+  const { isError, text } = await runBatchEdit(edits);
+  return { isError, content: [{ type: "text", text }] };
+});
+
+// packages/agent/src/tools/customToolsServer.ts
+var CUSTOM_MCP_SERVERS = {
+  [CUSTOM_SERVER_NAME]: createSdkMcpServer({
+    name: CUSTOM_SERVER_NAME,
+    tools: [batchEditTool],
+    alwaysLoad: true
+  })
+};
+
 // packages/agent/src/profile/adhdSystemPrompt.ts
 var ADHD_SYSTEM_PROMPT = `For the rest of this session, shape every response for a reader with ADHD. The output is not just brief; it is shaped so an ADHD brain can act on it.
 
@@ -8813,8 +9064,7 @@ var AGENT_TOOLS = [
   "TodoWrite",
   "AskUserQuestion",
   "Write",
-  "Edit",
-  "NotebookEdit"
+  "Edit"
 ];
 var AGENT_DISALLOWED_TOOLS = [
   "Agent(Explore)",
@@ -8841,11 +9091,12 @@ var TOOL_USAGE = {
   AskUserQuestion: "ask the user",
   Write: "create new files with content",
   Edit: "update files",
-  NotebookEdit: "update notebook cells"
+  mcp__claudin__BatchEdit: "update files mutiples files or multiple replaces in same file"
 };
 var TOOL_GUIDANCE = `Always use the dedicated tool, never a workaround:
 ${AGENT_TOOLS.map((tool) => `- Use *${tool}* to ${TOOL_USAGE[tool]}`).join(`
-`)}`;
+`)}
+- Use *${BATCH_EDIT_TOOL_NAME}* instead of repeated *Edit* calls to make several edits, across one or many files, in one call`;
 
 // packages/agent/src/profile/agentSystemPrompt.ts
 var AGENT_SYSTEM_PROMPT = [ADHD_SYSTEM_PROMPT, TOOL_GUIDANCE, SUBAGENT_GUIDANCE].join(`
@@ -8855,6 +9106,8 @@ var AGENT_SYSTEM_PROMPT = [ADHD_SYSTEM_PROMPT, TOOL_GUIDANCE, SUBAGENT_GUIDANCE]
 // packages/agent/src/profile/agentProfile.ts
 var AGENT_PROFILE_OPTIONS = {
   tools: AGENT_TOOLS,
+  mcpServers: CUSTOM_MCP_SERVERS,
+  toolAliases: { [BATCH_EDIT_BASE_NAME]: BATCH_EDIT_TOOL_NAME },
   disallowedTools: AGENT_DISALLOWED_TOOLS,
   systemPrompt: AGENT_SYSTEM_PROMPT,
   agents: AGENT_SUBAGENTS,
@@ -8889,6 +9142,27 @@ var AGENT_PROFILE_OPTIONS = {
   includeHookEvents: true
 };
 
+// packages/agent/src/session/readLiveTaskIds.ts
+var FINISHED_STATUSES2 = ["completed", "failed", "killed"];
+var withTask = (current, id) => new Set([...current, id]);
+var withoutTask = (current, id) => new Set([...current].filter((taskId) => taskId !== id));
+function readLiveTaskIds(message, current) {
+  if (message.type !== "system")
+    return current;
+  switch (message.subtype) {
+    case "background_tasks_changed":
+      return new Set(message.tasks.filter((task) => !task.ambient).map((task) => task.task_id));
+    case "task_started":
+      return message.ambient ? current : withTask(current, message.task_id);
+    case "task_updated":
+      return FINISHED_STATUSES2.includes(message.patch.status ?? "") ? withoutTask(current, message.task_id) : current;
+    case "task_notification":
+      return withoutTask(current, message.task_id);
+    default:
+      return current;
+  }
+}
+
 // packages/agent/src/session/agentSession.ts
 function requireRewind(result) {
   if (!result.canRewind)
@@ -8903,6 +9177,7 @@ class AgentSession {
   elicitations;
   query;
   pendingTurns = 0;
+  liveTaskIds = new Set;
   pumping = false;
   constructor(agentSessionId, baseOptions, runtime) {
     this.baseOptions = baseOptions;
@@ -8918,13 +9193,13 @@ class AgentSession {
       }
     });
   }
-  prompt(content, priority) {
-    this.send(content, priority);
+  prompt(content) {
+    this.send(content);
     return this.streamTurn();
   }
-  send(content, priority) {
+  send(content) {
     this.pendingTurns += 1;
-    this.input.push(buildUserMessage(content, priority));
+    this.input.push(buildUserMessage(content));
   }
   async* streamTurn() {
     if (this.pumping)
@@ -8951,6 +9226,9 @@ class AgentSession {
     this.rejectAllPrompts();
     await this.query.interrupt();
   }
+  stopTask(taskId) {
+    return this.query.stopTask(taskId);
+  }
   async setModel(model) {
     await this.query.setModel(model);
     this.baseOptions = { ...this.baseOptions, model };
@@ -9021,10 +9299,11 @@ class AgentSession {
         if (done)
           break;
         sink.push({ type: "agent.message.received", message: value });
+        this.liveTaskIds = readLiveTaskIds(value, this.liveTaskIds);
         if (value.type !== "result")
           continue;
         this.pendingTurns = Math.max(this.pendingTurns - 1, 0);
-        if (this.pendingTurns === 0)
+        if (this.pendingTurns === 0 && this.liveTaskIds.size === 0)
           break;
       }
       sink.end();
@@ -9091,19 +9370,21 @@ async function readOptions2(path) {
   const parsed = optionsFileSchema.safeParse(stored);
   return parsed.success ? parsed.data : {};
 }
-async function saveBackground(path, background) {
-  await Bun.write(path, JSON.stringify({ ...await readOptions2(path), background }, null, 2));
-}
+var saveOption = async (path, option) => {
+  await Bun.write(path, JSON.stringify({ ...await readOptions2(path), ...option }, null, 2));
+};
+var saveBackground = (path, background) => saveOption(path, { background });
+var saveTheme = (path, theme) => saveOption(path, { theme });
 
 // packages/daemon/src/workspace/resolvePath.ts
 import { stat } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join3, resolve } from "path";
+import { join as join3, resolve as resolve2 } from "path";
 var isDirectory = async (path) => (await stat(path).catch(() => {
   return;
 }))?.isDirectory() ?? false;
 var expandHome = (path) => path === "~" || path.startsWith("~/") ? join3(homedir2(), path.slice(1)) : path;
-var resolveUserPath = (base, path) => resolve(base, expandHome(path.trim()));
+var resolveUserPath = (base, path) => resolve2(base, expandHome(path.trim()));
 
 // packages/daemon/src/server/daemonContext.ts
 var SESSIONS_DIRECTORY = join4(homedir3(), ".claudin", "sessions");
@@ -9171,11 +9452,7 @@ async function createDaemonContext(store = new FileSessionStore(SESSIONS_DIRECTO
 // packages/daemon/src/client/replayClient.ts
 var MAX_GAP_MS = 1500;
 var READ_ONLY_REASON = "Replay is read-only";
-var PROMPT_TYPES = new Set([
-  "agent.prompt.requested",
-  "agent.prompt.queue.requested",
-  "agent.prompt.steer.requested"
-]);
+var PROMPT_TYPES = new Set(["agent.prompt.requested"]);
 
 class ReplayClient {
   stored;
@@ -9288,20 +9565,13 @@ var agentHandlers = {
   async* "agent.prompt.requested"({ agents }, request) {
     yield* agents.requireSession(request.agentSessionId).prompt(request.content);
   },
-  async* "agent.prompt.queue.requested"({ agents }, request) {
-    const turn = agents.requireSession(request.agentSessionId).prompt(request.content, "later");
-    yield { type: "agent.prompt.accepted", agentSessionId: request.agentSessionId };
-    yield* turn;
-  },
-  async* "agent.prompt.steer.requested"({ agents }, request) {
-    const turn = agents.requireSession(request.agentSessionId).prompt(request.content, "now");
-    yield { type: "agent.prompt.accepted", agentSessionId: request.agentSessionId };
-    yield* turn;
-  },
   async* "agent.prompt.cancel.requested"({ agents }, request) {
     await agents.requireSession(request.agentSessionId).cancel();
     yield { type: "agent.prompt.cancelled", agentSessionId: request.agentSessionId };
   },
+  async* "agent.task.stop.requested"({ agents }, request) {
+    await agents.requireSession(request.agentSessionId).stopTask(request.taskId);
+  },
   async* "agent.tool.approval.answered"({ agents }, request) {
     agents.requireSession(request.agentSessionId).answerApproval(request.toolUseId, request.decision);
   },
@@ -9378,12 +9648,16 @@ var agentHandlers = {
 // packages/daemon/src/handlers/optionsHandlers.ts
 var optionsHandlers = {
   async* "options.load.requested"({ optionsPath }) {
-    const { background } = await readOptions2(optionsPath);
-    yield { type: "options.loaded", background };
+    const { background, theme } = await readOptions2(optionsPath);
+    yield { type: "options.loaded", background, theme };
   },
   async* "options.background.save.requested"({ optionsPath }, request) {
     await saveBackground(optionsPath, request.color);
     yield { type: "options.background.saved", color: request.color };
+  },
+  async* "options.theme.save.requested"({ optionsPath }, request) {
+    await saveTheme(optionsPath, request.theme);
+    yield { type: "options.theme.saved", theme: request.theme };
   }
 };
 
@@ -9419,14 +9693,14 @@ var sessionHandlers = {
 };
 
 // packages/daemon/src/workspace/readFileDiffs.ts
-import { relative, resolve as resolve2 } from "path";
+import { relative, resolve as resolve3 } from "path";
 var isTracked = async (cwd, path) => (await Bun.$`git ls-files --error-unmatch -- ${path}`.cwd(cwd).quiet().nothrow()).exitCode === 0;
 async function readPatch(cwd, path) {
   const command = await isTracked(cwd, path) ? Bun.$`git diff --no-color HEAD -- ${path}` : Bun.$`git diff --no-color --no-index -- /dev/null ${path}`;
   return (await command.cwd(cwd).quiet().nothrow()).text();
 }
 async function readFileDiff(cwd, path) {
-  const absolute = resolve2(cwd, path);
+  const absolute = resolve3(cwd, path);
   const patch = await readPatch(cwd, absolute);
   return {
     path: relative(cwd, absolute) || path,
@@ -11134,7 +11408,7 @@ async function startDaemon(port = DEFAULT_PORT, context) {
 }
 // apps/tui/src/startTui.ts
 import {
-  BoxRenderable as BoxRenderable16,
+  BoxRenderable as BoxRenderable19,
   createCliRenderer,
   createHostClipboard
 } from "@opentui/core";
@@ -11176,7 +11450,7 @@ function buildPalette(colors, background = TRANSPARENT_BACKGROUND) {
     },
     fg: {
       primary: hex("text"),
-      secondary: rgbToHex2(tint(color("text"), color("textMuted"), SECONDARY_TEXT_WEIGHT)),
+      secondary: hex("secondary") ?? rgbToHex2(tint(color("text"), color("textMuted"), SECONDARY_TEXT_WEIGHT)),
       muted: hex("textMuted")
     },
     border: { subtle: hex("borderSubtle"), focus: hex("borderActive"), separator: hex("border") },
@@ -11187,7 +11461,38 @@ function buildPalette(colors, background = TRANSPARENT_BACKGROUND) {
       warning: hex("warning"),
       info: hex("info")
     },
-    diff: { addedBg: hex("diffAddedBg"), removedBg: hex("diffRemovedBg") }
+    diff: {
+      addedBg: hex("diffAddedBg"),
+      removedBg: hex("diffRemovedBg"),
+      contextBg: hex("diffContextBg"),
+      addedText: hex("diffAdded"),
+      removedText: hex("diffRemoved"),
+      contextText: hex("diffContext"),
+      lineNumber: hex("diffLineNumber"),
+      addedLineNumberBg: hex("diffAddedLineNumberBg"),
+      removedLineNumberBg: hex("diffRemovedLineNumberBg")
+    },
+    syntax: {
+      comment: hex("syntaxComment"),
+      keyword: hex("syntaxKeyword"),
+      function: hex("syntaxFunction"),
+      variable: hex("syntaxVariable"),
+      string: hex("syntaxString"),
+      number: hex("syntaxNumber"),
+      type: hex("syntaxType"),
+      operator: hex("syntaxOperator"),
+      punctuation: hex("syntaxPunctuation")
+    },
+    markdown: {
+      heading: hex("markdownHeading"),
+      strong: hex("markdownStrong"),
+      emphasis: hex("markdownEmph"),
+      listItem: hex("markdownListItem"),
+      blockQuote: hex("markdownBlockQuote"),
+      code: hex("markdownCode"),
+      link: hex("markdownLink"),
+      linkText: hex("markdownLinkText")
+    }
   };
 }
 // apps/tui/src/theme/assets/aura.json
@@ -18656,10 +18961,16 @@ var createDiffView = (renderer, syntaxStyle, patch, filetype) => new DiffRendera
   syntaxStyle,
   view: "unified",
   showLineNumbers: true,
+  fg: Theme.fg.primary,
   addedBg: Theme.diff.addedBg,
   removedBg: Theme.diff.removedBg,
-  addedSignColor: Theme.status.success,
-  removedSignColor: Theme.status.danger,
+  contextBg: Theme.diff.contextBg,
+  lineNumberFg: Theme.diff.lineNumber,
+  lineNumberBg: Theme.diff.contextBg,
+  addedLineNumberBg: Theme.diff.addedLineNumberBg,
+  removedLineNumberBg: Theme.diff.removedLineNumberBg,
+  addedSignColor: Theme.diff.addedText,
+  removedSignColor: Theme.diff.removedText,
   flexShrink: 0
 });
 
@@ -18948,11 +19259,11 @@ var buildImageBlock = (mediaType, bytes) => ({
 // apps/tui/src/prompt/pastedPaths.ts
 import { statSync } from "fs";
 import { homedir as homedir6 } from "os";
-import { isAbsolute } from "path";
+import { isAbsolute as isAbsolute2 } from "path";
 var unwrapPath = (raw) => raw.trim().replace(/^(['"])(.*)\1$/, "$2").replace(/^file:\/\//, "").replace(/^~(?=\/)/, homedir6()).replace(/\\(.)/g, "$1");
 var isExistingFile = (path) => {
   try {
-    return isAbsolute(path) && statSync(path).isFile();
+    return isAbsolute2(path) && statSync(path).isFile();
   } catch {
     return false;
   }
@@ -18998,7 +19309,7 @@ function planPaste(event, attachments) {
 
 // apps/tui/src/components/promptInput.ts
 var MAX_INPUT_LINES = 8;
-var BUSY_TITLE = " Ctrl+Q (queue) Ctrl+W (steer) ";
+var BUSY_PLACEHOLDER = "Enter (steer) Ctrl+Q (queue)";
 var ATTACHMENT_STYLE = "attachment";
 var PLACEHOLDER = "Type your prompt, /slash command, or @file reference...";
 var KEY_BINDINGS = [
@@ -19020,12 +19331,11 @@ class PromptInput {
   constructor(renderer, handlers) {
     this.renderable = new BoxRenderable5(renderer, {
       border: ["top", "bottom"],
+      borderColor: Theme.fg.muted,
       borderStyle: "rounded",
-      bottomTitleAlignment: "right",
       flexDirection: "row",
       height: 3,
-      flexShrink: 0,
-      paddingLeft: 1
+      flexShrink: 0
     });
     this.attachmentStyle = SyntaxStyle.create(renderer.nativeScene);
     this.textarea = new TextareaRenderable(renderer, {
@@ -19086,16 +19396,15 @@ class PromptInput {
       this.textarea.blur();
   }
   setBusy(busy) {
-    const title = busy ? BUSY_TITLE : undefined;
-    if (this.renderable.bottomTitle !== title)
-      this.renderable.bottomTitle = title;
+    const placeholder = busy ? BUSY_PLACEHOLDER : PLACEHOLDER;
+    if (this.textarea.placeholder !== placeholder)
+      this.textarea.placeholder = placeholder;
   }
   setBorderColor(color) {
     this.renderable.borderColor = color;
   }
   applyColors() {
-    this.renderable.titleColor = Theme.fg.primary;
-    this.chevron.fg = Theme.accent.brand;
+    this.chevron.fg = Theme.fg.muted;
     this.textarea.placeholderColor = Theme.fg.muted;
     this.textarea.textColor = Theme.fg.primary;
     this.textarea.focusedTextColor = Theme.fg.primary;
@@ -19197,6 +19506,25 @@ class AssistantMessageView {
   }
 }
 
+// apps/tui/src/components/markdownNoticeView.ts
+import { MarkdownRenderable as MarkdownRenderable2 } from "@opentui/core";
+
+class MarkdownNoticeView {
+  renderable;
+  constructor(renderer, mutedSyntaxStyle) {
+    this.renderable = new MarkdownRenderable2(renderer, {
+      content: "",
+      syntaxStyle: mutedSyntaxStyle,
+      marginTop: 1,
+      flexShrink: 0
+    });
+  }
+  update(entry) {
+    if (this.renderable.content !== entry.text)
+      this.renderable.content = entry.text;
+  }
+}
+
 // apps/tui/src/components/noticeView.ts
 import { fg as fg7, StyledText as StyledText6, TextRenderable as TextRenderable7 } from "@opentui/core";
 class NoticeView {
@@ -19851,7 +20179,9 @@ var clipLines = (text, maxLines) => {
 // apps/tui/src/format/toolInputText.ts
 var VALUE_LENGTH = 200;
 var formatInputValue = (value) => truncateText(typeof value === "string" ? value : JSON.stringify(value), VALUE_LENGTH);
-var formatToolInput = ({ input }) => Object.entries(input).map(([key, value]) => `${key}: ${formatInputValue(value)}`).join(`
+var formatBatchEdit = ({ input }) => listBatchEditPaths(input).map((path, index) => `${index + 1}. ${formatInputValue(path)}`).join(`
+`);
+var formatToolInput = (call) => call.name === BATCH_EDIT_TOOL_NAME ? formatBatchEdit(call) : Object.entries(call.input).map(([key, value]) => `${key}: ${formatInputValue(value)}`).join(`
 `);
 
 // apps/tui/src/format/toolSummary.ts
@@ -19859,9 +20189,15 @@ var SUMMARY_LENGTH = 80;
 var SUMMARY_KEYS = ["file_path", "path", "command", "pattern", "query", "url", "description"];
 var SEARCH_TOOLS = new Set(["Glob", "Grep"]);
 var summarizeSearch = ({ pattern, path }) => typeof path === "string" ? `${pattern} in ${path}` : String(pattern);
+var summarizeBatchEdit = (input) => {
+  const paths = listBatchEditPaths(input);
+  return `${paths.length} edits in ${new Set(paths).size} files`;
+};
 function summarizeToolCall({ name, input, status, progress }) {
   if (status === "running" && progress)
     return truncateText(progress, SUMMARY_LENGTH);
+  if (name === BATCH_EDIT_TOOL_NAME)
+    return summarizeBatchEdit(input);
   if (SEARCH_TOOLS.has(name) && typeof input.pattern === "string") {
     return truncateText(summarizeSearch(input), SUMMARY_LENGTH);
   }
@@ -19870,6 +20206,8 @@ function summarizeToolCall({ name, input, status, progress }) {
   return truncateText(value, SUMMARY_LENGTH);
 }
 var describeApproval = ({ name, input }) => {
+  if (name === BATCH_EDIT_TOOL_NAME)
+    return `Apply ${summarizeBatchEdit(input)} with BatchEdit?`;
   if (name === "Bash")
     return `Run command \`${truncateText(String(input.command ?? ""), 60)}\`?`;
   const path = input.file_path ?? input.notebook_path;
@@ -20114,8 +20452,8 @@ class ToolCallView {
     const glyph = call.expanded ? COLLAPSE_GLYPHS.expanded : COLLAPSE_GLYPHS.collapsed;
     const accent = this.hovered ? Theme.accent.brand : undefined;
     this.title.content = new StyledText10([
-      fg11(accent ?? toolColor(call.status))(`${glyph} `),
-      bold6(fg11(accent ?? Theme.fg.primary)(call.name)),
+      fg11(accent ?? toolColor(call.status))(glyph),
+      bold6(fg11(accent ?? Theme.fg.primary)(stripCustomPrefix(call.name))),
       fg11(Theme.fg.secondary)(` ${summarizeToolCall(call)}`),
       fg11(Theme.fg.muted)(stats)
     ]);
@@ -20222,7 +20560,6 @@ class UserMessageView {
       return;
     this.entry = entry;
     this.text.content = new StyledText11([
-      bold7(fg12(Theme.accent.brand)("\u276F ")),
       bold7(fg12(Theme.fg.primary)(clipLines(entry.text, USER_LINES)))
     ]);
     this.clock.content = new StyledText11([fg12(Theme.fg.muted)(formatClock(entry.at))]);
@@ -20276,9 +20613,9 @@ class ScrollbackView {
     else if (below > 0)
       this.renderable.scrollBy(Math.min(below, above));
   }
-  reset(syntaxStyle) {
+  reset(syntaxStyle, mutedSyntaxStyle) {
     this.dropViews(() => true);
-    this.options = { syntaxStyle, hooks: { ...this.options.hooks, syntaxStyle } };
+    this.options = { syntaxStyle, mutedSyntaxStyle, hooks: { ...this.options.hooks, syntaxStyle } };
   }
   dropRemovedViews(state) {
     const live = new Set(state.transcript.map((entry) => entry.id));
@@ -20300,14 +20637,14 @@ class ScrollbackView {
     return view;
   }
   createView(entry) {
-    const { syntaxStyle, hooks } = this.options;
+    const { syntaxStyle, mutedSyntaxStyle, hooks } = this.options;
     switch (entry.kind) {
       case "user":
         return new UserMessageView(this.renderer);
       case "assistant":
         return new AssistantMessageView(this.renderer, syntaxStyle);
       case "notice":
-        return new NoticeView(this.renderer);
+        return entry.markdown ? new MarkdownNoticeView(this.renderer, mutedSyntaxStyle) : new NoticeView(this.renderer);
       case "thought":
         return new ThoughtView(this.renderer);
       case "tools":
@@ -20386,15 +20723,14 @@ class SessionInfoBar {
   limits;
   constructor(renderer) {
     this.renderable = new BoxRenderable13(renderer, {
-      marginBottom: 1,
       flexShrink: 0,
       flexDirection: "row",
       flexWrap: "wrap",
       rowGap: 1,
       columnGap: 0,
       justifyContent: "space-between",
-      paddingLeft: 1,
-      paddingRight: 1
+      paddingLeft: 2,
+      paddingRight: 2
     });
     this.info = new TextRenderable13(renderer, { content: "", wrapMode: "none", flexShrink: 0 });
     this.limits = new TextRenderable13(renderer, {
@@ -20450,12 +20786,14 @@ class StatusLine {
   constructor(renderer, onStop) {
     this.renderable = new BoxRenderable14(renderer, {
       height: 2,
-      paddingTop: 1,
       flexShrink: 0,
       flexDirection: "row",
       justifyContent: "space-between",
+      border: ["top"],
+      borderColor: Theme.border.subtle,
       paddingLeft: 2,
-      paddingRight: 2
+      paddingRight: 2,
+      visible: false
     });
     this.label = new TextRenderable14(renderer, { content: "", wrapMode: "none" });
     this.stats = new TextRenderable14(renderer, {
@@ -20471,9 +20809,11 @@ class StatusLine {
   update(state) {
     if (state.status === "idle") {
       this.label.content = state.lastRun ? new StyledText13(buildLastRunChunks(state.lastRun, readLastPrompt(state))) : "";
+      this.renderable.visible = state.lastRun !== undefined;
       this.stats.content = "";
       return;
     }
+    this.renderable.visible = true;
     const label = agentLabel(state.status);
     const busy = label.icon === undefined;
     const frame = SPINNER_FRAMES[Math.floor(state.now / SPINNER_STEP_MS) % SPINNER_FRAMES.length];
@@ -20490,8 +20830,198 @@ class StatusLine {
   }
 }
 
+// apps/tui/src/components/promptQueueView.ts
+import {
+  BoxRenderable as BoxRenderable15,
+  bold as bold9,
+  dim as dim7,
+  fg as fg16,
+  StyledText as StyledText14,
+  TextRenderable as TextRenderable15
+} from "@opentui/core";
+
+// apps/tui/src/format/promptQueueRows.ts
+var MAX_QUEUE_ROWS = 5;
+var QUEUE_TEXT_LENGTH = 80;
+var buildQueueRows = (queued) => queued.slice(0, MAX_QUEUE_ROWS).map((content, index) => `${index + 1}. ${truncateText(readPromptText(content), QUEUE_TEXT_LENGTH)}`);
+var buildQueueHeader = (queued) => `Queued${SEPARATOR}${queued.length} waiting`;
+var countHiddenQueued = (queued) => Math.max(queued.length - MAX_QUEUE_ROWS, 0);
+
+// apps/tui/src/components/promptQueueView.ts
+class PromptQueueView {
+  renderable;
+  header;
+  rows;
+  overflow;
+  constructor(renderer) {
+    this.renderable = new BoxRenderable15(renderer, {
+      flexShrink: 0,
+      paddingLeft: 2,
+      paddingRight: 2,
+      visible: false
+    });
+    this.header = new TextRenderable15(renderer, { content: "", wrapMode: "none" });
+    this.overflow = new TextRenderable15(renderer, { content: "", wrapMode: "none" });
+    this.rows = Array.from({ length: MAX_QUEUE_ROWS }, () => new TextRenderable15(renderer, { content: "", wrapMode: "none" }));
+    this.renderable.add(this.header);
+    for (const row of this.rows)
+      this.renderable.add(row);
+    this.renderable.add(this.overflow);
+  }
+  update({ queuedPrompts }) {
+    this.renderable.visible = queuedPrompts.length > 0;
+    if (queuedPrompts.length === 0)
+      return;
+    this.header.content = new StyledText14([
+      bold9(fg16(Theme.fg.secondary)(buildQueueHeader(queuedPrompts)))
+    ]);
+    const lines = buildQueueRows(queuedPrompts);
+    this.rows.forEach((row, index) => {
+      row.content = new StyledText14([fg16(Theme.fg.primary)(lines[index] ?? "")]);
+    });
+    const hidden = countHiddenQueued(queuedPrompts);
+    this.overflow.content = hidden ? new StyledText14([dim7(fg16(Theme.fg.muted)(`  +${hidden} more`))]) : "";
+  }
+}
+
+// apps/tui/src/components/taskPanel.ts
+import {
+  BoxRenderable as BoxRenderable17,
+  bold as bold11,
+  dim as dim9,
+  fg as fg18,
+  StyledText as StyledText16,
+  TextRenderable as TextRenderable17
+} from "@opentui/core";
+
+// apps/tui/src/format/taskRows.ts
+var MAX_TASK_ROWS = 5;
+var KIND_LABELS = { "general-purpose": "Agent", local_bash: "Bash" };
+var describeLastTool = ({ lastToolCall, lastToolName }) => {
+  if (!lastToolCall)
+    return lastToolName;
+  const { name, input } = lastToolCall;
+  const summary = summarizeToolCall({
+    id: "",
+    name,
+    input,
+    status: "running",
+    expanded: false,
+    startedAt: 0
+  });
+  return `${name} ${summary}`;
+};
+var readDetail = (task) => {
+  if (task.paused)
+    return "Paused";
+  return task.summary ?? describeLastTool(task) ?? "Starting...";
+};
+var buildTaskRow = (task, now) => ({
+  taskId: task.id,
+  kind: KIND_LABELS[task.kind] ?? task.kind,
+  model: task.model ?? "",
+  title: task.description,
+  stats: [formatDuration(Math.max(now - task.startedAt, 0)), `\u2193${formatTokenCount(task.tokens)}`].join(SEPARATOR).trim(),
+  detail: readDetail(task)
+});
+var buildTaskRows = (tasks, now) => tasks.slice(0, MAX_TASK_ROWS).map((task) => buildTaskRow(task, now));
+var buildTaskHeader = (tasks) => `Tasks${SEPARATOR}${tasks.length} running`;
+var countHiddenTasks = (tasks) => Math.max(tasks.length - MAX_TASK_ROWS, 0);
+
+// apps/tui/src/components/taskRowView.ts
+import {
+  BoxRenderable as BoxRenderable16,
+  bold as bold10,
+  dim as dim8,
+  fg as fg17,
+  StyledText as StyledText15,
+  TextRenderable as TextRenderable16
+} from "@opentui/core";
+var SPINNER_STEP_MS2 = 100;
+
+class TaskRowView {
+  renderable;
+  title;
+  stop;
+  detail;
+  taskId = "";
+  constructor(renderer, onStop) {
+    this.renderable = new BoxRenderable16(renderer, { flexShrink: 0, visible: false });
+    const line = new BoxRenderable16(renderer, {
+      flexDirection: "row",
+      justifyContent: "space-between"
+    });
+    this.title = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
+    this.stop = new TextRenderable16(renderer, {
+      content: "",
+      wrapMode: "none",
+      flexShrink: 0,
+      selectable: false,
+      onMouseDown: () => onStop(this.taskId)
+    });
+    this.detail = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
+    line.add(this.title);
+    line.add(this.stop);
+    this.renderable.add(line);
+    this.renderable.add(this.detail);
+  }
+  update(row, now) {
+    this.renderable.visible = row !== undefined;
+    if (!row)
+      return;
+    this.taskId = row.taskId;
+    const frame = SPINNER_FRAMES[Math.floor(now / SPINNER_STEP_MS2) % SPINNER_FRAMES.length];
+    this.title.content = new StyledText15([
+      fg17(Theme.status.success)(`${frame} `),
+      bold10(fg17(Theme.fg.primary)(row.kind)),
+      fg17(Theme.fg.muted)(row.model ? ` (${row.model})` : ""),
+      fg17(Theme.fg.secondary)(` ${row.title}`)
+    ]);
+    this.stop.content = new StyledText15([
+      fg17(Theme.fg.muted)(`${row.stats} `),
+      bold10(fg17(Theme.fg.secondary)("[stop]"))
+    ]);
+    this.detail.content = new StyledText15([dim8(fg17(Theme.fg.muted)(`  \u2514 ${row.detail}`))]);
+  }
+}
+
+// apps/tui/src/components/taskPanel.ts
+class TaskPanel {
+  renderable;
+  header;
+  rows;
+  overflow;
+  constructor(renderer, onStop) {
+    this.renderable = new BoxRenderable17(renderer, {
+      flexShrink: 0,
+      paddingLeft: 2,
+      paddingRight: 2,
+      border: ["top"],
+      borderColor: Theme.border.subtle,
+      visible: false
+    });
+    this.header = new TextRenderable17(renderer, { content: "", wrapMode: "none" });
+    this.overflow = new TextRenderable17(renderer, { content: "", wrapMode: "none" });
+    this.rows = Array.from({ length: MAX_TASK_ROWS }, () => new TaskRowView(renderer, onStop));
+    this.renderable.add(this.header);
+    for (const row of this.rows)
+      this.renderable.add(row.renderable);
+    this.renderable.add(this.overflow);
+  }
+  update({ tasks, now }) {
+    this.renderable.visible = tasks.length > 0;
+    if (tasks.length === 0)
+      return;
+    const rows = buildTaskRows(tasks, now);
+    this.header.content = new StyledText16([bold11(fg18(Theme.fg.primary)(buildTaskHeader(tasks)))]);
+    this.rows.forEach((view, index) => view.update(rows[index], now));
+    const hidden = countHiddenTasks(tasks);
+    this.overflow.content = hidden ? new StyledText16([dim9(fg18(Theme.fg.muted)(`  +${hidden} more`))]) : "";
+  }
+}
+
 // apps/tui/src/components/toastView.ts
-import { BoxRenderable as BoxRenderable15, fg as fg16, StyledText as StyledText14, TextRenderable as TextRenderable15 } from "@opentui/core";
+import { BoxRenderable as BoxRenderable18, fg as fg19, StyledText as StyledText17, TextRenderable as TextRenderable18 } from "@opentui/core";
 var TOAST_ICON = "\u25CF";
 
 class ToastView {
@@ -20499,7 +21029,7 @@ class ToastView {
   text;
   toastId;
   constructor(renderer) {
-    this.renderable = new BoxRenderable15(renderer, {
+    this.renderable = new BoxRenderable18(renderer, {
       position: "absolute",
       top: 1,
       right: 2,
@@ -20510,7 +21040,7 @@ class ToastView {
       borderStyle: "rounded",
       visible: false
     });
-    this.text = new TextRenderable15(renderer, { content: "", wrapMode: "none", selectable: false });
+    this.text = new TextRenderable18(renderer, { content: "", wrapMode: "none", selectable: false });
     this.renderable.add(this.text);
   }
   update({ ui }) {
@@ -20521,9 +21051,9 @@ class ToastView {
     this.toastId = toast.id;
     this.renderable.borderColor = Theme.border.focus;
     this.renderable.backgroundColor = Theme.bg.surface;
-    this.text.content = new StyledText14([
-      fg16(Theme.status.success)(`${TOAST_ICON} `),
-      fg16(Theme.fg.primary)(toast.text)
+    this.text.content = new StyledText17([
+      fg19(Theme.status.success)(`${TOAST_ICON} `),
+      fg19(Theme.fg.primary)(toast.text)
     ]);
   }
 }
@@ -20552,6 +21082,9 @@ function requestAgent(store, request, onMissing = "notify") {
   return true;
 }
 
+// apps/tui/src/input/themeActions.ts
+var saveTheme2 = (store, theme) => store.request({ type: "options.theme.save.requested", theme });
+
 // apps/tui/src/input/workflowCommands.ts
 var postNotice = (store, text) => store.emit({ type: "ui.notice.posted", text });
 var WORKFLOW_COMMANDS = {
@@ -20651,7 +21184,7 @@ var SLASH_COMMANDS = {
         return store.emit({ type: "ui.theme.picker.opened" });
       const parsed = themeNameSchema.safeParse(argument);
       if (parsed.success)
-        return store.emit({ type: "ui.theme.selected", theme: parsed.data });
+        return saveTheme2(store, parsed.data);
       store.emit({ type: "ui.notice.posted", text: `Unknown theme: ${argument}` });
     }
   },
@@ -20680,8 +21213,10 @@ var SLASH_COMMANDS = {
     }
   },
   "/effort": {
-    description: "Show or set reasoning effort",
+    description: "Pick a reasoning effort, or set one with /effort <level>",
     run(store, level) {
+      if (!level)
+        return store.emit({ type: "ui.effort.picker.opened" });
       const parsed = effortLevelSchema.safeParse(level);
       if (parsed.success) {
         return void requestAgent(store, {
@@ -20753,6 +21288,14 @@ function buildPickerView(state) {
     }));
     return { title: "Select a theme", rows, selected: picker.selected };
   }
+  if (picker.kind === "effort") {
+    const current = state.effort || DEFAULT_EFFORT;
+    const rows = effortLevelSchema.options.map((level) => ({
+      name: `${level === current ? "\u25CF " : "  "}${level}`,
+      description: ""
+    }));
+    return { title: "Select an effort level", rows, selected: picker.selected };
+  }
   if (picker.kind === "rewind") {
     const rows = listCheckpoints(state).map((entry) => ({
       name: truncateText(entry.text.replace(/\s+/g, " "), CHECKPOINT_TEXT_LENGTH),
@@ -20770,7 +21313,6 @@ function buildPickerView(state) {
 var buildListView = (state) => buildPickerView(state) ?? buildAutocompleteView(state);
 
 // apps/tui/src/input/agentSessionActions.ts
-var DEFAULT_EFFORT = "high";
 var DEFAULT_MODEL = "claude-haiku-5-5";
 var buildSessionOptions = (store) => ({
   model: store.state.model || DEFAULT_MODEL,
@@ -20949,23 +21491,22 @@ function runSlashCommand(store, line) {
 }
 
 // apps/tui/src/input/promptActions.ts
-var DELIVERY_REQUESTS = {
-  send: "agent.prompt.requested",
-  queue: "agent.prompt.queue.requested",
-  steer: "agent.prompt.steer.requested"
-};
-var BUSY_NOTICE = "Agent is busy: Ctrl+Q queues, Ctrl+W steers, Esc Esc interrupts the turn";
 var buildContent = (text, images) => images.length > 0 ? [{ type: "text", text }, ...images] : text;
 function deliverPrompt(store, content, delivery, images) {
-  const busy = isAgentBusy(store);
-  if (busy && delivery === "send") {
-    store.emit({ type: "ui.notice.posted", text: BUSY_NOTICE });
-    return false;
+  const body = buildContent(content, images);
+  if (delivery === "queue" && isAgentBusy(store)) {
+    store.emit({ type: "ui.prompt.queued", content: body });
+    return true;
   }
-  return requestAgent(store, {
-    type: DELIVERY_REQUESTS[busy ? delivery : "send"],
-    content: buildContent(content, images)
-  });
+  return requestAgent(store, { type: "agent.prompt.requested", content: body });
+}
+function sendNextQueuedPrompt(store) {
+  const [next] = store.state.queuedPrompts;
+  if (next === undefined || store.state.status !== "idle")
+    return;
+  const sent = requestAgent(store, { type: "agent.prompt.requested", content: next }, "ignore");
+  if (sent)
+    store.emit({ type: "ui.prompt.dequeued" });
 }
 function submitPrompt(store, text, delivery = "send", images = []) {
   const content = text.trim();
@@ -20982,6 +21523,9 @@ function answerApproval(store, decision, toolUseId) {
   if (target)
     requestAgent(store, { type: "agent.tool.approval.answered", toolUseId: target, decision });
 }
+function stopTask(store, taskId) {
+  requestAgent(store, { type: "agent.task.stop.requested", taskId });
+}
 function cancelTurn(store) {
   requestAgent(store, { type: "agent.prompt.cancel.requested" });
 }
@@ -21046,7 +21590,12 @@ var PICKER_CONFIRMS = {
   theme(store, _state, selected) {
     const theme = THEME_NAMES[selected];
     if (theme)
-      store.emit({ type: "ui.theme.selected", theme });
+      saveTheme2(store, theme);
+  },
+  effort(store, _state, selected) {
+    const effort = effortLevelSchema.options[selected];
+    if (effort)
+      requestAgent(store, { type: "agent.effort.set.requested", effort });
   },
   rewind(store, state, selected) {
     const userMessageId = listCheckpoints(state)[selected]?.checkpointId;
@@ -21094,7 +21643,7 @@ var dismissQuestion = (store) => sendAnswers(store, {});
 
 // apps/tui/src/input/routeKeys.ts
 var createKeyPresses = () => ({ escapeAt: 0, ctrlCAt: 0 });
-var DELIVERY_KEYS = { q: "queue", w: "steer" };
+var DELIVERY_KEYS = { q: "queue" };
 var DOUBLE_ESCAPE_MS = 500;
 var EXIT_CONFIRM_MS = 3000;
 var EXIT_NOTICE = "Press Ctrl + C again to exit";
@@ -21439,21 +21988,70 @@ class AppStore {
 
 // apps/tui/src/theme/syntaxStyle.ts
 import { SyntaxStyle as SyntaxStyle2 } from "@opentui/core";
-var createSyntaxStyle = (renderer) => SyntaxStyle2.fromStyles({
-  default: { fg: Theme.fg.primary },
-  "markup.heading": { fg: Theme.accent.brand, bold: true },
-  "markup.strong": { fg: Theme.fg.primary, bold: true },
-  "markup.italic": { fg: Theme.fg.secondary, italic: true },
-  "markup.raw": { fg: Theme.status.warning },
-  "markup.link": { fg: Theme.status.info, underline: true },
-  "markup.list": { fg: Theme.accent.highlight },
-  keyword: { fg: Theme.accent.brand },
-  string: { fg: Theme.status.success },
-  comment: { fg: Theme.fg.muted, italic: true },
-  function: { fg: Theme.accent.highlight },
-  type: { fg: Theme.status.warning },
-  number: { fg: Theme.status.info }
-}, renderer.nativeScene);
+
+// apps/tui/src/theme/syntaxRules.ts
+var rule = (scope, foreground, style = {}) => ({
+  scope,
+  style: { foreground, ...style }
+});
+var buildMutedSyntaxRules = (palette) => buildSyntaxRules(palette).map(({ scope, style }) => ({
+  scope,
+  style: { ...style, foreground: palette.fg.muted }
+}));
+var buildSyntaxRules = ({ fg, status, syntax, markdown, diff, bg }) => [
+  rule(["default"], fg.primary),
+  rule(["comment", "comment.documentation"], syntax.comment, { italic: true }),
+  rule(["string", "symbol", "character.special", "character"], syntax.string),
+  rule(["number", "boolean", "constant", "float"], syntax.number),
+  rule(["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine"], syntax.keyword, {
+    italic: true
+  }),
+  rule(["keyword.type"], syntax.type, { bold: true, italic: true }),
+  rule(["keyword.function", "function.method"], syntax.function),
+  rule(["keyword"], syntax.keyword, { italic: true }),
+  rule(["keyword.import", "string.escape", "string.regexp", "tag.attribute", "keyword.export"], syntax.keyword),
+  rule(["operator", "keyword.operator", "punctuation.delimiter", "keyword.conditional.ternary"], syntax.operator),
+  rule(["variable", "variable.parameter", "function.method.call", "function.call", "property", "parameter", "field"], syntax.variable),
+  rule(["variable.member", "function", "constructor"], syntax.function),
+  rule(["type", "module", "class", "namespace"], syntax.type),
+  rule(["type.definition"], syntax.type, { bold: true }),
+  rule(["punctuation", "punctuation.bracket"], syntax.punctuation),
+  rule(["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"], status.danger),
+  rule(["keyword.directive", "keyword.modifier", "keyword.exception"], syntax.keyword, { italic: true }),
+  rule(["punctuation.special", "tag.delimiter"], syntax.operator),
+  rule(["markup.heading", "markup.heading.2", "markup.heading.3", "markup.heading.4", "markup.heading.5", "markup.heading.6"], markdown.heading, { bold: true }),
+  rule(["markup.heading.1"], markdown.heading, { bold: true, underline: true }),
+  rule(["markup.bold", "markup.strong"], markdown.strong, { bold: true }),
+  rule(["markup.italic"], markdown.emphasis, { italic: true }),
+  rule(["markup.list"], markdown.listItem),
+  rule(["markup.quote"], markdown.blockQuote, { italic: true }),
+  rule(["markup.raw", "markup.raw.block"], markdown.code),
+  rule(["markup.raw.inline"], markdown.code, { background: bg.surface }),
+  rule(["markup.link", "markup.link.url", "string.special", "string.special.url"], markdown.link, {
+    underline: true
+  }),
+  rule(["markup.link.label"], markdown.linkText, { underline: true }),
+  rule(["label"], markdown.linkText),
+  rule(["spell", "nospell"], fg.primary),
+  rule(["markup.underline"], fg.primary, { underline: true }),
+  rule(["comment.error"], status.danger, { italic: true, bold: true }),
+  rule(["comment.warning"], status.warning, { italic: true, bold: true }),
+  rule(["comment.todo", "comment.note"], status.info, { italic: true, bold: true }),
+  rule(["attribute", "annotation"], status.warning),
+  rule(["tag"], status.danger),
+  rule(["markup.strikethrough", "markup.list.unchecked", "debug"], fg.muted),
+  rule(["markup.list.checked"], status.success),
+  rule(["diff.plus"], diff.addedText, { background: diff.addedBg }),
+  rule(["diff.minus"], diff.removedText, { background: diff.removedBg }),
+  rule(["diff.delta"], diff.contextText, { background: diff.contextBg }),
+  rule(["error"], status.danger, { bold: true }),
+  rule(["warning"], status.warning, { bold: true }),
+  rule(["info"], status.info)
+];
+
+// apps/tui/src/theme/syntaxStyle.ts
+var createSyntaxStyle = (renderer) => SyntaxStyle2.fromTheme(buildSyntaxRules(Theme), renderer.nativeScene);
+var createMutedSyntaxStyle = (renderer) => SyntaxStyle2.fromTheme(buildMutedSyntaxRules(Theme), renderer.nativeScene);
 
 // apps/tui/src/startTui.ts
 var CLOCK_INTERVAL_MS = 100;
@@ -21463,10 +22061,10 @@ var readShownTheme = ({ theme, ui }) => (ui.picker?.kind === "theme" ? THEME_NAM
 var readShownBackground = ({ background, ui }) => ui.backgroundEditor?.color ?? background;
 async function startTui(client, options = {}) {
   const activeRenderer = options.renderer ?? await createCliRenderer({ exitOnCtrlC: false, useMouse: true });
-  activeRenderer.setTerminalTitle("Claudin");
   const store = new AppStore(client);
   const clipboard = options.clipboard ?? createHostClipboard();
   let syntaxStyle = createSyntaxStyle(activeRenderer);
+  let mutedSyntaxStyle = createMutedSyntaxStyle(activeRenderer);
   let appliedTheme = readShownTheme(store.state);
   let appliedBackground = readShownBackground(store.state);
   const header = new HeaderBar(activeRenderer);
@@ -21475,8 +22073,11 @@ async function startTui(client, options = {}) {
   const backgroundPanel = new BackgroundPanel(activeRenderer);
   const toastView = new ToastView(activeRenderer);
   const statusLine = new StatusLine(activeRenderer, () => cancelTurn(store));
+  const taskPanel = new TaskPanel(activeRenderer, (taskId) => stopTask(store, taskId));
+  const promptQueue = new PromptQueueView(activeRenderer);
   const scrollback = new ScrollbackView(activeRenderer, {
     syntaxStyle,
+    mutedSyntaxStyle,
     hooks: {
       syntaxStyle,
       onDecision: (decision, id) => answerApproval(store, decision, id),
@@ -21509,7 +22110,7 @@ async function startTui(client, options = {}) {
       saveDraft(text);
     }
   });
-  const root = new BoxRenderable16(activeRenderer, {
+  const root = new BoxRenderable19(activeRenderer, {
     width: "100%",
     height: "100%",
     flexDirection: "column",
@@ -21520,10 +22121,12 @@ async function startTui(client, options = {}) {
     scrollback,
     diffViewer,
     statusLine,
+    promptQueue,
     popover,
     backgroundPanel,
     input,
-    infoBar
+    infoBar,
+    taskPanel
   ];
   for (const part of parts)
     root.add(part.renderable);
@@ -21532,7 +22135,7 @@ async function startTui(client, options = {}) {
   activeRenderer.on("selection", (selection) => {
     copySelection(store, activeRenderer, clipboard, selection);
   });
-  for (const part of [header, statusLine, popover, backgroundPanel, input, infoBar]) {
+  for (const part of [header, statusLine, taskPanel, popover, backgroundPanel, input, infoBar]) {
     part.renderable.onMouseScroll = ({ scroll }) => {
       if (scroll?.direction === "up")
         scrollback.scrollByLines(-1);
@@ -21550,11 +22153,13 @@ async function startTui(client, options = {}) {
     appliedBackground = shownBackground;
     applyTheme(shownTheme, shownBackground);
     if (themeChanged) {
-      const previous = syntaxStyle;
+      const previous = [syntaxStyle, mutedSyntaxStyle];
       syntaxStyle = createSyntaxStyle(activeRenderer);
-      scrollback.reset(syntaxStyle);
+      mutedSyntaxStyle = createMutedSyntaxStyle(activeRenderer);
+      scrollback.reset(syntaxStyle, mutedSyntaxStyle);
       diffViewer.reset(syntaxStyle);
-      previous.destroy();
+      for (const style of previous)
+        style.destroy();
     }
     root.backgroundColor = Theme.bg.default;
     input.applyColors();
@@ -21564,6 +22169,8 @@ async function startTui(client, options = {}) {
     syncTheme(state);
     header.update(state);
     statusLine.update(state);
+    taskPanel.update(state);
+    promptQueue.update(state);
     toastView.update(state);
     infoBar.update(state);
     scrollback.update(state);
@@ -21575,7 +22182,7 @@ async function startTui(client, options = {}) {
     input.setFocused(inputFocused);
     scrollback.setFocused(!inputFocused);
     input.setBusy(isStatusBusy(state.status));
-    input.setBorderColor(inputFocused ? Theme.status.success : Theme.border.separator);
+    input.setBorderColor(inputFocused ? Theme.fg.muted : Theme.border.separator);
     const awaitingId = (findAwaitingCalls(state)[0] ?? findQuestionCalls(state)[0])?.id;
     if (awaitingId && awaitingId !== revealedCallId) {
       scrollback.revealEntry(findGroupId(state, awaitingId) ?? "");
@@ -21583,13 +22190,17 @@ async function startTui(client, options = {}) {
     revealedCallId = awaitingId;
   };
   store.subscribe(render);
+  store.subscribe(() => sendNextQueuedPrompt(store));
   const notifier = new TurnNotifier(activeRenderer);
   store.subscribeOwnEvents((event) => {
     reactToEvent(store, event);
     notifier.notify(event);
     if (event.type === "ui.exit.requested")
       activeRenderer.destroy();
+    if (event.type === "ui.title.set")
+      activeRenderer.setTerminalTitle(event.title);
   });
+  store.emit({ type: "ui.title.set", title: "Claudin" });
   const editor = {
     read: () => input.text,
     replace: (text) => input.replaceText(text, text.length)
@@ -21611,7 +22222,8 @@ async function startTui(client, options = {}) {
       key.preventDefault();
   });
   const clock = setInterval(() => {
-    if (store.state.status !== "idle")
+    const { status, tasks } = store.state;
+    if (status !== "idle" || tasks.length > 0)
       store.emit({ type: "ui.clock.ticked", now: Date.now() });
   }, CLOCK_INTERVAL_MS);
   let lastRateLimitAt = Date.now();