kaizenai 0.7.2 → 0.8.1

package/dist/server/cli.js

@@ -22,7 +22,7 @@ import { fileURLToPath } from "url";
 var package_default = {
   name: "kaizenai",
   type: "module",
-  version: "0.7.2",
+  version: "0.8.1",
   description: "Local web UI for coding agents",
   keywords: [
     "claude",
@@ -79,6 +79,7 @@ var package_default = {
   },
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "^0.2.39",
+    "@pierre/diffs": "^1.1.12",
     "@radix-ui/react-context-menu": "^2.2.16",
     "@radix-ui/react-select": "^2.2.6",
     "@xterm/addon-fit": "^0.11.0",
@@ -183,6 +184,9 @@ function getManagedBackgroundsDirPath(homeDir, env = getRuntimeEnv()) {
 function getProviderSettingsFilePath(homeDir, env = getRuntimeEnv()) {
   return `${getDataRootDir(homeDir, env)}/providers.json`;
 }
+function getGeneralSettingsFilePath(homeDir, env = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/general.json`;
+}
 function getRemoteAuthFilePath(homeDir, env = getRuntimeEnv()) {
   return `${getDataRootDir(homeDir, env)}/remote-auth.json`;
 }
@@ -829,7 +833,7 @@ ${stderr}`);
 }
 
 // src/server/server.ts
-import path27 from "path";
+import path29 from "path";
 import QRCode2 from "qrcode";
 
 // src/server/event-store.ts
@@ -1033,6 +1037,12 @@ var OPENROUTER_ATTACHMENT_CAPABILITIES = {
   markdown: true,
   document: true
 };
+var MIN_SEND_CHUNK_SIZE_BYTES = 16 * 1024;
+var MAX_SEND_CHUNK_SIZE_BYTES = 1024 * 1024;
+var DEFAULT_SENT_CHUNK_SIZE_BYTES = 200 * 1024;
+var DEFAULT_GENERAL_SETTINGS = {
+  sendChunkSizeBytes: DEFAULT_SENT_CHUNK_SIZE_BYTES
+};
 var FEATURE_ACCESS_REQUIREMENTS = {
   openrouter: "account",
   providerUsage: "account",
@@ -4202,7 +4212,7 @@ function normalizeToolCall(args) {
 
 // src/server/attachments.ts
 import path5 from "path";
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, unlink, writeFile as writeFile2 } from "fs/promises";
 var ATTACHMENTS_ROUTE_PREFIX = "/attachments";
 var MAX_CHAT_IMAGE_DATA_URL_CHARS = 14000000;
 var MAX_CHAT_DOCUMENT_DATA_URL_CHARS = 30000000;
@@ -4312,6 +4322,23 @@ async function persistChatAttachments(input) {
   }
   return persisted;
 }
+async function deleteStagedAttachmentsForUserPrompt(input) {
+  const attachments = input.userPrompt.attachments;
+  if (!attachments?.length)
+    return;
+  for (const attachment of attachments) {
+    const filePath = resolveAttachmentPath(input.attachmentsDir, attachment.relativePath);
+    if (!filePath)
+      continue;
+    try {
+      await unlink(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+}
 
 // src/server/codex-app-server.ts
 import { spawn as spawn2 } from "child_process";
@@ -7954,6 +7981,33 @@ function normalizeOpenCodeToolResult(args) {
     isError: args.status === "failed"
   };
 }
+function looksLikeDeliveredPlan(assistantText) {
+  const trimmed = assistantText.trim();
+  if (trimmed.length < 160)
+    return false;
+  const markdownHeadings = trimmed.match(/(^|\n)#{1,6}\s+/g)?.length ?? 0;
+  const listItems = trimmed.match(/(^|\n)(?:\d+\.\s+|[-*]\s+)/g)?.length ?? 0;
+  const hasTable = /\|[^\n]+\|/.test(trimmed);
+  const hasPlanHeading = /(^|\n)#{1,6}\s+.*\bplan\b/m.test(trimmed);
+  const hasApprovalPrompt = /do you want me to proceed|would you like any changes to this plan|should i proceed with implementation|ready to proceed with implementation|does this plan look good/i.test(trimmed);
+  return hasPlanHeading && (markdownHeadings >= 2 || listItems >= 3 || hasTable) || hasApprovalPrompt && (markdownHeadings >= 1 || listItems >= 3 || hasTable);
+}
+function createSyntheticOpenCodeExitPlanTool(context, turn) {
+  const observedExitPlanTool = [...turn.toolCalls.values()].find((tool) => tool.toolKind === "exit_plan_mode");
+  if (observedExitPlanTool && turn.interactiveToolRequestIds.has(observedExitPlanTool.toolId)) {
+    return null;
+  }
+  if (turn.sawExitPlanModeCall && !observedExitPlanTool)
+    return null;
+  if (!looksLikeDeliveredPlan(turn.assistantText))
+    return null;
+  const hydrated = populateExitPlanFromAssistantText(observedExitPlanTool ?? normalizeToolCall({
+    toolName: "ExitPlanMode",
+    toolId: `${context.sessionId ?? "opencode"}:${randomUUID5()}:synthetic-exit-plan`,
+    input: {}
+  }), turn.assistantText);
+  return hydrated.toolKind === "exit_plan_mode" && hydrated.input.plan ? hydrated : null;
+}
 function extractOpenCodeStderrTurnError(line) {
   const jsonMatch = line.match(/error=(\{.*\})\s+stream error$/);
   if (jsonMatch) {
@@ -8728,6 +8782,14 @@ class OpenCodeAcpManager {
       return;
     if (turn.pendingInteractiveToolIds.size > 0)
       return;
+    if (context.currentPlanMode && !turn.completedExitPlanMode) {
+      const syntheticExitPlan = createSyntheticOpenCodeExitPlanTool(context, turn);
+      if (syntheticExitPlan) {
+        turn.toolCalls.set(syntheticExitPlan.toolId, syntheticExitPlan);
+        await this.requestInteractiveTool(context, turn, syntheticExitPlan);
+        return;
+      }
+    }
     if (context.currentPlanMode && !turn.completedExitPlanMode) {
       const failureMessage = turn.sawExitPlanModeCall ? `OpenCode ended the plan turn with stop reason "${turn.promptStopReason}" before exit_plan_mode was confirmed. No plan was delivered for approval.` : `OpenCode ended the plan turn with stop reason "${turn.promptStopReason}" without calling exit_plan_mode. No plan was delivered for approval.`;
       this.failPendingTurn(context, turn, failureMessage);
@@ -11704,7 +11766,7 @@ function deriveSuggestedProjectFolders(state, discoveredProjects) {
   }
   return [...candidates.entries()].map(([localPath, label]) => ({ localPath, label })).slice(0, 12);
 }
-function deriveChatSnapshot(state, activeStatus, chatId, getTranscriptWindow, getLastModel, pendingTool = null, usage = null, providerSettings, availableProviders) {
+function deriveChatSnapshot(state, activeStatus, chatId, getTranscriptWindow, getLastModel, pendingTool = null, usage = null, diffs = null, providerSettings, availableProviders, queuedOutbound) {
   const chat = state.chatsById.get(chatId);
   if (!chat || chat.deletedAt)
     return null;
@@ -11724,6 +11786,7 @@ function deriveChatSnapshot(state, activeStatus, chatId, getTranscriptWindow, ge
     sessionToken: chat.sessionToken,
     updatedAt: chat.updatedAt,
     pendingTool,
+    queuedOutbound: queuedOutbound && queuedOutbound.length > 0 ? queuedOutbound : undefined,
     hydrationState: chat.hydrationState ?? "local",
     inactiveProviderMessage: provider ? getProviderInactiveMessage(provider, providerSettings) : null
   };
@@ -11733,6 +11796,7 @@ function deriveChatSnapshot(state, activeStatus, chatId, getTranscriptWindow, ge
     runtime,
     messages: transcript.entries,
     transcript,
+    diffs,
     usage,
     availableProviders: availableProviders ?? getSelectableProviders(providerSettings),
     providerSettings
@@ -11759,6 +11823,25 @@ var CLAUDE_TOOLSET = [
   "ExitPlanMode"
 ];
 var CHAT_RESOURCE_IDLE_TTL_MS = 2 * 60 * 1000;
+function previewForOutboundQueue(text, attachmentCount = 0) {
+  const singleLine = text.trim().replace(/\s+/g, " ");
+  if (!singleLine) {
+    return attachmentCount > 1 ? `${attachmentCount} attachments` : "Attachment";
+  }
+  if (singleLine.length <= 120)
+    return singleLine;
+  return `${singleLine.slice(0, 117)}...`;
+}
+function restampTranscriptEntryAfterLatest(latestCreatedAt, entry) {
+  const createdAt = Math.max(Date.now(), latestCreatedAt + 1);
+  if (entry.createdAt >= createdAt) {
+    return entry;
+  }
+  return {
+    ...entry,
+    createdAt
+  };
+}
 var noopRealtime = {
   publishChatMessageAppended: () => {},
   publishChatMessagesAppended: () => {},
@@ -11771,6 +11854,7 @@ var noopRealtime = {
   publishChatUsageSet: () => {},
   publishChatAvailableProvidersSet: () => {},
   publishChatTranscriptWindowMetaSet: () => {},
+  publishChatOutboundQueueSet: () => {},
   publishChatDeleted: () => {},
   publishSidebarChatFieldsSet: () => {},
   publishSidebarChatAdded: () => {},
@@ -12217,6 +12301,10 @@ class AgentCoordinator {
   providerCatalogManager;
   generateTitle;
   activeTurns = new Map;
+  outboundQueues = new Map;
+  drainingOutboundQueues = new Set;
+  outboundQueueRetryTimers = new Map;
+  latestTranscriptCreatedAt = new Map;
   liveUsage = new Map;
   disposeTimers = new Map;
   realtime = noopRealtime;
@@ -12298,7 +12386,10 @@ class AgentCoordinator {
     return state?.projectsById ? this.store.state : null;
   }
   async prewarmEnabledProviders(providers, localPath = process.cwd()) {
-    const orderedProviders = providers.includes("codex") ? ["codex", ...providers.filter((provider) => provider !== "codex")] : providers;
+    const orderedProviders = providers.includes("codex") ? [
+      "codex",
+      ...providers.filter((provider) => provider !== "codex")
+    ] : providers;
     for (const provider of orderedProviders) {
       try {
         await this.providerRuntimeSupervisor.prewarmPrimary(provider, localPath);
@@ -12408,6 +12499,169 @@ class AgentCoordinator {
     this.realtime.publishChatUsageSet(chatId, this.getLiveUsage(chatId));
     this.realtime.publishSidebarProviderUsageSet(this.getProviderUsage());
   }
+  publishOutboundQueueSet(chatId) {
+    const queue = this.outboundQueues.get(chatId);
+    const queuedMessages = queue?.map((item) => ({
+      id: item.id,
+      preview: item.preview,
+      text: item.content,
+      attachmentCount: item.attachmentCount
+    })) ?? [];
+    this.realtime.publishChatOutboundQueueSet(chatId, queuedMessages);
+  }
+  getQueuedOutboundPreview(chatId) {
+    const queue = this.outboundQueues.get(chatId);
+    return queue?.map((item) => ({
+      id: item.id,
+      preview: item.preview,
+      text: item.content,
+      attachmentCount: item.attachmentCount
+    })) ?? [];
+  }
+  getLatestTranscriptCreatedAt(chatId) {
+    const cached = this.latestTranscriptCreatedAt.get(chatId);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const latest = this.store.getMessages(chatId).reduce((max, entry) => Math.max(max, entry.createdAt), 0);
+    this.latestTranscriptCreatedAt.set(chatId, latest);
+    return latest;
+  }
+  restampTranscriptEntryAfterLatest(chatId, entry) {
+    const latestCreatedAt = this.getLatestTranscriptCreatedAt(chatId);
+    const restamped = restampTranscriptEntryAfterLatest(latestCreatedAt, entry);
+    this.latestTranscriptCreatedAt.set(chatId, Math.max(latestCreatedAt, restamped.createdAt));
+    return restamped;
+  }
+  async clearOutboundQueueForChat(chatId) {
+    const retryTimer = this.outboundQueueRetryTimers.get(chatId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.outboundQueueRetryTimers.delete(chatId);
+    }
+    const queue = this.outboundQueues.get(chatId);
+    if (!queue?.length) {
+      this.outboundQueues.delete(chatId);
+      this.publishOutboundQueueSet(chatId);
+      return;
+    }
+    for (const item of queue) {
+      await this.safeDeleteQueuedPromptAttachments(chatId, item.userPrompt);
+    }
+    this.outboundQueues.delete(chatId);
+    this.publishOutboundQueueSet(chatId);
+  }
+  async safeDeleteQueuedPromptAttachments(chatId, userPrompt) {
+    try {
+      await deleteStagedAttachmentsForUserPrompt({
+        attachmentsDir: this.attachmentsDir,
+        userPrompt
+      });
+    } catch (error) {
+      console.error("Failed to delete staged queued attachments:", {
+        chatId,
+        userPromptId: userPrompt._id,
+        error
+      });
+    }
+  }
+  async maybeDrainOutboundQueueHead(chatId) {
+    if (this.activeTurns.has(chatId))
+      return;
+    if (this.drainingOutboundQueues.has(chatId))
+      return;
+    const queue = this.outboundQueues.get(chatId);
+    if (!queue?.length)
+      return;
+    const retryTimer = this.outboundQueueRetryTimers.get(chatId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.outboundQueueRetryTimers.delete(chatId);
+    }
+    this.drainingOutboundQueues.add(chatId);
+    const item = queue.shift();
+    if (queue.length === 0) {
+      this.outboundQueues.delete(chatId);
+    }
+    this.publishOutboundQueueSet(chatId);
+    try {
+      const userPrompt = this.restampTranscriptEntryAfterLatest(chatId, item.userPrompt);
+      await this.startTurnForChat({
+        chatId,
+        provider: item.provider,
+        content: item.content,
+        attachments: userPrompt.attachments,
+        model: item.model,
+        effort: item.effort,
+        serviceTier: item.serviceTier,
+        fastMode: item.fastMode,
+        planMode: item.planMode,
+        appendUserPrompt: userPrompt,
+        pushChatSnapshotRefresh: true
+      });
+    } catch (error) {
+      const restored = this.outboundQueues.get(chatId) ?? [];
+      this.outboundQueues.set(chatId, [item, ...restored]);
+      this.publishOutboundQueueSet(chatId);
+      console.error("Outbound queue drain failed:", error);
+      const retryHandle = setTimeout(() => {
+        this.outboundQueueRetryTimers.delete(chatId);
+        const retryQueue = this.outboundQueues.get(chatId);
+        if (!retryQueue?.length)
+          return;
+        if (retryQueue[0]?.id !== item.id)
+          return;
+        if (this.activeTurns.has(chatId))
+          return;
+        this.maybeDrainOutboundQueueHead(chatId);
+      }, 1000);
+      this.outboundQueueRetryTimers.set(chatId, retryHandle);
+    } finally {
+      this.drainingOutboundQueues.delete(chatId);
+    }
+  }
+  async removeOutboundQueueMessage(chatId, messageId) {
+    const queue = this.outboundQueues.get(chatId);
+    if (!queue) {
+      throw new Error("Queued message not found");
+    }
+    const index = queue.findIndex((item) => item.id === messageId);
+    if (index < 0) {
+      throw new Error("Queued message not found");
+    }
+    const [removed] = queue.splice(index, 1);
+    if (queue.length === 0) {
+      this.outboundQueues.delete(chatId);
+    }
+    await this.safeDeleteQueuedPromptAttachments(chatId, removed.userPrompt);
+    this.publishOutboundQueueSet(chatId);
+    if (!this.activeTurns.has(chatId)) {
+      await this.maybeDrainOutboundQueueHead(chatId);
+    }
+  }
+  async updateOutboundQueueMessage(chatId, messageId, text) {
+    const queue = this.outboundQueues.get(chatId);
+    if (!queue) {
+      throw new Error("Queued message not found");
+    }
+    const item = queue.find((entry) => entry.id === messageId);
+    if (!item) {
+      throw new Error("Queued message not found");
+    }
+    const trimmed = text.trim();
+    const attachmentCount = item.userPrompt.attachments?.length ?? 0;
+    const hasAttachments = attachmentCount > 0;
+    if (!trimmed && !hasAttachments) {
+      throw new Error("Message must include text or attachments");
+    }
+    item.content = trimmed;
+    item.preview = previewForOutboundQueue(trimmed, attachmentCount);
+    item.userPrompt = {
+      ...item.userPrompt,
+      content: trimmed
+    };
+    this.publishOutboundQueueSet(chatId);
+  }
   async failTurnResumeAccessDenied(active, message) {
     const errorEntry = timestamped3({
       kind: "result",
@@ -12437,6 +12691,7 @@ class AgentCoordinator {
     this.publishPendingTool(active.chatId);
     this.publishChatStatus(active.chatId);
     this.publishSidebarChatState(active.chatId);
+    await this.maybeDrainOutboundQueueHead(active.chatId);
   }
   publishAvailableProviders(chatId) {
     const providerSettings = this.providerSettingsManager?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS;
@@ -12571,10 +12826,14 @@ class AgentCoordinator {
     const sidebarStoreState = this.getSidebarStoreState();
     const previousSidebarIndex = args.appendUserPrompt && sidebarStoreState ? deriveSidebarChatIndex(this.store, chat.projectId, previousFeatureId, args.chatId) : -1;
     if (args.appendUserPrompt) {
-      await this.store.appendMessage(args.chatId, args.appendUserPrompt);
-      this.realtime.publishChatMessageAppended(args.chatId, args.appendUserPrompt);
+      const userPrompt = this.restampTranscriptEntryAfterLatest(args.chatId, args.appendUserPrompt);
+      await this.store.appendMessage(args.chatId, userPrompt);
+      this.realtime.publishChatMessageAppended(args.chatId, userPrompt);
       this.publishTranscriptMeta(args.chatId);
       this.publishPendingTool(args.chatId);
+      if (args.pushChatSnapshotRefresh) {
+        this.realtime.refreshChatSnapshot?.(args.chatId);
+      }
     }
     await this.store.recordTurnStarted(args.chatId);
     const project = this.store.getProject(chat.projectId);
@@ -12814,6 +13073,7 @@ class AgentCoordinator {
       this.publishPendingTool(args.chatId);
       this.publishChatStatus(args.chatId);
       this.publishSidebarChatState(args.chatId);
+      this.maybeDrainOutboundQueueHead(args.chatId);
     }
   }
   assertProviderAccess(provider) {
@@ -12844,6 +13104,19 @@ class AgentCoordinator {
     const settings = this.getProviderSettings(provider, command);
     validateProviderAttachmentSupport(provider, settings.model, command.message.attachments, this.providerCatalogManager?.getSnapshot());
     const text = command.message.text.trim();
+    const requestedAttachmentCount = command.message.attachments?.length ?? 0;
+    if (!text && requestedAttachmentCount === 0) {
+      throw new Error("Message must include text or attachments");
+    }
+    const active = this.activeTurns.get(chatId);
+    if (active?.status === "waiting_for_user") {
+      throw new Error("Chat is waiting for a tool response");
+    }
+    const queue = this.outboundQueues.get(chatId);
+    const shouldEnqueue = Boolean(queue?.length) || Boolean(active && (active.status === "starting" || active.status === "running"));
+    if (shouldEnqueue && chat.planMode) {
+      throw new Error("Cannot queue messages while plan mode is active");
+    }
     const userPrompt = timestamped3({
       kind: "user_prompt",
       content: text
@@ -12855,8 +13128,28 @@ class AgentCoordinator {
       uploads: command.message.attachments
     });
     userPrompt.attachments = attachments;
-    if (!text && !attachments?.length) {
-      throw new Error("Message must include text or attachments");
+    if (shouldEnqueue) {
+      const id = crypto.randomUUID();
+      const attachmentCount = attachments?.length ?? 0;
+      const preview = previewForOutboundQueue(text, attachmentCount);
+      const queued = {
+        id,
+        preview,
+        attachmentCount,
+        provider,
+        model: settings.model,
+        effort: settings.effort,
+        serviceTier: settings.serviceTier,
+        fastMode: settings.fastMode,
+        planMode: settings.planMode,
+        content: text,
+        userPrompt
+      };
+      const list = queue ?? [];
+      list.push(queued);
+      this.outboundQueues.set(chatId, list);
+      this.publishOutboundQueueSet(chatId);
+      return { chatId, queued: true, queuedMessageId: id };
     }
     await this.startTurnForChat({
       chatId,
@@ -12922,19 +13215,20 @@ class AgentCoordinator {
         if (event.entry.kind === "tool_call" && active.syntheticToolCallIds.delete(event.entry.tool.toolId)) {
           continue;
         }
-        await this.store.appendMessage(active.chatId, event.entry);
-        this.realtime.publishChatMessageAppended(active.chatId, event.entry);
+        const entry = this.restampTranscriptEntryAfterLatest(active.chatId, event.entry);
+        await this.store.appendMessage(active.chatId, entry);
+        this.realtime.publishChatMessageAppended(active.chatId, entry);
         this.publishTranscriptMeta(active.chatId);
         this.publishPendingTool(active.chatId);
         this.publishSidebarChatState(active.chatId);
-        if (event.entry.kind === "system_init") {
+        if (entry.kind === "system_init") {
           active.status = "running";
           this.publishChatStatus(active.chatId);
         }
-        if (event.entry.kind === "result") {
+        if (entry.kind === "result") {
           active.hasFinalResult = true;
-          if (event.entry.isError) {
-            await this.store.recordTurnFailed(active.chatId, event.entry.result || "Turn failed");
+          if (entry.isError) {
+            await this.store.recordTurnFailed(active.chatId, entry.result || "Turn failed");
             active.status = "failed";
           } else if (!active.cancelRequested) {
             await this.store.recordTurnFinished(active.chatId);
@@ -13016,9 +13310,11 @@ class AgentCoordinator {
           this.publishSidebarChatState(active.chatId);
         }
       }
+      await this.maybeDrainOutboundQueueHead(active.chatId);
     }
   }
   async cancel(chatId) {
+    await this.clearOutboundQueueForChat(chatId);
     const active = this.activeTurns.get(chatId);
     if (!active)
       return;
@@ -13069,6 +13365,7 @@ class AgentCoordinator {
       await this.cancel(chatId);
       return;
     }
+    await this.clearOutboundQueueForChat(chatId);
     active.cancelRequested = true;
     active.cancelRecorded = true;
     active.hasFinalResult = true;
@@ -13543,7 +13840,83 @@ function discoverProjects(homeDir = homedir9(), adapters = DEFAULT_PROJECT_DISCO
 
 // src/server/git-manager.ts
 import path14 from "path";
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile3, stat as stat4, writeFile as writeFile3 } from "fs/promises";
+function normalizeDiffPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function countContentLines(value) {
+  if (value.length === 0)
+    return 0;
+  const normalized = value.replaceAll(`\r
+`, `
+`);
+  return normalized.endsWith(`
+`) ? normalized.slice(0, -1).split(`
+`).length : normalized.split(`
+`).length;
+}
+var MAX_UNTRACKED_PREVIEW_BYTES = 128 * 1024;
+function buildUntrackedFilePatch(filePath, content) {
+  const normalizedPath = normalizeDiffPath(filePath);
+  const normalizedContent = content.replaceAll(`\r
+`, `
+`);
+  const hasTrailingNewline = normalizedContent.endsWith(`
+`);
+  const bodyLines = normalizedContent.length === 0 ? [] : normalizedContent.split(`
+`).slice(0, hasTrailingNewline ? -1 : undefined).map((line) => `+${line}`);
+  const lineCount = countContentLines(normalizedContent);
+  const patchLines = [
+    `diff --git a/${normalizedPath} b/${normalizedPath}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${normalizedPath}`,
+    `@@ -0,0 +1,${lineCount} @@`,
+    ...bodyLines
+  ];
+  if (lineCount > 0 && !hasTrailingNewline) {
+    patchLines.push("\");
+  }
+  return `${patchLines.join(`
+`)}
+`;
+}
+function isBinaryBuffer(buffer) {
+  const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
+  if (sample.includes(0))
+    return true;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(sample);
+    return false;
+  } catch {}
+  let suspiciousBytes = 0;
+  for (const value of sample) {
+    if (value === 9 || value === 10 || value === 13 || value >= 32 && value <= 126) {
+      continue;
+    }
+    suspiciousBytes += 1;
+  }
+  return sample.length > 0 && suspiciousBytes / sample.length > 0.3;
+}
+function splitPatchByFile(patch) {
+  const patchesByPath = new Map;
+  const blocks = patch.split(/(?=^diff --git )/m).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.split(`
+`);
+    const plusLine = lines.find((line) => line.startsWith("+++ "));
+    const minusLine = lines.find((line) => line.startsWith("--- "));
+    const renameToLine = lines.find((line) => line.startsWith("rename to "));
+    const renameFromLine = lines.find((line) => line.startsWith("rename from "));
+    const candidate = plusLine && !plusLine.includes("/dev/null") ? plusLine.replace(/^\+\+\+ b\//, "") : minusLine && !minusLine.includes("/dev/null") ? minusLine.replace(/^--- a\//, "") : renameToLine ? renameToLine.replace(/^rename to /, "") : renameFromLine ? renameFromLine.replace(/^rename from /, "") : null;
+    if (!candidate)
+      continue;
+    patchesByPath.set(normalizeDiffPath(candidate), `${block}
+`);
+  }
+  return patchesByPath;
+}
+
 class GitManager {
   async runGit(cwd, args) {
     const proc = Bun.spawn(["git", "-C", cwd, ...args], {
@@ -13557,6 +13930,210 @@ class GitManager {
     ]);
     return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
   }
+  async runGitRaw(cwd, args) {
+    const proc = Bun.spawn(["git", "-C", cwd, ...args], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    return { exitCode, stdout, stderr: stderr.trim() };
+  }
+  async getStatusEntries(localPath) {
+    const result = await this.runGitRaw(localPath, [
+      "status",
+      "--porcelain=v1",
+      "--untracked-files=all",
+      "-z"
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || "git status failed");
+    }
+    const parts = result.stdout.split("\x00").filter(Boolean);
+    const entries = [];
+    for (let index = 0;index < parts.length; index += 1) {
+      const part = parts[index];
+      if (part.length < 4)
+        continue;
+      const indexStatus = part[0] ?? " ";
+      const worktreeStatus = part[1] ?? " ";
+      const filePath = part.slice(3);
+      if (!filePath)
+        continue;
+      if (indexStatus === "R" || indexStatus === "C" || worktreeStatus === "R" || worktreeStatus === "C") {
+        const originalPath = parts[index + 1];
+        if (!originalPath)
+          continue;
+        entries.push({
+          indexStatus,
+          worktreeStatus,
+          path: filePath,
+          originalPath
+        });
+        index += 1;
+        continue;
+      }
+      entries.push({ indexStatus, worktreeStatus, path: filePath });
+    }
+    return entries;
+  }
+  async getBranchState(localPath) {
+    const repoResult = await this.runGit(localPath, ["rev-parse", "--show-toplevel"]);
+    if (repoResult.exitCode !== 0) {
+      return {
+        isRepo: false,
+        branchName: null,
+        hasUpstream: false,
+        hasHead: false
+      };
+    }
+    const branchResult = await this.runGit(localPath, [
+      "symbolic-ref",
+      "--quiet",
+      "--short",
+      "HEAD"
+    ]);
+    const headResult = await this.runGit(localPath, ["rev-parse", "--verify", "HEAD"]);
+    const hasHead = headResult.exitCode === 0;
+    const detachedHeadResult = hasHead && branchResult.exitCode !== 0 ? await this.runGit(localPath, ["rev-parse", "--abbrev-ref", "HEAD"]) : null;
+    const upstreamResult = await this.runGit(localPath, [
+      "rev-parse",
+      "--abbrev-ref",
+      "--symbolic-full-name",
+      "@{upstream}"
+    ]);
+    return {
+      isRepo: true,
+      branchName: branchResult.exitCode === 0 ? branchResult.stdout : detachedHeadResult && detachedHeadResult.stdout !== "HEAD" ? detachedHeadResult.stdout : null,
+      hasUpstream: upstreamResult.exitCode === 0 && upstreamResult.stdout.length > 0,
+      hasHead
+    };
+  }
+  async getDiffSnapshot(localPath) {
+    const branchState = await this.getBranchState(localPath);
+    if (!branchState.isRepo) {
+      return {
+        status: "not_repo",
+        branchName: branchState.branchName,
+        hasUpstream: false,
+        files: [],
+        error: null,
+        refreshedAt: Date.now()
+      };
+    }
+    const statuses = await this.getStatusEntries(localPath);
+    const trackedDiff = await this.runGitRaw(localPath, branchState.hasHead ? ["diff", "--no-ext-diff", "--find-renames", "--patch", "HEAD", "--"] : ["diff", "--no-ext-diff", "--find-renames", "--cached", "--patch", "--"]);
+    if (trackedDiff.exitCode !== 0) {
+      throw new Error(trackedDiff.stderr || "git diff failed");
+    }
+    const trackedPatches = splitPatchByFile(trackedDiff.stdout);
+    const files = (await Promise.all(statuses.map(async (entry) => this.getDiffFile(localPath, entry, trackedPatches)))).filter((value) => value !== null);
+    return {
+      status: "ready",
+      branchName: branchState.branchName,
+      hasUpstream: branchState.hasUpstream,
+      files,
+      error: null,
+      refreshedAt: Date.now()
+    };
+  }
+  async getDiffFile(localPath, entry, trackedPatches) {
+    const absolutePath = path14.join(localPath, entry.path);
+    const isUntracked = entry.indexStatus === "?" && entry.worktreeStatus === "?";
+    let patch = "";
+    let patchAvailable = true;
+    let patchSummary = null;
+    if (isUntracked) {
+      try {
+        const fileStat = await stat4(absolutePath);
+        if (fileStat.size > MAX_UNTRACKED_PREVIEW_BYTES) {
+          patchAvailable = false;
+          patchSummary = "File too large to preview.";
+        } else {
+          const content = await readFile3(absolutePath);
+          if (isBinaryBuffer(content)) {
+            patchAvailable = false;
+            patchSummary = "Binary file.";
+          } else {
+            patch = buildUntrackedFilePatch(entry.path, new TextDecoder("utf-8").decode(content));
+          }
+        }
+      } catch {
+        patchAvailable = false;
+        patchSummary = "File is no longer available for preview.";
+      }
+    } else {
+      patch = trackedPatches.get(normalizeDiffPath(entry.path)) ?? "";
+    }
+    if (patchAvailable && !patch.trim()) {
+      return null;
+    }
+    return {
+      path: entry.path,
+      previousPath: entry.originalPath ?? null,
+      patch,
+      patchAvailable,
+      patchSummary,
+      changeType: this.getChangeType(entry)
+    };
+  }
+  getChangeType(entry) {
+    if (entry.indexStatus === "?" && entry.worktreeStatus === "?") {
+      return "untracked";
+    }
+    if (entry.indexStatus === "R" || entry.worktreeStatus === "R") {
+      return "renamed";
+    }
+    if (entry.indexStatus === "C" || entry.worktreeStatus === "C") {
+      return "added";
+    }
+    if (entry.indexStatus === "D" || entry.worktreeStatus === "D") {
+      return "deleted";
+    }
+    if (entry.indexStatus === "A" || entry.worktreeStatus === "A") {
+      return "added";
+    }
+    return "modified";
+  }
+  async commitPaths(localPath, paths, summary, description) {
+    const selectedPaths = [
+      ...new Set(paths.filter((value) => value.length > 0))
+    ];
+    if (selectedPaths.length === 0) {
+      throw new Error("No file paths were provided.");
+    }
+    const addResult = await this.runGit(localPath, [
+      "add",
+      "--",
+      ...selectedPaths
+    ]);
+    if (addResult.exitCode !== 0) {
+      throw new Error(addResult.stderr || "Failed to stage selected files.");
+    }
+    const message = description.trim() ? `${summary.trim()}
+
+${description.trim()}` : summary.trim();
+    const commitResult = await this.runGit(localPath, [
+      "commit",
+      "--only",
+      "-m",
+      message,
+      "--",
+      ...selectedPaths
+    ]);
+    if (commitResult.exitCode !== 0) {
+      throw new Error(commitResult.stderr || "Failed to create commit.");
+    }
+  }
+  async pushCurrentBranch(localPath) {
+    const result = await this.runGit(localPath, ["push"]);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || "Failed to push current branch.");
+    }
+  }
   async getBranches(localPath) {
     const [branchResult, headResult] = await Promise.all([
       this.runGit(localPath, ["branch"]),
@@ -13575,7 +14152,11 @@ class GitManager {
     if (result.exitCode !== 0) {
       throw new Error(result.stderr || `Failed to switch to branch "${branchName}"`);
     }
-    const head = await this.runGit(localPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const head = await this.runGit(localPath, [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD"
+    ]);
     return { currentBranch: head.stdout };
   }
   async createBranch(localPath, branchName, checkout) {
@@ -13584,7 +14165,11 @@ class GitManager {
     if (result.exitCode !== 0) {
       throw new Error(result.stderr || `Failed to create branch "${branchName}"`);
     }
-    const head = await this.runGit(localPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const head = await this.runGit(localPath, [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD"
+    ]);
     return { currentBranch: head.stdout };
   }
   async setProjectMetadataDirectoryCommitMode(localPath, commitProjectMetadata) {
@@ -13607,11 +14192,240 @@ class GitManager {
   }
 }
 
+// src/server/generate-commit-message.ts
+import path15 from "path";
+function toSentenceCase(value) {
+  if (!value)
+    return value;
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function summarizePath(path16) {
+  const segments = path16.split(/[\\/]/u).filter(Boolean);
+  return segments.at(-1) ?? path16;
+}
+function describeChange(file) {
+  switch (file.changeType) {
+    case "added":
+    case "untracked":
+      return `add ${summarizePath(file.path)}`;
+    case "deleted":
+      return `remove ${summarizePath(file.path)}`;
+    case "renamed": {
+      const previousPath = file.previousPath ?? file.path;
+      const from = summarizePath(previousPath);
+      const to = summarizePath(file.path);
+      return path15.basename(previousPath) === path15.basename(file.path) ? `rename ${previousPath} to ${file.path}` : `rename ${from} to ${to}`;
+    }
+    default:
+      return `update ${summarizePath(file.path)}`;
+  }
+}
+function generateCommitMessage(files) {
+  if (files.length === 0) {
+    return {
+      subject: "Update project files",
+      body: ""
+    };
+  }
+  const primarySummary = describeChange(files[0]);
+  const remainingCount = files.length - 1;
+  const subject = remainingCount > 0 ? `${toSentenceCase(primarySummary)} and ${remainingCount} more change${remainingCount === 1 ? "" : "s"}` : toSentenceCase(primarySummary);
+  const body = files.map((file) => {
+    const pathText = file.changeType === "renamed" && file.previousPath ? `${file.previousPath} -> ${file.path}` : file.path;
+    return `- ${file.changeType}: ${pathText}`;
+  }).join(`
+`);
+  return { subject, body };
+}
+
+// src/server/diff-store.ts
+function normalizePathForMatch(value) {
+  return value.replaceAll("\\", "/");
+}
+function uniquePaths(paths) {
+  return [...new Set(paths.filter((value) => value.length > 0))];
+}
+
+class DiffStore {
+  git;
+  snapshots = new Map;
+  refreshStateByProjectId = new Map;
+  constructor(git = new GitManager) {
+    this.git = git;
+  }
+  getSnapshot(projectId) {
+    return this.snapshots.get(projectId) ?? null;
+  }
+  clearSnapshot(projectId) {
+    this.snapshots.delete(projectId);
+    this.refreshStateByProjectId.delete(projectId);
+  }
+  async refreshProjectDiffSnapshot({
+    projectId,
+    localPath,
+    force = false
+  }) {
+    const currentState = this.refreshStateByProjectId.get(projectId);
+    if (currentState?.inFlight) {
+      if (force || currentState.localPath !== localPath) {
+        currentState.localPath = localPath;
+        currentState.needsRefresh = true;
+      }
+      return currentState.inFlight;
+    }
+    const refreshState = currentState ?? {
+      inFlight: null,
+      localPath,
+      needsRefresh: false
+    };
+    refreshState.localPath = localPath;
+    const refreshPromise = this.runRefresh(projectId, refreshState);
+    refreshState.inFlight = refreshPromise;
+    this.refreshStateByProjectId.set(projectId, refreshState);
+    return refreshPromise;
+  }
+  async getSnapshotForPath({
+    projectId,
+    localPath
+  }) {
+    const snapshot = this.getSnapshot(projectId);
+    const refreshState = this.refreshStateByProjectId.get(projectId);
+    if (snapshot && refreshState?.localPath === localPath && refreshState.inFlight === null) {
+      return snapshot;
+    }
+    return this.refreshProjectDiffSnapshot({ projectId, localPath });
+  }
+  async generateCommitMessage(args) {
+    const snapshot = await this.getSnapshotForPath({
+      projectId: args.projectId,
+      localPath: args.localPath
+    });
+    const selected = this.getSelectedFiles(snapshot.files, args.paths);
+    return generateCommitMessage(selected);
+  }
+  async commitDiffs({
+    projectId,
+    localPath,
+    paths,
+    summary,
+    description,
+    mode
+  }) {
+    const snapshot = await this.getSnapshotForPath({ projectId, localPath });
+    const selectedFiles = this.getSelectedFiles(snapshot.files, paths);
+    if (selectedFiles.length === 0) {
+      return {
+        ok: false,
+        mode,
+        title: "No changes selected",
+        message: "Select at least one changed file before creating a commit.",
+        detail: null,
+        localCommitCreated: false,
+        snapshotChanged: false
+      };
+    }
+    try {
+      await this.git.commitPaths(localPath, uniquePaths(selectedFiles.flatMap((file) => file.changeType === "renamed" && file.previousPath ? [file.path, file.previousPath] : [file.path])), summary, description);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      const nextSnapshot = await this.refreshProjectDiffSnapshot({
+        projectId,
+        localPath,
+        force: true
+      });
+      return {
+        ok: false,
+        mode,
+        title: "Commit failed",
+        message: "Kaizen could not create a commit from the selected changes.",
+        detail,
+        localCommitCreated: false,
+        snapshotChanged: !areDiffSnapshotsEquivalent(snapshot, nextSnapshot)
+      };
+    }
+    let pushError = null;
+    if (mode === "commit_and_push") {
+      const branchState = await this.git.getBranchState(localPath);
+      if (!branchState.hasUpstream) {
+        pushError = new Error("No upstream branch is configured for the current branch.");
+      } else {
+        try {
+          await this.git.pushCurrentBranch(localPath);
+        } catch (error) {
+          pushError = error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+    await this.refreshProjectDiffSnapshot({
+      projectId,
+      localPath,
+      force: true
+    });
+    if (pushError) {
+      return {
+        ok: false,
+        mode,
+        title: mode === "commit_and_push" ? "Commit created, push failed" : "Commit failed",
+        message: mode === "commit_and_push" ? "The selected changes were committed locally, but Kaizen could not push them." : pushError.message,
+        detail: pushError.message,
+        localCommitCreated: true,
+        snapshotChanged: true
+      };
+    }
+    return {
+      ok: true,
+      mode,
+      title: mode === "commit_and_push" ? "Committed and pushed" : "Commit created",
+      message: mode === "commit_and_push" ? "The selected changes were committed and pushed." : "The selected changes were committed.",
+      detail: null,
+      localCommitCreated: true,
+      snapshotChanged: true
+    };
+  }
+  getSelectedFiles(files, paths) {
+    const selected = new Set(uniquePaths(paths).map(normalizePathForMatch));
+    return files.filter((file) => selected.has(normalizePathForMatch(file.path)));
+  }
+  async runRefresh(projectId, refreshState) {
+    let snapshot = null;
+    while (true) {
+      refreshState.needsRefresh = false;
+      snapshot = await this.git.getDiffSnapshot(refreshState.localPath).catch((error) => ({
+        status: "error",
+        branchName: null,
+        hasUpstream: false,
+        files: [],
+        error: error instanceof Error ? error.message : String(error),
+        refreshedAt: Date.now()
+      }));
+      this.snapshots.set(projectId, snapshot);
+      if (!refreshState.needsRefresh) {
+        break;
+      }
+    }
+    refreshState.inFlight = null;
+    return snapshot;
+  }
+}
+function areDiffSnapshotsEquivalent(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right)
+    return false;
+  if (left.status !== right.status || left.branchName !== right.branchName || left.hasUpstream !== right.hasUpstream || (left.error ?? null) !== (right.error ?? null) || left.files.length !== right.files.length) {
+    return false;
+  }
+  return left.files.every((file, index) => {
+    const other = right.files[index];
+    return other && file.path === other.path && (file.previousPath ?? null) === (other.previousPath ?? null) && file.changeType === other.changeType && file.patch === other.patch && file.patchAvailable === other.patchAvailable && (file.patchSummary ?? null) === (other.patchSummary ?? null);
+  });
+}
+
 // src/server/keybindings.ts
 import { watch } from "fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import path15 from "path";
+import path16 from "path";
 var KEYBINDING_ACTIONS = Object.keys(DEFAULT_KEYBINDINGS);
 var SELF_WRITE_WATCH_DEBOUNCE_MS = 250;
 
@@ -13626,7 +14440,7 @@ class KeybindingsManager {
     this.snapshot = createDefaultSnapshot(this.filePath);
   }
   async initialize() {
-    await mkdir4(path15.dirname(this.filePath), { recursive: true });
+    await mkdir4(path16.dirname(this.filePath), { recursive: true });
     const file = Bun.file(this.filePath);
     if (!await file.exists()) {
       await writeFile4(this.filePath, `${JSON.stringify(DEFAULT_KEYBINDINGS, null, 2)}
@@ -13655,7 +14469,7 @@ class KeybindingsManager {
   }
   async write(bindings) {
     const nextSnapshot = normalizeKeybindings(bindings, this.filePath);
-    await mkdir4(path15.dirname(this.filePath), { recursive: true });
+    await mkdir4(path16.dirname(this.filePath), { recursive: true });
     this.ignoreWatchEventsUntil = Date.now() + SELF_WRITE_WATCH_DEBOUNCE_MS;
     await writeFile4(this.filePath, `${JSON.stringify(nextSnapshot.bindings, null, 2)}
 `, "utf8");
@@ -13671,8 +14485,8 @@ class KeybindingsManager {
   startWatching() {
     this.watcher?.close();
     try {
-      this.watcher = watch(path15.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
-        if (filename && filename !== path15.basename(this.filePath)) {
+      this.watcher = watch(path16.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path16.basename(this.filePath)) {
           return;
         }
         if (Date.now() <= this.ignoreWatchEventsUntil) {
@@ -13758,7 +14572,7 @@ function formatDisplayPath(filePath) {
   const homePath = homedir10();
   if (filePath === homePath)
     return "~";
-  if (filePath.startsWith(`${homePath}${path15.sep}`)) {
+  if (filePath.startsWith(`${homePath}${path16.sep}`)) {
     return `~${filePath.slice(homePath.length)}`;
   }
   return filePath;
@@ -13768,7 +14582,7 @@ function formatDisplayPath(filePath) {
 import { watch as watch2 } from "fs";
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import path16 from "path";
+import path17 from "path";
 var PROVIDER_IDS = Object.keys(DEFAULT_PROVIDER_SETTINGS);
 
 class ProviderSettingsManager {
@@ -13781,7 +14595,7 @@ class ProviderSettingsManager {
     this.snapshot = createDefaultSnapshot2(this.filePath);
   }
   async initialize() {
-    await mkdir5(path16.dirname(this.filePath), { recursive: true });
+    await mkdir5(path17.dirname(this.filePath), { recursive: true });
     const file = Bun.file(this.filePath);
     if (!await file.exists()) {
       await writeFile5(this.filePath, `${JSON.stringify(DEFAULT_PROVIDER_SETTINGS, null, 2)}
@@ -13810,7 +14624,7 @@ class ProviderSettingsManager {
   }
   async write(settings) {
     const nextSnapshot = normalizeProviderSettings(settings, this.filePath);
-    await mkdir5(path16.dirname(this.filePath), { recursive: true });
+    await mkdir5(path17.dirname(this.filePath), { recursive: true });
     await writeFile5(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}
 `, "utf8");
     this.setSnapshot(nextSnapshot);
@@ -13825,8 +14639,8 @@ class ProviderSettingsManager {
   startWatching() {
     this.watcher?.close();
     try {
-      this.watcher = watch2(path16.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
-        if (filename && filename !== path16.basename(this.filePath)) {
+      this.watcher = watch2(path17.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path17.basename(this.filePath)) {
           return;
         }
         this.reload().catch((error) => {
@@ -13890,7 +14704,7 @@ function formatDisplayPath2(filePath) {
   const homePath = homedir11();
   if (filePath === homePath)
     return "~";
-  if (filePath.startsWith(`${homePath}${path16.sep}`)) {
+  if (filePath.startsWith(`${homePath}${path17.sep}`)) {
     return `~${filePath.slice(homePath.length)}`;
   }
   return filePath;
@@ -13900,7 +14714,7 @@ function formatDisplayPath2(filePath) {
 import { watch as watch3 } from "fs";
 import { mkdir as mkdir7, readdir as readdir3, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import path19 from "path";
+import path20 from "path";
 // ../../packages/themes/src/builtins/catppuccin.json
 var catppuccin_default = {
   id: "catppuccin",
@@ -14581,21 +15395,21 @@ function serializeCssVariables(variables) {
 // src/server/managed-backgrounds.ts
 import { createHash } from "crypto";
 import { lookup } from "dns/promises";
-import { mkdir as mkdir6, readFile as readFile6, rm as rm2, stat as stat4, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile6, rm as rm2, stat as stat5, writeFile as writeFile6 } from "fs/promises";
 import { isIP as isIP2 } from "net";
 import { homedir as homedir12 } from "os";
-import path18 from "path";
+import path19 from "path";
 import sharp from "sharp";
 
 // src/server/backgrounds.ts
 import fs3 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import os from "os";
 var BACKGROUND_DIRS = [
-  path17.join(os.homedir(), ".local/share/backgrounds"),
+  path18.join(os.homedir(), ".local/share/backgrounds"),
   "/usr/share/backgrounds",
   "/Library/Desktop Pictures",
-  path17.join(os.homedir(), "Pictures"),
+  path18.join(os.homedir(), "Pictures"),
   process.platform === "win32" ? "C:\\Windows\\Web\\Wallpaper" : ""
 ].filter(Boolean);
 async function getSystemBackgrounds() {
@@ -14608,11 +15422,11 @@ async function getSystemBackgrounds() {
       const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          await scanDir(path17.join(dir, entry.name), depth + 1);
+          await scanDir(path18.join(dir, entry.name), depth + 1);
         } else if (entry.isFile()) {
-          const ext = path17.extname(entry.name).toLowerCase();
+          const ext = path18.extname(entry.name).toLowerCase();
           if (ext === ".jpg" || ext === ".jpeg" || ext === ".png" || ext === ".webp") {
-            const fullPath = path17.join(dir, entry.name);
+            const fullPath = path18.join(dir, entry.name);
             if (seen.has(fullPath))
               continue;
             seen.add(fullPath);
@@ -14658,8 +15472,8 @@ var MAX_REMOTE_BACKGROUND_BYTES = 20 * 1024 * 1024;
 function getManagedBackgroundPathsForSource(source, backgroundsDirectory = getManagedBackgroundsDirPath(homedir12())) {
   const sourceKey = createHash("sha256").update(source).digest("hex");
   return {
-    assetFilePath: path18.join(backgroundsDirectory, `${sourceKey}.webp`),
-    metadataFilePath: path18.join(backgroundsDirectory, `${sourceKey}.json`)
+    assetFilePath: path19.join(backgroundsDirectory, `${sourceKey}.webp`),
+    metadataFilePath: path19.join(backgroundsDirectory, `${sourceKey}.json`)
   };
 }
 async function deleteManagedBackgroundForSource(source, backgroundsDirectory = getManagedBackgroundsDirPath(homedir12())) {
@@ -14707,7 +15521,7 @@ async function cacheManagedBackgroundForSource(source, backgroundsDirectory = ge
   const { assetFilePath, metadataFilePath } = getManagedBackgroundPathsForSource(source, backgroundsDirectory);
   const resolvedSource = await resolveSource(source, options);
   const previousMetadata = await readManagedBackgroundMetadata(metadataFilePath);
-  const existingAsset = await stat4(assetFilePath).catch(() => null);
+  const existingAsset = await stat5(assetFilePath).catch(() => null);
   if (existingAsset?.isFile() && previousMetadata?.fingerprint === resolvedSource.fingerprint) {
     return {
       assetFilePath,
@@ -14752,7 +15566,7 @@ async function readManagedBackgroundCache(source, backgroundsDirectory) {
   const { assetFilePath, metadataFilePath } = getManagedBackgroundPathsForSource(source, backgroundsDirectory);
   const [metadata, existingAsset] = await Promise.all([
     readManagedBackgroundMetadata(metadataFilePath),
-    stat4(assetFilePath).catch(() => null)
+    stat5(assetFilePath).catch(() => null)
   ]);
   if (!existingAsset?.isFile() || !metadata?.fingerprint) {
     return null;
@@ -14769,7 +15583,7 @@ async function resolveSource(source, options) {
     if (!filePath) {
       throw new Error("Background image not found.");
     }
-    const info = await stat4(filePath);
+    const info = await stat5(filePath);
     return {
       input: filePath,
       fingerprint: JSON.stringify({
@@ -15033,7 +15847,7 @@ class ThemeSettingsManager {
     });
   }
   async initialize() {
-    await mkdir7(path19.dirname(this.filePath), { recursive: true });
+    await mkdir7(path20.dirname(this.filePath), { recursive: true });
     await mkdir7(this.themesDirectory, { recursive: true });
     await mkdir7(this.managedBackgroundsDirectory, { recursive: true });
     const file = Bun.file(this.filePath);
@@ -15083,7 +15897,7 @@ class ThemeSettingsManager {
         console.warn(`${LOG_PREFIX} Failed to warm managed background cache:`, error);
       }
     }
-    await mkdir7(path19.dirname(this.filePath), { recursive: true });
+    await mkdir7(path20.dirname(this.filePath), { recursive: true });
     await writeFile7(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}
 `, "utf8");
     if (previousBackgroundImage !== nextSnapshot.settings.backgroundImage) {
@@ -15115,8 +15929,8 @@ class ThemeSettingsManager {
     this.settingsWatcher?.close();
     this.themesWatcher?.close();
     try {
-      this.settingsWatcher = watch3(path19.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
-        if (filename && filename !== path19.basename(this.filePath))
+      this.settingsWatcher = watch3(path20.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path20.basename(this.filePath))
           return;
         this.reload().catch((error) => {
           console.warn(`${LOG_PREFIX} Failed to reload theme settings:`, error);
@@ -15217,7 +16031,7 @@ async function loadThemeRegistry(themesDirectory) {
   }
   const customThemeFiles = entries.filter((entry) => entry.endsWith(".json") && !entry.endsWith(".example.json")).sort((left, right) => left.localeCompare(right));
   for (const fileName of customThemeFiles) {
-    const absolutePath = path19.join(themesDirectory, fileName);
+    const absolutePath = path20.join(themesDirectory, fileName);
     try {
       const text = await readFile7(absolutePath, "utf8");
       const parsed = parseThemeDefinition(JSON.parse(text));
@@ -15281,7 +16095,168 @@ function formatDisplayPath3(filePath) {
   const homePath = homedir13();
   if (filePath === homePath)
     return "~";
-  if (filePath.startsWith(`${homePath}${path19.sep}`)) {
+  if (filePath.startsWith(`${homePath}${path20.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`;
+  }
+  return filePath;
+}
+
+// src/server/general-settings.ts
+import { watch as watch4 } from "fs";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { homedir as homedir14 } from "os";
+import path21 from "path";
+var SELF_WRITE_WATCH_DEBOUNCE_MS2 = 250;
+
+class GeneralSettingsManager {
+  filePath;
+  watcher = null;
+  snapshot;
+  ignoreWatchEventsUntil = 0;
+  updateQueue = Promise.resolve();
+  listeners = new Set;
+  constructor(filePath = getGeneralSettingsFilePath(homedir14())) {
+    this.filePath = filePath;
+    this.snapshot = createDefaultSnapshot4(this.filePath);
+  }
+  async initialize() {
+    await mkdir8(path21.dirname(this.filePath), { recursive: true });
+    const file = Bun.file(this.filePath);
+    if (!await file.exists()) {
+      await writeFile8(this.filePath, `${JSON.stringify(DEFAULT_GENERAL_SETTINGS, null, 2)}
+`, "utf8");
+    }
+    await this.reload();
+    this.startWatching();
+  }
+  dispose() {
+    this.watcher?.close();
+    this.watcher = null;
+    this.listeners.clear();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async reload() {
+    return this.enqueueUpdate(async () => {
+      const nextSnapshot = await readGeneralSettingsSnapshot(this.filePath);
+      this.setSnapshot(nextSnapshot);
+      return nextSnapshot;
+    });
+  }
+  async write(settings) {
+    return this.enqueueUpdate(async () => {
+      const nextSnapshot = normalizeGeneralSettings(settings, this.filePath);
+      await mkdir8(path21.dirname(this.filePath), { recursive: true });
+      this.ignoreWatchEventsUntil = Date.now() + SELF_WRITE_WATCH_DEBOUNCE_MS2;
+      await writeFile8(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}
+`, "utf8");
+      this.setSnapshot(nextSnapshot);
+      return nextSnapshot;
+    });
+  }
+  setSnapshot(snapshot) {
+    this.snapshot = snapshot;
+    for (const listener of this.listeners) {
+      listener(snapshot);
+    }
+  }
+  enqueueUpdate(update) {
+    const result = this.updateQueue.then(update);
+    this.updateQueue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  startWatching() {
+    this.watcher?.close();
+    try {
+      this.watcher = watch4(path21.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path21.basename(this.filePath)) {
+          return;
+        }
+        if (Date.now() <= this.ignoreWatchEventsUntil) {
+          return;
+        }
+        this.reload().catch((error) => {
+          console.warn(`${LOG_PREFIX} Failed to reload general settings:`, error);
+        });
+      });
+      this.watcher.on("error", (error) => {
+        console.warn(`${LOG_PREFIX} Failed to watch general settings file:`, error);
+        this.watcher?.close();
+        this.watcher = null;
+      });
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to watch general settings file:`, error);
+      this.watcher = null;
+    }
+  }
+}
+async function readGeneralSettingsSnapshot(filePath) {
+  try {
+    const text = await readFile8(filePath, "utf8");
+    if (!text.trim()) {
+      return createDefaultSnapshot4(filePath, "General settings file was empty. Using defaults.");
+    }
+    const parsed = JSON.parse(text);
+    return normalizeGeneralSettings(parsed, filePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return createDefaultSnapshot4(filePath);
+    }
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot4(filePath, "General settings file is invalid JSON. Using defaults.");
+    }
+    throw error;
+  }
+}
+function normalizeGeneralSettings(value, filePath = getGeneralSettingsFilePath(homedir14())) {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  if (!source) {
+    return createDefaultSnapshot4(filePath, "General settings file must contain a JSON object. Using defaults.");
+  }
+  const warnings = [];
+  let sendChunkSizeBytes = DEFAULT_GENERAL_SETTINGS.sendChunkSizeBytes;
+  const rawSendChunkSize = source.sendChunkSizeBytes;
+  if (rawSendChunkSize !== undefined) {
+    if (typeof rawSendChunkSize === "number" && Number.isFinite(rawSendChunkSize)) {
+      const normalizedValue = Math.round(rawSendChunkSize);
+      if (normalizedValue >= MIN_SEND_CHUNK_SIZE_BYTES && normalizedValue <= MAX_SEND_CHUNK_SIZE_BYTES) {
+        sendChunkSizeBytes = normalizedValue;
+      } else {
+        warnings.push(`sendChunkSizeBytes must be between ${MIN_SEND_CHUNK_SIZE_BYTES} and ${MAX_SEND_CHUNK_SIZE_BYTES}`);
+      }
+    } else {
+      warnings.push("sendChunkSizeBytes must be a number");
+    }
+  }
+  return {
+    settings: { sendChunkSizeBytes },
+    warning: warnings.length > 0 ? `Some general settings were reset to defaults: ${warnings.join("; ")}` : null,
+    filePathDisplay: formatDisplayPath4(filePath)
+  };
+}
+function createDefaultSnapshot4(filePath, warning = null) {
+  return {
+    settings: { ...DEFAULT_GENERAL_SETTINGS },
+    warning,
+    filePathDisplay: formatDisplayPath4(filePath)
+  };
+}
+function formatDisplayPath4(filePath) {
+  const homePath = homedir14();
+  if (filePath === homePath)
+    return "~";
+  if (filePath.startsWith(`${homePath}${path21.sep}`)) {
     return `~${filePath.slice(homePath.length)}`;
   }
   return filePath;
@@ -15514,7 +16489,7 @@ function getMachineDisplayName() {
 }
 
 // src/server/terminal-manager.ts
-import path20 from "path";
+import path22 from "path";
 import process8 from "process";
 import defaultShell, { detectDefaultShell } from "default-shell";
 import { Terminal } from "@xterm/headless";
@@ -15553,7 +16528,7 @@ function resolveShellArgs(shellPath) {
   if (process8.platform === "win32") {
     return [];
   }
-  const shellName = path20.basename(shellPath);
+  const shellName = path22.basename(shellPath);
   if (["bash", "zsh", "fish", "sh", "ksh"].includes(shellName)) {
     return ["-l"];
   }
@@ -15647,7 +16622,7 @@ class TerminalManager {
     const cols = normalizeTerminalDimension(args.cols, DEFAULT_COLS);
     const rows = normalizeTerminalDimension(args.rows, DEFAULT_ROWS);
     const scrollback = clampScrollback(args.scrollback);
-    const title = path20.basename(shell) || "shell";
+    const title = path22.basename(shell) || "shell";
     const headless = new Terminal({
       cols,
       rows,
@@ -16011,13 +16986,13 @@ class UpdateManager {
 
 // src/server/recovery.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync8, statSync as statSync7 } from "fs";
-import { homedir as homedir14 } from "os";
-import path22 from "path";
+import { homedir as homedir15 } from "os";
+import path24 from "path";
 
 // src/server/cursor-chat-store.ts
 import { Database as Database2 } from "bun:sqlite";
 import { existsSync as existsSync9, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
-import path21 from "path";
+import path23 from "path";
 function decodeMetaValue(value) {
   try {
     const decoded = Buffer.from(value, "hex").toString("utf8");
@@ -16072,7 +17047,7 @@ function extractWorkspacePath(value) {
   if (!match) {
     return null;
   }
-  return path21.normalize(match[1].trim());
+  return path23.normalize(match[1].trim());
 }
 function unwrapCursorTaggedText(value) {
   const trimmed = value.trim();
@@ -16148,7 +17123,7 @@ function readBlobRows(database) {
   return database.query("select id, data from blobs").all();
 }
 function collectCursorChatStorePaths(homeDir) {
-  const chatsRoot = path21.join(homeDir, ".cursor", "chats");
+  const chatsRoot = path23.join(homeDir, ".cursor", "chats");
   if (!existsSync9(chatsRoot)) {
     return [];
   }
@@ -16156,11 +17131,11 @@ function collectCursorChatStorePaths(homeDir) {
   for (const parent of readdirSync7(chatsRoot, { withFileTypes: true })) {
     if (!parent.isDirectory())
       continue;
-    const parentPath = path21.join(chatsRoot, parent.name);
+    const parentPath = path23.join(chatsRoot, parent.name);
     for (const child of readdirSync7(parentPath, { withFileTypes: true })) {
       if (!child.isDirectory())
         continue;
-      const storePath = path21.join(parentPath, child.name, "store.db");
+      const storePath = path23.join(parentPath, child.name, "store.db");
       if (existsSync9(storePath)) {
         storePaths.push(storePath);
       }
@@ -16169,14 +17144,14 @@ function collectCursorChatStorePaths(homeDir) {
   return storePaths;
 }
 function findCursorChatStorePath(homeDir, sessionToken) {
-  const chatsRoot = path21.join(homeDir, ".cursor", "chats");
+  const chatsRoot = path23.join(homeDir, ".cursor", "chats");
   if (!existsSync9(chatsRoot)) {
     return null;
   }
   for (const parent of readdirSync7(chatsRoot, { withFileTypes: true })) {
     if (!parent.isDirectory())
       continue;
-    const candidate = path21.join(chatsRoot, parent.name, sessionToken, "store.db");
+    const candidate = path23.join(chatsRoot, parent.name, sessionToken, "store.db");
     if (existsSync9(candidate)) {
       return candidate;
     }
@@ -16350,7 +17325,7 @@ function collectFiles(directory, extension) {
   }
   const files = [];
   for (const entry of readdirSync8(directory, { withFileTypes: true })) {
-    const fullPath = path22.join(directory, entry.name);
+    const fullPath = path24.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectFiles(fullPath, extension));
       continue;
@@ -16488,7 +17463,7 @@ function markSkippedSession(skippedSessionKeys, provider, sessionToken) {
   }
 }
 function readClaudeProjectChats(homeDir, trackedWorktreePaths, skippedSessionKeys, existingSessionKeys) {
-  const projectsDir = path22.join(homeDir, ".claude", "projects");
+  const projectsDir = path24.join(homeDir, ".claude", "projects");
   const chats = [];
   for (const sessionFile of collectFiles(projectsDir, ".jsonl")) {
     const head = peekFileHead(sessionFile, 2048);
@@ -16505,8 +17480,8 @@ function readClaudeProjectChats(homeDir, trackedWorktreePaths, skippedSessionKey
       if (!peekedSessionToken && typeof record.sessionId === "string") {
         peekedSessionToken = record.sessionId;
       }
-      if (!peekedSessionLocalPath && typeof record.cwd === "string" && path22.isAbsolute(record.cwd)) {
-        peekedSessionLocalPath = path22.normalize(record.cwd);
+      if (!peekedSessionLocalPath && typeof record.cwd === "string" && path24.isAbsolute(record.cwd)) {
+        peekedSessionLocalPath = path24.normalize(record.cwd);
       }
       peekedEntries.push(...claudeEntriesFromRecord(record));
     }
@@ -16536,8 +17511,8 @@ function readClaudeProjectChats(homeDir, trackedWorktreePaths, skippedSessionKey
       if (!sessionToken && typeof record.sessionId === "string") {
         sessionToken = record.sessionId;
       }
-      if (!sessionLocalPath && typeof record.cwd === "string" && path22.isAbsolute(record.cwd)) {
-        sessionLocalPath = path22.normalize(record.cwd);
+      if (!sessionLocalPath && typeof record.cwd === "string" && path24.isAbsolute(record.cwd)) {
+        sessionLocalPath = path24.normalize(record.cwd);
       }
       const timestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN;
       if (!Number.isNaN(timestamp)) {
@@ -16721,12 +17696,12 @@ function cursorEntriesFromRecord(record, index, sessionToken, fallbackBaseTimest
   ];
 }
 function findCursorTranscriptPath(args) {
-  const transcriptRoot = path22.join(args.homeDir, ".cursor", "projects", encodeCursorProjectPath(path22.normalize(args.localPath)), "agent-transcripts");
-  const directPath = path22.join(transcriptRoot, args.sessionToken, `${args.sessionToken}.jsonl`);
+  const transcriptRoot = path24.join(args.homeDir, ".cursor", "projects", encodeCursorProjectPath(path24.normalize(args.localPath)), "agent-transcripts");
+  const directPath = path24.join(transcriptRoot, args.sessionToken, `${args.sessionToken}.jsonl`);
   if (existsSync10(directPath)) {
     return directPath;
   }
-  return collectFiles(transcriptRoot, ".jsonl").find((sourcePath) => path22.basename(sourcePath, ".jsonl") === args.sessionToken) ?? null;
+  return collectFiles(transcriptRoot, ".jsonl").find((sourcePath) => path24.basename(sourcePath, ".jsonl") === args.sessionToken) ?? null;
 }
 function isCodexSubagentSession(payload) {
   if (typeof payload.forked_from_id === "string" && payload.forked_from_id.trim()) {
@@ -16740,7 +17715,7 @@ function isCodexSubagentSession(payload) {
   return Boolean(sourceRecord.subagent);
 }
 function readCodexProjectChats(homeDir, trackedWorktreePaths, skippedSessionKeys, existingSessionKeys) {
-  const sessionsDir = path22.join(homeDir, ".codex", "sessions");
+  const sessionsDir = path24.join(homeDir, ".codex", "sessions");
   const chats = [];
   for (const sessionFile of collectFiles(sessionsDir, ".jsonl")) {
     const head = peekFileHead(sessionFile, 2048);
@@ -16754,7 +17729,7 @@ function readCodexProjectChats(homeDir, trackedWorktreePaths, skippedSessionKeys
         if (payload && typeof payload === "object" && !Array.isArray(payload)) {
           const payloadRecord = payload;
           const peekedSessionToken = typeof payloadRecord.id === "string" ? payloadRecord.id : null;
-          const peekedSessionLocalPath = typeof payloadRecord.cwd === "string" && path22.isAbsolute(payloadRecord.cwd) ? path22.normalize(payloadRecord.cwd) : null;
+          const peekedSessionLocalPath = typeof payloadRecord.cwd === "string" && path24.isAbsolute(payloadRecord.cwd) ? path24.normalize(payloadRecord.cwd) : null;
           if (isCodexSubagentSession(payloadRecord)) {
             markSkippedSession(skippedSessionKeys, "codex", peekedSessionToken);
             continue;
@@ -16803,8 +17778,8 @@ function readCodexProjectChats(homeDir, trackedWorktreePaths, skippedSessionKeys
           if (!sessionToken && typeof payloadRecord.id === "string") {
             sessionToken = payloadRecord.id;
           }
-          if (!sessionLocalPath && typeof payloadRecord.cwd === "string" && path22.isAbsolute(payloadRecord.cwd)) {
-            sessionLocalPath = path22.normalize(payloadRecord.cwd);
+          if (!sessionLocalPath && typeof payloadRecord.cwd === "string" && path24.isAbsolute(payloadRecord.cwd)) {
+            sessionLocalPath = path24.normalize(payloadRecord.cwd);
           }
         }
       }
@@ -16840,13 +17815,13 @@ function readCodexProjectChats(homeDir, trackedWorktreePaths, skippedSessionKeys
 function collectProjectChats(homeDir, trackedWorktreePaths, existingSessionKeys) {
   const skippedSessionKeys = new Set;
   const cursorTranscriptChats = [...trackedWorktreePaths].flatMap((localPath) => {
-    const transcriptsDir = path22.join(homeDir, ".cursor", "projects", encodeCursorProjectPath(localPath), "agent-transcripts");
+    const transcriptsDir = path24.join(homeDir, ".cursor", "projects", encodeCursorProjectPath(localPath), "agent-transcripts");
     const chats = [];
     for (const sessionFile of collectFiles(transcriptsDir, ".jsonl")) {
       const lines = readFileSync7(sessionFile, "utf8").split(`
 `);
       const entries = [];
-      const sessionToken = path22.basename(sessionFile, ".jsonl");
+      const sessionToken = path24.basename(sessionFile, ".jsonl");
       const sourceMtimeMs = statSync7(sessionFile).mtimeMs;
       const modifiedAt = sourceMtimeMs;
       lines.forEach((line, index) => {
@@ -16915,7 +17890,7 @@ function loadClaudeSessionEntries(args) {
   return [];
 }
 function loadClaudeSessionEntriesFromFilesystem(args) {
-  const projectsDir = path22.join(args.homeDir, ".claude", "projects", encodeClaudeProjectPath(path22.normalize(args.localPath)));
+  const projectsDir = path24.join(args.homeDir, ".claude", "projects", encodeClaudeProjectPath(path24.normalize(args.localPath)));
   for (const sessionFile of collectFiles(projectsDir, ".jsonl")) {
     const lines = readFileSync7(sessionFile, "utf8").split(`
 `);
@@ -16957,8 +17932,8 @@ function loadCodexSessionEntries(args) {
         if (payloadRecord.id === args.session.sessionToken) {
           matched = true;
         }
-        if (typeof payloadRecord.cwd === "string" && path22.isAbsolute(payloadRecord.cwd)) {
-          sessionLocalPath = path22.normalize(payloadRecord.cwd);
+        if (typeof payloadRecord.cwd === "string" && path24.isAbsolute(payloadRecord.cwd)) {
+          sessionLocalPath = path24.normalize(payloadRecord.cwd);
         }
       }
     }
@@ -16966,13 +17941,13 @@ function loadCodexSessionEntries(args) {
       entries.push(...codexEntriesFromRecord(record, index));
     }
   });
-  if (matched && sessionLocalPath === path22.normalize(args.session.localPath)) {
+  if (matched && sessionLocalPath === path24.normalize(args.session.localPath)) {
     return entries;
   }
   return [];
 }
 function loadCodexSessionEntriesFromFilesystem(args) {
-  const sessionsDir = path22.join(args.homeDir, ".codex", "sessions");
+  const sessionsDir = path24.join(args.homeDir, ".codex", "sessions");
   for (const sessionFile of collectFiles(sessionsDir, ".jsonl")) {
     const lines = readFileSync7(sessionFile, "utf8").split(`
 `);
@@ -16992,8 +17967,8 @@ function loadCodexSessionEntriesFromFilesystem(args) {
           if (payloadRecord.id === args.sessionToken) {
             matched = true;
           }
-          if (typeof payloadRecord.cwd === "string" && path22.isAbsolute(payloadRecord.cwd)) {
-            sessionLocalPath = path22.normalize(payloadRecord.cwd);
+          if (typeof payloadRecord.cwd === "string" && path24.isAbsolute(payloadRecord.cwd)) {
+            sessionLocalPath = path24.normalize(payloadRecord.cwd);
           }
         }
       }
@@ -17001,7 +17976,7 @@ function loadCodexSessionEntriesFromFilesystem(args) {
         entries.push(...codexEntriesFromRecord(record, index));
       }
     });
-    if (matched && sessionLocalPath === path22.normalize(args.localPath)) {
+    if (matched && sessionLocalPath === path24.normalize(args.localPath)) {
       return entries;
     }
   }
@@ -17049,14 +18024,14 @@ function loadCursorSessionEntriesFromFilesystem(args) {
     return [];
   }
   const metadata = readCursorChatStoreMetadata(chatStorePath);
-  if (metadata?.localPath !== path22.normalize(args.localPath)) {
+  if (metadata?.localPath !== path24.normalize(args.localPath)) {
     return [];
   }
   return loadCursorChatStoreEntries(chatStorePath);
 }
 function loadProviderSessionEntries(args) {
   const startedAt = performance.now();
-  const root = args.homeDir ?? homedir14();
+  const root = args.homeDir ?? homedir15();
   const indexedSession = args.provider === "claude" || args.provider === "codex" || args.provider === "cursor" ? args.providerSessionIndex?.getSession(args.provider, args.sessionToken) : null;
   const entries = args.provider === "claude" && indexedSession ? loadClaudeSessionEntries({
     session: indexedSession
@@ -17094,8 +18069,8 @@ function hydrateProviderSessionWindow(args) {
   });
 }
 async function importProjectHistory(args) {
-  const normalizedPaths = new Set(args.worktreePaths.map((worktreePath) => path22.normalize(worktreePath)));
-  normalizedPaths.add(path22.normalize(args.localPath));
+  const normalizedPaths = new Set(args.worktreePaths.map((worktreePath) => path24.normalize(worktreePath)));
+  normalizedPaths.add(path24.normalize(args.localPath));
   if (args.store.isProjectHidden(args.repoKey)) {
     return {
       importedChatIds: [],
@@ -17117,7 +18092,7 @@ async function importProjectHistory(args) {
       entries: []
     })),
     skippedSessionKeys: new Set
-  } : collectProjectChats(args.homeDir ?? homedir14(), normalizedPaths, existingSessionKeys);
+  } : collectProjectChats(args.homeDir ?? homedir15(), normalizedPaths, existingSessionKeys);
   for (const chat of existingChats.filter((candidate) => {
     if (!candidate.provider || !candidate.sessionToken)
       return false;
@@ -17212,8 +18187,8 @@ function isClientEnvelope(value) {
 }
 
 // src/server/external-open.ts
-import { stat as stat5 } from "fs/promises";
-import path23 from "path";
+import { stat as stat6 } from "fs/promises";
+import path25 from "path";
 import process9 from "process";
 var DEFAULT_EDITOR_SETTINGS = {
   preset: "cursor",
@@ -17222,7 +18197,7 @@ var DEFAULT_EDITOR_SETTINGS = {
 async function openExternal(command) {
   const resolvedPath = resolveLocalPath(command.localPath);
   const platform = process9.platform;
-  const info = command.action === "open_editor" || command.action === "open_finder" ? await stat5(resolvedPath).catch(() => null) : null;
+  const info = command.action === "open_editor" || command.action === "open_finder" ? await stat6(resolvedPath).catch(() => null) : null;
   if (command.action === "open_editor") {
     if (!info) {
       throw new Error(`Path not found: ${resolvedPath}`);
@@ -17271,7 +18246,7 @@ async function openExternal(command) {
     }
   }
   if (command.action === "open_finder") {
-    spawnDetached("xdg-open", [info?.isDirectory() ? resolvedPath : path23.dirname(resolvedPath)]);
+    spawnDetached("xdg-open", [info?.isDirectory() ? resolvedPath : path25.dirname(resolvedPath)]);
     return;
   }
   if (command.action === "open_terminal") {
@@ -17468,9 +18443,19 @@ function createRealtimeDeltaPublisher({
   function publishSidebarEvent(event) {
     publishToSubscriptions((topic) => topic.type === "sidebar", event);
   }
+  function refreshChatSnapshot(chatId) {
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type === "chat" && topic.chatId === chatId) {
+          sendSnapshot(ws, id, topic);
+        }
+      }
+    }
+  }
   return {
     sendInitialSnapshot: sendSnapshot,
     sendRefreshSnapshot: sendSnapshot,
+    refreshChatSnapshot,
     publishChatMessageAppended(chatId, entry) {
       publishChatEvent(chatId, { type: "chat.message-appended", chatId, entry });
     },
@@ -17492,6 +18477,13 @@ function createRealtimeDeltaPublisher({
     publishChatPendingToolSet(chatId, pendingTool) {
       publishChatEvent(chatId, { type: "chat.pending-tool-set", chatId, pendingTool });
     },
+    publishChatOutboundQueueSet(chatId, queuedMessages) {
+      publishChatEvent(chatId, {
+        type: "chat.outbound-queue-set",
+        chatId,
+        queuedMessages
+      });
+    },
     publishChatSessionTokenSet(chatId, sessionToken, hydrationState) {
       publishChatEvent(chatId, {
         type: "chat.session-token-set",
@@ -17666,9 +18658,7 @@ function resolveChatUsage({
 // src/server/ws-router.ts
 var PROVIDER_USAGE_POLL_INTERVAL_MS = 30 * 60 * 1000;
 var PROVIDER_USAGE_POLL_MAX_INTERVAL_MS = 31 * 60 * 1000;
-var INITIAL_CHAT_WINDOW_TARGET_BYTES = 384 * 1024;
 var INITIAL_CHAT_WINDOW_MIN_ENTRIES = 240;
-var LOAD_MORE_CHAT_WINDOW_TARGET_BYTES = 384 * 1024;
 var LOAD_MORE_CHAT_WINDOW_MIN_ENTRIES = 200;
 function send(ws, message) {
   const payload = JSON.stringify(message);
@@ -17680,7 +18670,7 @@ function send(ws, message) {
 function hasSidebarSnapshotState(store) {
   return Boolean(store && typeof store === "object" && "state" in store && store.state && typeof store.state === "object");
 }
-function getChatTranscriptWindow(store, providerSessionIndex, chatId, warmHydratedTranscriptCache, pruneEmptyProviderShell) {
+function getChatTranscriptWindow(store, providerSessionIndex, chatId, targetBytes, warmHydratedTranscriptCache, pruneEmptyProviderShell) {
   const startedAt = performance.now();
   const chat = store.getChat(chatId);
   const hasLocalPayload = typeof store.hasLocalChatPayload === "function" ? store.hasLocalChatPayload(chatId) : true;
@@ -17690,7 +18680,7 @@ function getChatTranscriptWindow(store, providerSessionIndex, chatId, warmHydrat
         provider: chat.provider,
         sessionToken: chat.sessionToken,
         localPath: store.getProject(chat.projectId)?.localPath ?? "",
-        targetBytes: INITIAL_CHAT_WINDOW_TARGET_BYTES,
+        targetBytes,
         minEntries: INITIAL_CHAT_WINDOW_MIN_ENTRIES,
         providerSessionIndex
       });
@@ -17713,7 +18703,7 @@ function getChatTranscriptWindow(store, providerSessionIndex, chatId, warmHydrat
   }
   if (typeof store.getMessageWindow === "function") {
     const transcript = store.getMessageWindow(chatId, {
-      targetBytes: INITIAL_CHAT_WINDOW_TARGET_BYTES,
+      targetBytes,
       minEntries: INITIAL_CHAT_WINDOW_MIN_ENTRIES
     });
     performanceDiagnostics.recordTiming("chat_open_snapshot_latency_ms", Math.round(performance.now() - startedAt), { chatId, source: "local" });
@@ -17741,6 +18731,8 @@ function topicKey(topic) {
       return `feature-overview:${topic.featureId}`;
     case "chat":
       return `chat:${topic.chatId}`;
+    case "project-diffs":
+      return `project-diffs:${topic.projectId}`;
     default:
       return topic.type;
   }
@@ -17751,7 +18743,9 @@ function createWsRouter({
   providerSessionIndex,
   terminals,
   git,
+  diffs: providedDiffs,
   keybindings,
+  generalSettings,
   providerSettings,
   providerCatalogManager,
   remoteAuth,
@@ -17774,7 +18768,9 @@ function createWsRouter({
   openUrlCommand = openUrl2,
   resolveChatUsageForSnapshot = resolveChatUsage
 }) {
+  const diffs = providedDiffs ?? new DiffStore(git);
   const sockets = new Set;
+  const getSendChunkSizeBytes = () => generalSettings?.getSnapshot().settings.sendChunkSizeBytes ?? DEFAULT_GENERAL_SETTINGS.sendChunkSizeBytes;
   const realtime = createRealtimeDeltaPublisher({
     sockets,
     send,
@@ -17851,6 +18847,16 @@ function createWsRouter({
         data: keybindings.getSnapshot()
       };
     }
+    if (topic.type === "general-settings") {
+      return {
+        type: "general-settings",
+        data: generalSettings?.getSnapshot() ?? {
+          settings: DEFAULT_GENERAL_SETTINGS,
+          warning: null,
+          filePathDisplay: ""
+        }
+      };
+    }
     if (topic.type === "theme-settings") {
       return {
         type: "theme-settings",
@@ -17911,17 +18917,23 @@ function createWsRouter({
         data: store.getFeatureOverviewSnapshot(topic.featureId)
       };
     }
+    if (topic.type === "project-diffs") {
+      return {
+        type: "project-diffs",
+        data: diffs.getSnapshot(topic.projectId)
+      };
+    }
     return {
       type: "chat",
       data: (() => {
         const chat = store.getChat(topic.chatId);
-        const transcript = getChatTranscriptWindow(store, providerSessionIndex, topic.chatId, warmHydratedTranscriptCache, (chatId) => pruneOrphanProviderShells([chatId]));
+        const transcript = getChatTranscriptWindow(store, providerSessionIndex, topic.chatId, getSendChunkSizeBytes(), warmHydratedTranscriptCache, (chatId) => pruneOrphanProviderShells([chatId]));
         const messages = transcript.entries;
         return deriveChatSnapshot(store.state, agent.getChatStatus(topic.chatId), topic.chatId, () => transcript, () => getLastChatModel(store, topic.chatId), agent.getChatPendingTool(topic.chatId), resolveChatUsageForSnapshot({
           chat,
           messages,
           liveUsage: agent.getLiveUsage(topic.chatId)
-        }), providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS, providerCatalogManager?.getSelectableProviders(providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS));
+        }), null, providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS, providerCatalogManager?.getSelectableProviders(providerSettings?.getSnapshot().settings ?? DEFAULT_PROVIDER_SETTINGS), agent.getQueuedOutboundPreview(topic.chatId));
       })()
     };
   }
@@ -17975,6 +18987,24 @@ function createWsRouter({
       }
     }
   }
+  function pushProjectDiffSnapshot(projectId) {
+    const snapshot = deriveSnapshotForTopic({ type: "project-diffs", projectId });
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type !== "project-diffs" || topic.projectId !== projectId) {
+          continue;
+        }
+        send(ws, {
+          v: PROTOCOL_VERSION,
+          type: "snapshot",
+          id,
+          seq: (ws.data.seqBySubscriptionId.get(id) ?? 0) + 1,
+          snapshot
+        });
+        ws.data.seqBySubscriptionId.set(id, (ws.data.seqBySubscriptionId.get(id) ?? 0) + 1);
+      }
+    }
+  }
   function pushFeatureOverviewSnapshot(featureId) {
     for (const ws of sockets) {
       for (const [id, topic] of ws.data.subscriptions.entries()) {
@@ -18012,6 +19042,22 @@ function createWsRouter({
       }
     }
   });
+  let lastSendChunkSizeBytes = generalSettings?.getSnapshot().settings.sendChunkSizeBytes ?? DEFAULT_GENERAL_SETTINGS.sendChunkSizeBytes;
+  const disposeGeneralSettingsEvents = generalSettings?.onChange((snapshot) => {
+    const previousSendChunkSizeBytes = lastSendChunkSizeBytes;
+    lastSendChunkSizeBytes = snapshot.settings.sendChunkSizeBytes;
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type === "general-settings") {
+          realtime.sendRefreshSnapshot(ws, id, topic);
+          continue;
+        }
+        if (topic.type === "chat" && previousSendChunkSizeBytes !== lastSendChunkSizeBytes) {
+          realtime.sendRefreshSnapshot(ws, id, topic);
+        }
+      }
+    }
+  }) ?? (() => {});
   const disposeThemeSettingsEvents = themeSettings.onChange(() => {
     for (const ws of sockets) {
       for (const [id, topic] of ws.data.subscriptions.entries()) {
@@ -18140,6 +19186,14 @@ function createWsRouter({
           });
           return;
         }
+        case "settings.writeGeneralSettings": {
+          if (!generalSettings) {
+            throw new Error("General settings unavailable.");
+          }
+          const snapshot = await generalSettings.write(command.settings);
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot });
+          return;
+        }
         case "settings.readKeybindings": {
           send(ws, {
             v: PROTOCOL_VERSION,
@@ -18302,6 +19356,7 @@ function createWsRouter({
             }
             await store.hideProject(project.localPath);
             realtime.publishSidebarProjectRemoved(project.id);
+            diffs.clearSnapshot(project.id);
           }
           await refreshDiscovery();
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
@@ -18336,6 +19391,7 @@ function createWsRouter({
           await store.hideProject(command.localPath);
           if (existingProject) {
             realtime.publishSidebarProjectRemoved(existingProject.id);
+            diffs.clearSnapshot(existingProject.id);
           }
           await refreshDiscovery();
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
@@ -18530,11 +19586,35 @@ function createWsRouter({
           await agent.cancel(command.chatId);
           agent.disposeChatResources(command.chatId);
           await store.deleteChat(command.chatId);
+          if (store.listChatsByProject(chat.projectId).length === 0) {
+            diffs.clearSnapshot(chat.projectId);
+          }
           realtime.publishChatDeleted(command.chatId);
           realtime.publishSidebarChatRemoved(chat.projectId, chat.featureId ?? null, command.chatId);
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
           break;
         }
+        case "project.refreshDiffs": {
+          const project = store.getProject(command.projectId);
+          if (!project)
+            throw new Error("Project not found");
+          const previousSnapshot = diffs.getSnapshot(command.projectId);
+          const snapshot = await diffs.refreshProjectDiffSnapshot({
+            projectId: command.projectId,
+            localPath: project.localPath
+          });
+          const changed = !areDiffSnapshotsEquivalent(previousSnapshot, snapshot);
+          send(ws, {
+            v: PROTOCOL_VERSION,
+            type: "ack",
+            id,
+            result: { changed }
+          });
+          if (changed) {
+            pushProjectDiffSnapshot(command.projectId);
+          }
+          break;
+        }
         case "chat.loadMore": {
           const chat = store.getChat(command.chatId);
           const transcript = chat && !store.hasLocalChatPayload(command.chatId) && chat.provider && chat.sessionToken && (chat.provider === "claude" || chat.provider === "codex" || chat.provider === "cursor") ? hydrateProviderSessionWindow({
@@ -18542,12 +19622,12 @@ function createWsRouter({
             sessionToken: chat.sessionToken,
             localPath: store.getProject(chat.projectId)?.localPath ?? "",
             beforeEntryId: command.beforeEntryId,
-            targetBytes: command.targetBytes ?? LOAD_MORE_CHAT_WINDOW_TARGET_BYTES,
+            targetBytes: command.targetBytes ?? getSendChunkSizeBytes(),
             minEntries: LOAD_MORE_CHAT_WINDOW_MIN_ENTRIES,
             providerSessionIndex
           }) : store.getMessageWindow(command.chatId, {
             beforeEntryId: command.beforeEntryId,
-            targetBytes: command.targetBytes ?? LOAD_MORE_CHAT_WINDOW_TARGET_BYTES,
+            targetBytes: command.targetBytes ?? getSendChunkSizeBytes(),
             minEntries: LOAD_MORE_CHAT_WINDOW_MIN_ENTRIES
           });
           const result = {
@@ -18593,6 +19673,16 @@ function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result });
           break;
         }
+        case "chat.outboundQueue.remove": {
+          await agent.removeOutboundQueueMessage(command.chatId, command.messageId);
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
+          break;
+        }
+        case "chat.outboundQueue.update": {
+          await agent.updateOutboundQueueMessage(command.chatId, command.messageId, command.text);
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
+          break;
+        }
         case "chat.cancel": {
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
           agent.cancel(command.chatId).catch((error) => {
@@ -18600,6 +19690,44 @@ function createWsRouter({
           });
           break;
         }
+        case "chat.generateCommitMessage": {
+          const chat = store.getChat(command.chatId);
+          if (!chat)
+            throw new Error("Chat not found");
+          const project = store.getProject(chat.projectId);
+          if (!project)
+            throw new Error("Project not found");
+          const result = await diffs.generateCommitMessage({
+            projectId: project.id,
+            localPath: project.localPath,
+            paths: command.paths
+          });
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result });
+          break;
+        }
+        case "chat.commitDiffs": {
+          const chat = store.getChat(command.chatId);
+          if (!chat)
+            throw new Error("Chat not found");
+          const project = store.getProject(chat.projectId);
+          if (!project)
+            throw new Error("Project not found");
+          const previousSnapshot = diffs.getSnapshot(project.id);
+          const result = await diffs.commitDiffs({
+            projectId: project.id,
+            localPath: project.localPath,
+            paths: command.paths,
+            summary: command.summary,
+            description: command.description,
+            mode: command.mode
+          });
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result });
+          const nextSnapshot = diffs.getSnapshot(project.id);
+          if (result.snapshotChanged && !areDiffSnapshotsEquivalent(previousSnapshot, nextSnapshot)) {
+            pushProjectDiffSnapshot(project.id);
+          }
+          break;
+        }
         case "chat.respondTool": {
           await agent.respondTool(command);
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id });
@@ -18749,6 +19877,7 @@ function createWsRouter({
       }
       disposeTerminalEvents();
       disposeKeybindingEvents();
+      disposeGeneralSettingsEvents();
       disposeProviderSettingsEvents();
       disposeProviderCatalogEvents();
       disposeRemoteAuthEvents();
@@ -18786,10 +19915,10 @@ var remoteRelaySnapshotFallback = {
 };
 
 // src/server/remote-auth.ts
-import { watch as watch4 } from "fs";
-import { chmod, mkdir as mkdir8, readFile as readFile8, rename as rename2, writeFile as writeFile8 } from "fs/promises";
-import { homedir as homedir15 } from "os";
-import path24 from "path";
+import { watch as watch5 } from "fs";
+import { chmod, mkdir as mkdir9, readFile as readFile9, rename as rename2, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir16 } from "os";
+import path26 from "path";
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -19266,8 +20395,8 @@ function getErrorMap() {
 }
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path24, errorMaps, issueData } = params;
-  const fullPath = [...path24, ...issueData.path || []];
+  const { data, path: path26, errorMaps, issueData } = params;
+  const fullPath = [...path26, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -19379,11 +20508,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path24, key) {
+  constructor(parent, value, path26, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path24;
+    this._path = path26;
     this._key = key;
   }
   get path() {
@@ -23070,8 +24199,8 @@ function dedupeCallbackUrls(values) {
   return [...new Set(values)];
 }
 function getRemoteAuthTokenFilePath(stateFilePath) {
-  const parsedPath = path24.parse(stateFilePath);
-  return path24.join(parsedPath.dir, `${parsedPath.name}.tokens${parsedPath.ext}`);
+  const parsedPath = path26.parse(stateFilePath);
+  return path26.join(parsedPath.dir, `${parsedPath.name}.tokens${parsedPath.ext}`);
 }
 function buildAllowedRemoteAuthCallbackUrls(localBaseUrl) {
   const currentUrl = new URL(localBaseUrl);
@@ -23236,7 +24365,7 @@ function formatJwksErrorBodyPreview(bodyText) {
 }
 async function writeFileAtomically(filePath, contents, options) {
   const tempFilePath = `${filePath}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(tempFilePath, contents, {
+  await writeFile9(tempFilePath, contents, {
     encoding: "utf8",
     mode: options?.mode
   });
@@ -23260,14 +24389,14 @@ class RemoteAuthManager {
   state;
   snapshot;
   listeners = new Set;
-  constructor(filePath = getRemoteAuthFilePath(homedir15())) {
+  constructor(filePath = getRemoteAuthFilePath(homedir16())) {
     this.filePath = filePath;
     this.tokenFilePath = getRemoteAuthTokenFilePath(filePath);
     this.state = normalizeStoredRemoteAuthState(null);
     this.snapshot = createSnapshot2(this.state, getRemoteAuthFilePathDisplay());
   }
   async initialize() {
-    await mkdir8(path24.dirname(this.filePath), { recursive: true });
+    await mkdir9(path26.dirname(this.filePath), { recursive: true });
     const file = Bun.file(this.filePath);
     if (!await file.exists()) {
       await this.persistState(normalizeStoredRemoteAuthState(null));
@@ -23602,7 +24731,7 @@ class RemoteAuthManager {
     throw lastError ?? new Error("Failed to fetch Kaizen JWKS");
   }
   async persistState(state) {
-    await mkdir8(path24.dirname(this.filePath), { recursive: true });
+    await mkdir9(path26.dirname(this.filePath), { recursive: true });
     const { metadata, tokens } = splitStoredState(state);
     await writeFileAtomically(this.tokenFilePath, `${JSON.stringify(tokens, null, 2)}
 `, {
@@ -23663,10 +24792,10 @@ class RemoteAuthManager {
   startWatching() {
     this.watcher?.close();
     try {
-      this.watcher = watch4(path24.dirname(this.filePath), { persistent: false }, (eventType, filename) => {
+      this.watcher = watch5(path26.dirname(this.filePath), { persistent: false }, (eventType, filename) => {
         if (eventType !== "change" && eventType !== "rename")
           return;
-        if (filename && filename !== path24.basename(this.filePath) && filename !== path24.basename(this.tokenFilePath)) {
+        if (filename && filename !== path26.basename(this.filePath) && filename !== path26.basename(this.tokenFilePath)) {
           return;
         }
         this.reloadFromDisk().catch((error) => {
@@ -23681,7 +24810,7 @@ class RemoteAuthManager {
 }
 async function readRemoteAuthState(filePath, tokenFilePath) {
   try {
-    const metadataText = await readFile8(filePath, "utf8");
+    const metadataText = await readFile9(filePath, "utf8");
     const metadataValue = metadataText.trim() ? JSON.parse(metadataText) : null;
     const tokenValue = await readRemoteAuthTokens(tokenFilePath);
     const needsMigration = containsLegacyTokenFields(metadataValue) || tokenValue === null;
@@ -23705,7 +24834,7 @@ async function readRemoteAuthState(filePath, tokenFilePath) {
 }
 async function readRemoteAuthTokens(filePath) {
   try {
-    const text = await readFile8(filePath, "utf8");
+    const text = await readFile9(filePath, "utf8");
     if (!text.trim()) {
       return null;
     }
@@ -23719,9 +24848,9 @@ async function readRemoteAuthTokens(filePath) {
 }
 
 // src/server/remote-relay.ts
-import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
-import { homedir as homedir16 } from "os";
-import path25 from "path";
+import { mkdir as mkdir10, readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
+import { homedir as homedir17 } from "os";
+import path27 from "path";
 var OFFLINE_POLL_INTERVAL_MS = 15000;
 var HOP_BY_HOP_HEADER_NAMES = new Set([
   "accept-encoding",
@@ -23838,7 +24967,7 @@ class RemoteRelayManager {
   reconnectAttempt = 0;
   isIdleDisconnected = false;
   proxiedSockets = new Map;
-  constructor(remoteAuth, machineDisplayName, filePath = getRemoteRelayFilePath(homedir16())) {
+  constructor(remoteAuth, machineDisplayName, filePath = getRemoteRelayFilePath(homedir17())) {
     this.remoteAuth = remoteAuth;
     this.machineDisplayName = machineDisplayName;
     this.filePath = filePath;
@@ -23848,7 +24977,7 @@ class RemoteRelayManager {
   async initialize(localPort, localHost) {
     this.localPort = localPort;
     this.localHost = resolveUpstreamHost(localHost);
-    await mkdir9(path25.dirname(this.filePath), { recursive: true });
+    await mkdir10(path27.dirname(this.filePath), { recursive: true });
     this.state = await this.readState();
     this.setSnapshot(createSnapshot3(this.state));
     this.remoteAuth.onChange(() => {
@@ -23879,7 +25008,7 @@ class RemoteRelayManager {
   }
   async readState() {
     try {
-      const text = await readFile9(this.filePath, "utf8");
+      const text = await readFile10(this.filePath, "utf8");
       return normalizeState(JSON.parse(text));
     } catch {
       return normalizeState(null);
@@ -23887,7 +25016,7 @@ class RemoteRelayManager {
   }
   async persistState(state) {
     this.state = state;
-    await writeFile9(this.filePath, `${JSON.stringify(state, null, 2)}
+    await writeFile10(this.filePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   }
   setSnapshot(snapshot) {
@@ -24029,10 +25158,6 @@ class RemoteRelayManager {
       this.disconnect("disabled");
       return;
     }
-    if (!authSnapshot.entitlements?.["remote.relay"]) {
-      this.disconnect("unauthorized");
-      return;
-    }
     if (this.isIdleDisconnected) {
       this.setSnapshot(createSnapshot3(this.state, { status: "idle_disconnected" }));
       this.startOfflinePoll();
@@ -24043,7 +25168,16 @@ class RemoteRelayManager {
     }
     this.setSnapshot(createSnapshot3(this.state, { status: "registering" }));
     this.stopOfflinePoll();
-    const registration = await this.registerMachine(authSnapshot.baseUrl, accessToken);
+    let registration;
+    try {
+      registration = await this.registerMachine(authSnapshot.baseUrl, accessToken);
+    } catch (error) {
+      if (error instanceof Error && "status" in error && error.status === 403) {
+        this.disconnect("unauthorized");
+        return;
+      }
+      throw error;
+    }
     await this.persistState({
       relayEnabled: this.state.relayEnabled,
       ownerUserId: authSnapshot.userId,
@@ -24067,7 +25201,9 @@ class RemoteRelayManager {
     });
     const payload = await response.json();
     if (!response.ok || !payload.data) {
-      throw new Error(payload.error ?? "Failed to register relay machine");
+      const error = new Error(payload.error ?? "Failed to register relay machine");
+      Object.assign(error, { status: response.status });
+      throw error;
     }
     return payload.data;
   }
@@ -24370,9 +25506,9 @@ class RemoteRelayManager {
 
 // src/server/provider-session-index.ts
 import { existsSync as existsSync11, readFileSync as readFileSync8, readdirSync as readdirSync9, statSync as statSync8 } from "fs";
-import { mkdir as mkdir10, readFile as readFile10, rename as rename3, writeFile as writeFile10 } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import path26 from "path";
+import { mkdir as mkdir11, readFile as readFile11, rename as rename3, writeFile as writeFile11 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import path28 from "path";
 var PROVIDER_SESSION_INDEX_VERSION = 1;
 var REFRESH_INTERVAL_MS = 60000;
 var CODEX_SESSION_METADATA_PEEK_BYTES = 128 * 1024;
@@ -24393,7 +25529,7 @@ function collectFiles2(directory, extension) {
   }
   const files = [];
   for (const entry of readdirSync9(directory, { withFileTypes: true })) {
-    const fullPath = path26.join(directory, entry.name);
+    const fullPath = path28.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectFiles2(fullPath, extension));
       continue;
@@ -24405,7 +25541,7 @@ function collectFiles2(directory, extension) {
   return files;
 }
 function normalizePath(localPath) {
-  return path26.normalize(localPath);
+  return path28.normalize(localPath);
 }
 function firstLine3(value, fallback) {
   const line = value.split(`
@@ -24439,7 +25575,7 @@ function readClaudeSessionMetadata(sourcePath) {
     if (!sessionToken && typeof record.sessionId === "string") {
       sessionToken = record.sessionId;
     }
-    if (!localPath && typeof record.cwd === "string" && path26.isAbsolute(record.cwd)) {
+    if (!localPath && typeof record.cwd === "string" && path28.isAbsolute(record.cwd)) {
       localPath = normalizePath(record.cwd);
     }
     if (typeof record.timestamp === "string") {
@@ -24527,7 +25663,7 @@ function readCodexSessionMetadata2(sourcePath) {
         if (!sessionToken && typeof payloadRecord2.id === "string") {
           sessionToken = payloadRecord2.id;
         }
-        if (!localPath && typeof payloadRecord2.cwd === "string" && path26.isAbsolute(payloadRecord2.cwd)) {
+        if (!localPath && typeof payloadRecord2.cwd === "string" && path28.isAbsolute(payloadRecord2.cwd)) {
           localPath = normalizePath(payloadRecord2.cwd);
         }
       }
@@ -24578,7 +25714,7 @@ function readCursorSessionMetadata(sourcePath, localPath) {
   const stats = statSync8(sourcePath);
   const lines = readFileSync8(sourcePath, "utf8").split(`
 `);
-  const sessionToken = path26.basename(sourcePath, ".jsonl");
+  const sessionToken = path28.basename(sourcePath, ".jsonl");
   let title = null;
   for (const line of lines) {
     if (!line.trim())
@@ -24637,8 +25773,8 @@ class ProviderSessionIndex {
   sessionsByKey = new Map;
   refreshTimer = null;
   refreshInFlight = null;
-  constructor(dataDir, homeDir = homedir17()) {
-    this.indexPath = path26.join(dataDir, "provider-session-index.json");
+  constructor(dataDir, homeDir = homedir18()) {
+    this.indexPath = path28.join(dataDir, "provider-session-index.json");
     this.homeDir = homeDir;
   }
   async initialize() {
@@ -24685,7 +25821,7 @@ class ProviderSessionIndex {
           visiblePaths.add(normalizePath(worktreePath));
         }
       }
-      for (const sourcePath of collectFiles2(path26.join(this.homeDir, ".claude", "projects"), ".jsonl")) {
+      for (const sourcePath of collectFiles2(path28.join(this.homeDir, ".claude", "projects"), ".jsonl")) {
         const metadata = reuseUnchangedMetadata(previousBySourcePath, sourcePath) ?? readClaudeSessionMetadata(sourcePath);
         if (!metadata || !visiblePaths.has(metadata.localPath))
           continue;
@@ -24696,7 +25832,7 @@ class ProviderSessionIndex {
           indexedPaths.add(sourcePath);
         }
       }
-      for (const sourcePath of collectFiles2(path26.join(this.homeDir, ".codex", "sessions"), ".jsonl")) {
+      for (const sourcePath of collectFiles2(path28.join(this.homeDir, ".codex", "sessions"), ".jsonl")) {
         const metadata = reuseUnchangedMetadata(previousBySourcePath, sourcePath) ?? readCodexSessionMetadata2(sourcePath);
         if (!metadata || !visiblePaths.has(metadata.localPath))
           continue;
@@ -24708,7 +25844,7 @@ class ProviderSessionIndex {
         }
       }
       for (const localPath of visiblePaths) {
-        const transcriptRoot = path26.join(this.homeDir, ".cursor", "projects", encodeCursorProjectPath2(localPath), "agent-transcripts");
+        const transcriptRoot = path28.join(this.homeDir, ".cursor", "projects", encodeCursorProjectPath2(localPath), "agent-transcripts");
         for (const sourcePath of collectFiles2(transcriptRoot, ".jsonl")) {
           const metadata = reuseUnchangedMetadata(previousBySourcePath, sourcePath) ?? readCursorSessionMetadata(sourcePath, localPath);
           if (!metadata)
@@ -24782,7 +25918,7 @@ class ProviderSessionIndex {
   async loadPersistedIndex() {
     if (!existsSync11(this.indexPath))
       return;
-    const raw = await readFile10(this.indexPath, "utf8").catch(() => "");
+    const raw = await readFile11(this.indexPath, "utf8").catch(() => "");
     if (!raw.trim())
       return;
     try {
@@ -24814,8 +25950,8 @@ class ProviderSessionIndex {
       sessions: [...this.sessionsByKey.values()].sort(sessionSort)
     };
     const tempPath = `${this.indexPath}.tmp`;
-    await mkdir10(path26.dirname(this.indexPath), { recursive: true });
-    await writeFile10(tempPath, JSON.stringify(payload, null, 2), "utf8");
+    await mkdir11(path28.dirname(this.indexPath), { recursive: true });
+    await writeFile11(tempPath, JSON.stringify(payload, null, 2), "utf8");
     await rename3(tempPath, this.indexPath);
   }
 }
@@ -24855,10 +25991,13 @@ async function startKaizenServer(options = {}) {
   let router = null;
   const terminals = new TerminalManager;
   const git = new GitManager;
+  const diffs = new DiffStore(git);
   const keybindings = new KeybindingsManager;
   await keybindings.initialize();
   const providerSettings = new ProviderSettingsManager;
   await providerSettings.initialize();
+  const generalSettings = new GeneralSettingsManager;
+  await generalSettings.initialize();
   const providerCatalogManager = new ProviderCatalogManager;
   await providerCatalogManager.initialize();
   const remoteAuth = new RemoteAuthManager;
@@ -24875,7 +26014,7 @@ async function startKaizenServer(options = {}) {
   }) : null;
   const agent = new AgentCoordinator({
     store,
-    attachmentsDir: path27.join(store.dataDir, "attachments"),
+    attachmentsDir: path29.join(store.dataDir, "attachments"),
     providerSettingsManager: providerSettings,
     providerCatalogManager,
     remoteAuthManager: remoteAuth,
@@ -24900,7 +26039,9 @@ async function startKaizenServer(options = {}) {
       providerSessionIndex,
       terminals,
       git,
+      diffs,
       keybindings,
+      generalSettings,
       providerSettings,
       providerCatalogManager,
       remoteAuth,
@@ -24915,7 +26056,7 @@ async function startKaizenServer(options = {}) {
     agent.setRealtime(router.realtime);
   }
   providerSessionIndex.start(() => store.listProjects());
-  const distDir = path27.join(import.meta.dir, "..", "..", "dist", "client");
+  const distDir = path29.join(import.meta.dir, "..", "..", "dist", "client");
   const MAX_PORT_ATTEMPTS = 20;
   let actualPort = port;
   for (let attempt = 0;attempt < MAX_PORT_ATTEMPTS; attempt++) {
@@ -24966,7 +26107,7 @@ async function startKaizenServer(options = {}) {
             });
           }
           if (url.pathname.startsWith(`${ATTACHMENTS_ROUTE_PREFIX}/`)) {
-            return serveAttachment(path27.join(store.dataDir, "attachments"), url.pathname);
+            return serveAttachment(path29.join(store.dataDir, "attachments"), url.pathname);
           }
           return serveStatic(distDir, req, url.pathname);
         },
@@ -25027,6 +26168,7 @@ async function startKaizenServer(options = {}) {
     providerSessionIndex.dispose();
     keybindings.dispose();
     providerSettings.dispose();
+    generalSettings.dispose();
     remoteAuth.dispose();
     remoteRelay.dispose();
     themeSettings.dispose();
@@ -25162,8 +26304,8 @@ async function serveCompressed(originalFilePath, request, cacheControl) {
 }
 async function serveStatic(distDir, request, pathname) {
   const requestedPath = pathname === "/" ? "/index.html" : pathname;
-  const filePath = path27.join(distDir, requestedPath);
-  const indexPath = path27.join(distDir, "index.html");
+  const filePath = path29.join(distDir, requestedPath);
+  const indexPath = path29.join(distDir, "index.html");
   const cacheControl = getCacheControlHeader(requestedPath);
   const file = Bun.file(filePath);
   if (await file.exists()) {