@couralabs/claudin 0.1.5 → 0.1.7

package/claudin.js

@@ -1,5 +1,16 @@
 #!/usr/bin/env bun
 // @bun
+
+// packages/daemon/src/auth/connectionCredentials.ts
+import { randomBytes } from "crypto";
+var createRunId = () => crypto.randomUUID();
+var createAccessToken = () => randomBytes(32).toString("base64url");
+function appendCredentials(url, { token, runId }) {
+  const target = new URL(url);
+  target.searchParams.set("token", token);
+  target.searchParams.set("runId", runId);
+  return target.toString();
+}
 // node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -5928,6 +5939,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 +6081,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 +6129,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,8 +6164,6 @@ 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({
@@ -6218,6 +6235,7 @@ var createSessionState = (sessionId) => ({
   models: [],
   sessionList: [],
   queuedTurns: 0,
+  queuedPrompts: [],
   tasks: [],
   transcript: [],
   entryCounter: 0,
@@ -6317,10 +6335,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");
@@ -6519,6 +6538,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;
@@ -6539,6 +6595,8 @@ var startTask = (state, message) => {
     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
   };
@@ -6609,9 +6667,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);
@@ -6628,7 +6689,8 @@ function reduceTaskMessage(state, message) {
     return reduceTaskProgress(state, message);
   }
   if (message.type === "system" && message.subtype === "task_notification") {
-    return reduceNoticeMessage(state, message);
+    const text = describeSystemMessage(message);
+    return text ? appendMarkdownNotice(state, text) : state;
   }
   return state;
 }
@@ -6812,6 +6874,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,
@@ -6839,6 +6918,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;
@@ -6857,6 +6938,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)
@@ -6881,8 +6967,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":
@@ -6961,9 +7051,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);
@@ -7040,9 +7127,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:
@@ -7055,13 +7144,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") }),
@@ -7122,7 +7220,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"),
@@ -7464,8 +7561,8 @@ class DaemonClient {
     this.socket = socket;
     socket.addEventListener("message", (event) => this.notifyListeners(String(event.data)));
   }
-  static async connect(url) {
-    const socket = new WebSocket(url);
+  static async connect(url, credentials) {
+    const socket = new WebSocket(appendCredentials(url, credentials));
     await new Promise((resolve, reject) => {
       socket.addEventListener("open", () => resolve(), { once: true });
       socket.addEventListener("error", () => reject(new Error(`Cannot reach ${url}`)), {
@@ -7532,11 +7629,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
@@ -8731,8 +8827,10 @@ class PermissionGate {
   }
   open(kind, toolUseId, input, signal, announcement) {
     return new Promise((settle) => {
-      this.pending.set(toolUseId, { kind, input, settle });
-      signal.addEventListener("abort", () => this.dismiss(kind, toolUseId), { once: true });
+      const onAbort = () => this.dismiss(kind, toolUseId);
+      const detach = () => signal.removeEventListener("abort", onAbort);
+      this.pending.set(toolUseId, { kind, input, settle, detach });
+      signal.addEventListener("abort", onAbort, { once: true });
       this.emit(announcement);
     });
   }
@@ -8747,6 +8845,7 @@ class PermissionGate {
     if (pending?.kind !== kind)
       return;
     this.pending.delete(toolUseId);
+    pending.detach();
     return pending;
   }
   listIds(kind) {
@@ -8761,6 +8860,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.
 
@@ -8875,8 +9078,7 @@ var AGENT_TOOLS = [
   "TodoWrite",
   "AskUserQuestion",
   "Write",
-  "Edit",
-  "NotebookEdit"
+  "Edit"
 ];
 var AGENT_DISALLOWED_TOOLS = [
   "Agent(Explore)",
@@ -8903,11 +9105,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(`
@@ -8917,6 +9120,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,
@@ -8951,11 +9156,25 @@ var AGENT_PROFILE_OPTIONS = {
   includeHookEvents: true
 };
 
-// packages/agent/src/session/readBackgroundTaskCount.ts
-function readBackgroundTaskCount(message, current) {
-  if (message.type !== "system" || message.subtype !== "background_tasks_changed")
+// 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;
-  return message.tasks.length;
+  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
@@ -8972,7 +9191,7 @@ class AgentSession {
   elicitations;
   query;
   pendingTurns = 0;
-  backgroundTaskCount = 0;
+  liveTaskIds = new Set;
   pumping = false;
   constructor(agentSessionId, baseOptions, runtime) {
     this.baseOptions = baseOptions;
@@ -8988,13 +9207,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)
@@ -9006,7 +9225,6 @@ class AgentSession {
     try {
       yield* sink;
     } finally {
-      this.pumping = false;
       this.listenGates(() => {});
     }
   }
@@ -9094,16 +9312,18 @@ class AgentSession {
         if (done)
           break;
         sink.push({ type: "agent.message.received", message: value });
-        this.backgroundTaskCount = readBackgroundTaskCount(value, this.backgroundTaskCount);
+        this.liveTaskIds = readLiveTaskIds(value, this.liveTaskIds);
         if (value.type !== "result")
           continue;
         this.pendingTurns = Math.max(this.pendingTurns - 1, 0);
-        if (this.pendingTurns === 0 && this.backgroundTaskCount === 0)
+        if (this.pendingTurns === 0 && this.liveTaskIds.size === 0)
           break;
       }
+      this.pumping = false;
       sink.end();
     } catch (error) {
       this.pendingTurns = 0;
+      this.pumping = false;
       sink.end(error);
     }
   }
@@ -9127,14 +9347,13 @@ class AgentSessionManager {
   }
   createSession(options = {}) {
     const sessionId = options.sessionId ?? crypto.randomUUID();
-    this.sessions.set(sessionId, new AgentSession(sessionId, { ...options, sessionId }, this.runtime));
+    this.replaceSession(sessionId, { ...options, sessionId });
     return sessionId;
   }
   async resumeSession(sessionId, options = {}) {
     if (!await this.runtime.getInfo(sessionId))
       return this.createSession({ ...options, sessionId });
-    const resumed = new AgentSession(sessionId, { ...options, resume: sessionId }, this.runtime);
-    this.sessions.set(sessionId, resumed);
+    this.replaceSession(sessionId, { ...options, resume: sessionId });
     return sessionId;
   }
   async forkSession(sessionId, forkOptions, options = {}) {
@@ -9149,6 +9368,10 @@ class AgentSessionManager {
     for (const sessionId of [...this.sessions.keys()])
       this.closeSession(sessionId);
   }
+  replaceSession(sessionId, options) {
+    this.closeSession(sessionId);
+    this.sessions.set(sessionId, new AgentSession(sessionId, options, this.runtime));
+  }
   requireSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session)
@@ -9165,19 +9388,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");
@@ -9245,11 +9470,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;
@@ -9300,6 +9521,31 @@ class ReplayClient {
 import { once } from "events";
 import { WebSocketServer } from "ws";
 
+// packages/daemon/src/auth/checkConnection.ts
+import { timingSafeEqual } from "crypto";
+var isSameSecret = (given, expected) => {
+  const givenBytes = Buffer.from(given);
+  const expectedBytes = Buffer.from(expected);
+  return givenBytes.length === expectedBytes.length && timingSafeEqual(givenBytes, expectedBytes);
+};
+function readRunId(request) {
+  return new URL(request.url ?? "/", "ws://127.0.0.1").searchParams.get("runId");
+}
+function checkConnection(request, token, liveRunIds) {
+  if (request.headers.origin)
+    return { status: 403, reason: "Browser origins are not allowed" };
+  const params = new URL(request.url ?? "/", "ws://127.0.0.1").searchParams;
+  if (!isSameSecret(params.get("token") ?? "", token)) {
+    return { status: 401, reason: "Invalid access token" };
+  }
+  const runId = params.get("runId");
+  if (!runId)
+    return { status: 400, reason: "Missing run id" };
+  if (liveRunIds.has(runId))
+    return { status: 409, reason: "Run id already connected" };
+  return;
+}
+
 // packages/daemon/src/persistence/rateLimitCache.ts
 import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
 import { homedir as homedir4 } from "os";
@@ -9362,16 +9608,6 @@ 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 };
@@ -9455,12 +9691,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 };
   }
 };
 
@@ -9496,14 +9736,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,
@@ -11163,11 +11403,18 @@ var workspaceHandlers = {
 
 // packages/daemon/src/server/handleRequest.ts
 var handlers = { ...sessionHandlers, ...agentHandlers, ...workspaceHandlers, ...optionsHandlers };
+var SESSION_SWITCH_TYPES = new Set([
+  "session.created",
+  "session.restored",
+  "session.forked"
+]);
 async function* handleRequest(context, request) {
-  await context.session.dispatch(request);
+  const origin = context.session;
+  await origin.dispatch(request);
   const handler = handlers[request.type];
   for await (const response of handler(context, request)) {
-    await context.session.dispatch(response);
+    const target = SESSION_SWITCH_TYPES.has(response.type) ? context.session : origin;
+    await target.dispatch(response);
     yield response;
   }
 }
@@ -11185,7 +11432,12 @@ function publishEvent(clients, origin, event, toOrigin = true) {
 }
 
 // packages/daemon/src/server/startDaemon.ts
-var DEFAULT_PORT = 7777;
+var LOOPBACK_HOST = "127.0.0.1";
+async function reportFailure(context, server, socket, error) {
+  const failure = { type: "request.failed", reason: String(error) };
+  await context.session.dispatch(failure).catch(() => {});
+  publishEvent(server.clients, socket, failure);
+}
 async function answerMessage(context, server, socket, data) {
   try {
     const request = requestEventSchema.parse(JSON.parse(data));
@@ -11194,15 +11446,27 @@ async function answerMessage(context, server, socket, data) {
       publishEvent(server.clients, socket, response);
     }
   } catch (error) {
-    const failure = { type: "request.failed", reason: String(error) };
-    await context.session.dispatch(failure);
-    publishEvent(server.clients, socket, failure);
+    await reportFailure(context, server, socket, error);
   }
 }
-async function startDaemon(port = DEFAULT_PORT, context) {
+async function startDaemon(port, token, context) {
   const daemonContext = context ?? await createDaemonContext();
-  const server = new WebSocketServer({ port });
-  server.on("connection", (socket) => {
+  const liveRunIds = new Set;
+  const server = new WebSocketServer({
+    port,
+    host: LOOPBACK_HOST,
+    verifyClient: ({ req }, respond) => {
+      const rejection = checkConnection(req, token, liveRunIds);
+      if (rejection)
+        respond(false, rejection.status, rejection.reason);
+      else
+        respond(true);
+    }
+  });
+  server.on("connection", (socket, request) => {
+    const runId = readRunId(request) ?? "";
+    liveRunIds.add(runId);
+    socket.once("close", () => liveRunIds.delete(runId));
     socket.on("message", (data) => answerMessage(daemonContext, server, socket, data.toString()));
   });
   server.once("close", () => daemonContext.agents.closeAll());
@@ -11211,7 +11475,7 @@ async function startDaemon(port = DEFAULT_PORT, context) {
 }
 // apps/tui/src/startTui.ts
 import {
-  BoxRenderable as BoxRenderable18,
+  BoxRenderable as BoxRenderable19,
   createCliRenderer,
   createHostClipboard
 } from "@opentui/core";
@@ -11253,7 +11517,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") },
@@ -11264,7 +11528,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
@@ -18733,10 +19028,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
 });
 
@@ -19025,11 +19326,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;
   }
@@ -19075,7 +19376,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 = [
@@ -19097,12 +19398,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, {
@@ -19163,16 +19463,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;
@@ -19274,6 +19573,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 {
@@ -19928,7 +20246,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
@@ -19936,9 +20256,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);
   }
@@ -19947,6 +20273,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;
@@ -20192,7 +20520,7 @@ class ToolCallView {
     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)),
+      bold6(fg11(accent ?? Theme.fg.primary)(stripCustomPrefix(call.name))),
       fg11(Theme.fg.secondary)(` ${summarizeToolCall(call)}`),
       fg11(Theme.fg.muted)(stats)
     ]);
@@ -20352,9 +20680,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));
@@ -20376,14 +20704,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":
@@ -20462,15 +20790,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, {
@@ -20526,12 +20853,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, {
@@ -20547,9 +20876,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];
@@ -20566,26 +20897,96 @@ 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 BoxRenderable16,
-  bold as bold10,
-  dim as dim8,
-  fg as fg17,
-  StyledText as StyledText15,
-  TextRenderable as TextRenderable16
+  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 readDetail = ({ summary, lastToolName, paused }) => {
-  if (paused)
+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 summary ?? lastToolName ?? "Starting...";
+  return task.summary ?? describeLastTool(task) ?? "Starting...";
 };
 var buildTaskRow = (task, now) => ({
   taskId: task.id,
-  kind: task.kind,
+  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)
@@ -20596,12 +20997,12 @@ var countHiddenTasks = (tasks) => Math.max(tasks.length - MAX_TASK_ROWS, 0);
 
 // apps/tui/src/components/taskRowView.ts
 import {
-  BoxRenderable as BoxRenderable15,
-  bold as bold9,
-  dim as dim7,
-  fg as fg16,
-  StyledText as StyledText14,
-  TextRenderable as TextRenderable15
+  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;
 
@@ -20612,20 +21013,20 @@ class TaskRowView {
   detail;
   taskId = "";
   constructor(renderer, onStop) {
-    this.renderable = new BoxRenderable15(renderer, { flexShrink: 0, visible: false });
-    const line = new BoxRenderable15(renderer, {
+    this.renderable = new BoxRenderable16(renderer, { flexShrink: 0, visible: false });
+    const line = new BoxRenderable16(renderer, {
       flexDirection: "row",
       justifyContent: "space-between"
     });
-    this.title = new TextRenderable15(renderer, { content: "", wrapMode: "none" });
-    this.stop = new TextRenderable15(renderer, {
+    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 TextRenderable15(renderer, { content: "", wrapMode: "none" });
+    this.detail = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
     line.add(this.title);
     line.add(this.stop);
     this.renderable.add(line);
@@ -20637,16 +21038,17 @@ class TaskRowView {
       return;
     this.taskId = row.taskId;
     const frame = SPINNER_FRAMES[Math.floor(now / SPINNER_STEP_MS2) % SPINNER_FRAMES.length];
-    this.title.content = new StyledText14([
-      fg16(Theme.status.success)(`${frame} `),
-      bold9(fg16(Theme.fg.primary)(row.kind)),
-      fg16(Theme.fg.secondary)(` ${row.title}`)
+    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 StyledText14([
-      fg16(Theme.fg.muted)(`${row.stats} `),
-      bold9(fg16(Theme.fg.secondary)("[stop]"))
+    this.stop.content = new StyledText15([
+      fg17(Theme.fg.muted)(`${row.stats} `),
+      bold10(fg17(Theme.fg.secondary)("[stop]"))
     ]);
-    this.detail.content = new StyledText14([dim7(fg16(Theme.fg.muted)(`  \u2514 ${row.detail}`))]);
+    this.detail.content = new StyledText15([dim8(fg17(Theme.fg.muted)(`  \u2514 ${row.detail}`))]);
   }
 }
 
@@ -20657,14 +21059,16 @@ class TaskPanel {
   rows;
   overflow;
   constructor(renderer, onStop) {
-    this.renderable = new BoxRenderable16(renderer, {
+    this.renderable = new BoxRenderable17(renderer, {
       flexShrink: 0,
       paddingLeft: 2,
       paddingRight: 2,
+      border: ["top"],
+      borderColor: Theme.border.subtle,
       visible: false
     });
-    this.header = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
-    this.overflow = new TextRenderable16(renderer, { content: "", wrapMode: "none" });
+    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)
@@ -20676,15 +21080,15 @@ class TaskPanel {
     if (tasks.length === 0)
       return;
     const rows = buildTaskRows(tasks, now);
-    this.header.content = new StyledText15([bold10(fg17(Theme.fg.secondary)(buildTaskHeader(tasks)))]);
+    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 StyledText15([dim8(fg17(Theme.fg.muted)(`  +${hidden} more`))]) : "";
+    this.overflow.content = hidden ? new StyledText16([dim9(fg18(Theme.fg.muted)(`  +${hidden} more`))]) : "";
   }
 }
 
 // apps/tui/src/components/toastView.ts
-import { BoxRenderable as BoxRenderable17, fg as fg18, StyledText as StyledText16, TextRenderable as TextRenderable17 } 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 {
@@ -20692,7 +21096,7 @@ class ToastView {
   text;
   toastId;
   constructor(renderer) {
-    this.renderable = new BoxRenderable17(renderer, {
+    this.renderable = new BoxRenderable18(renderer, {
       position: "absolute",
       top: 1,
       right: 2,
@@ -20703,7 +21107,7 @@ class ToastView {
       borderStyle: "rounded",
       visible: false
     });
-    this.text = new TextRenderable17(renderer, { content: "", wrapMode: "none", selectable: false });
+    this.text = new TextRenderable18(renderer, { content: "", wrapMode: "none", selectable: false });
     this.renderable.add(this.text);
   }
   update({ ui }) {
@@ -20714,9 +21118,9 @@ class ToastView {
     this.toastId = toast.id;
     this.renderable.borderColor = Theme.border.focus;
     this.renderable.backgroundColor = Theme.bg.surface;
-    this.text.content = new StyledText16([
-      fg18(Theme.status.success)(`${TOAST_ICON} `),
-      fg18(Theme.fg.primary)(toast.text)
+    this.text.content = new StyledText17([
+      fg19(Theme.status.success)(`${TOAST_ICON} `),
+      fg19(Theme.fg.primary)(toast.text)
     ]);
   }
 }
@@ -20745,6 +21149,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 = {
@@ -20844,7 +21251,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}` });
     }
   },
@@ -20873,8 +21280,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, {
@@ -20946,6 +21355,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),
@@ -20963,7 +21380,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,
@@ -21142,23 +21558,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();
@@ -21242,7 +21657,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;
@@ -21290,7 +21710,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";
@@ -21635,21 +22055,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;
@@ -21662,6 +22131,7 @@ async function startTui(client, options = {}) {
   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);
@@ -21671,8 +22141,10 @@ async function startTui(client, options = {}) {
   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),
@@ -21705,7 +22177,7 @@ async function startTui(client, options = {}) {
       saveDraft(text);
     }
   });
-  const root = new BoxRenderable18(activeRenderer, {
+  const root = new BoxRenderable19(activeRenderer, {
     width: "100%",
     height: "100%",
     flexDirection: "column",
@@ -21716,11 +22188,12 @@ async function startTui(client, options = {}) {
     scrollback,
     diffViewer,
     statusLine,
-    taskPanel,
+    promptQueue,
     popover,
     backgroundPanel,
     input,
-    infoBar
+    infoBar,
+    taskPanel
   ];
   for (const part of parts)
     root.add(part.renderable);
@@ -21747,11 +22220,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();
@@ -21762,6 +22237,7 @@ async function startTui(client, options = {}) {
     header.update(state);
     statusLine.update(state);
     taskPanel.update(state);
+    promptQueue.update(state);
     toastView.update(state);
     infoBar.update(state);
     scrollback.update(state);
@@ -21773,7 +22249,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) ?? "");
@@ -21781,6 +22257,7 @@ 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);
@@ -23892,7 +24369,8 @@ function useColor() {
 var program = new Command;
 
 // apps/cli/src/index.ts
-var DEFAULT_PORT2 = "7777";
+var DEFAULT_PORT = "7777";
+var runId = createRunId();
 var program2 = new Command().name("claudin").enablePositionalOptions();
 var printResumeHint = (sessionId) => {
   if (!sessionId)
@@ -23906,10 +24384,12 @@ var exitOnDestroy = (renderer) => {
   renderer.on("destroy", () => process.exit(0));
 };
 var openContext = (sessionId) => createDaemonContext(undefined, sessionId).catch((error) => program2.error(error.message));
-var daemonUrl = (port) => `ws://localhost:${Number(port)}`;
-program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, --session <id>", "resume a previous session").action(async (opts) => {
-  const server = await startDaemon(Number(opts.port), await openContext(opts.session));
-  const renderer = await startTui(await DaemonClient.connect(daemonUrl(opts.port)), {
+var daemonUrl = (port) => `ws://127.0.0.1:${Number(port)}`;
+program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-s, --session <id>", "resume a previous session").action(async (opts) => {
+  const token = createAccessToken();
+  const server = await startDaemon(Number(opts.port), token, await openContext(opts.session));
+  const client = await DaemonClient.connect(daemonUrl(opts.port), { token, runId });
+  const renderer = await startTui(client, {
     resumeSessionId: opts.session,
     onExit: printResumeHint
   });
@@ -23919,14 +24399,16 @@ program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, -
     server.close(() => process.exit(0));
   });
 });
-program2.command("daemon").description("Run the daemon without a UI so terminals can attach to it").option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, --session <id>", "serve a previous session").action(async (opts) => {
-  await startDaemon(Number(opts.port), await openContext(opts.session));
-  process.stdout.write(`Daemon on ${daemonUrl(opts.port)}
-Attach with: claudin attach -p ${opts.port}
+program2.command("daemon").description("Run the daemon without a UI so terminals can attach to it").option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-s, --session <id>", "serve a previous session").action(async (opts) => {
+  const token = createAccessToken();
+  await startDaemon(Number(opts.port), token, await openContext(opts.session));
+  process.stdout.write(`Daemon on ${daemonUrl(opts.port)} (run ${runId})
+Attach with: claudin attach -p ${opts.port} --token ${token}
 `);
 });
-program2.command("attach").description("Attach another terminal to a running daemon's live session").option("-p, --port <port>", "daemon port", DEFAULT_PORT2).action(async (opts) => {
-  const client = await DaemonClient.connect(daemonUrl(opts.port)).catch((error) => program2.error(error.message));
+program2.command("attach").description("Attach another terminal to a running daemon's live session").option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-t, --token <token>", "access token printed by the daemon (or CLAUDIN_TOKEN)").action(async (opts) => {
+  const token = opts.token ?? process.env.CLAUDIN_TOKEN ?? program2.error("An access token is required: pass --token or set CLAUDIN_TOKEN");
+  const client = await DaemonClient.connect(daemonUrl(opts.port), { token, runId }).catch((error) => program2.error(error.message));
   const renderer = await startTui(client, { attach: true, onExit: printResumeHint });
   client.onDisconnect(() => renderer.destroy());
   exitOnDestroy(renderer);