@kimuson/claude-code-viewer 0.5.9 → 0.6.0-beta.2

package/dist/main.js

@@ -2,12 +2,12 @@
 
 // src/server/main.ts
 import { Command as Command3 } from "commander";
-import { Effect as Effect53 } from "effect";
+import { Effect as Effect65 } from "effect";
 
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.5.9",
+  version: "0.6.0-beta.2",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -28,7 +28,7 @@ var package_default = {
   scripts: {
     dev: "run-p 'dev:*'",
     "dev:frontend": "vite",
-    "dev:backend": "NODE_ENV=development tsx watch src/server/main.ts --env-file-if-exists=.env.local",
+    "dev:backend": "CCV_ENV=development tsx watch --env-file-if-exists=.env.local src/server/main.ts",
     start: "node dist/main.js",
     build: "./scripts/build.sh",
     "build:frontend": "vite build",
@@ -39,7 +39,7 @@ var package_default = {
     fix: "run-s 'fix:*'",
     "fix:biome-format": "biome format --write .",
     "fix:biome-lint": "biome check --write --unsafe .",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsgo --noEmit",
     test: "vitest --run",
     "test:watch": "vitest",
     e2e: "./scripts/e2e/exec_e2e.sh",
@@ -52,7 +52,7 @@ var package_default = {
   },
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "0.2.20",
-    "@anthropic-ai/claude-code": "2.0.24",
+    "@anthropic-ai/claude-code": "2.1.29",
     "@anthropic-ai/sdk": "0.71.2",
     "@effect/cluster": "0.56.1",
     "@effect/experimental": "0.58.0",
@@ -63,6 +63,7 @@ var package_default = {
     "@effect/workflow": "0.16.0",
     "@hono/node-server": "1.19.9",
     "@hono/zod-validator": "0.7.6",
+    "@hookform/resolvers": "^5.2.2",
     "@lingui/core": "5.9.0",
     "@lingui/react": "5.9.0",
     "@radix-ui/react-avatar": "1.1.11",
@@ -75,13 +76,17 @@ var package_default = {
     "@radix-ui/react-slot": "1.2.4",
     "@radix-ui/react-tabs": "1.1.13",
     "@radix-ui/react-tooltip": "1.2.8",
+    "@replit/ruspty": "^3.6.0",
     "@tailwindcss/vite": "4.1.18",
     "@tanstack/react-devtools": "0.9.2",
     "@tanstack/react-query": "5.90.20",
     "@tanstack/react-router": "1.156.0",
     "@tanstack/react-router-devtools": "1.156.0",
+    "@xterm/addon-fit": "0.10.0",
+    "@xterm/xterm": "5.5.0",
     "class-variance-authority": "0.7.1",
     clsx: "2.1.1",
+    cmdk: "^1.1.1",
     commander: "^14.0.2",
     "date-fns": "4.1.0",
     effect: "3.19.15",
@@ -92,15 +97,18 @@ var package_default = {
     minisearch: "7.2.0",
     "parse-git-diff": "0.0.19",
     prexit: "2.3.0",
+    "radix-ui": "^1.4.3",
     react: "19.2.3",
     "react-dom": "19.2.3",
     "react-error-boundary": "6.1.0",
+    "react-hook-form": "^7.71.1",
     "react-markdown": "10.1.0",
     "react-syntax-highlighter": "16.1.0",
     "remark-gfm": "4.0.1",
     sonner: "2.0.7",
     "tailwind-merge": "3.4.0",
     ulid: "3.0.2",
+    ws: "8.18.3",
     zod: "4.3.6"
   },
   devDependencies: {
@@ -118,6 +126,8 @@ var package_default = {
     "@types/react": "19.2.9",
     "@types/react-dom": "19.2.3",
     "@types/react-syntax-highlighter": "15.5.13",
+    "@types/ws": "8.18.0",
+    "@typescript/native-preview": "7.0.0-dev.20260207.1",
     "@vitejs/plugin-react-swc": "4.2.2",
     dotenv: "17.2.3",
     esbuild: "0.27.2",
@@ -214,12 +224,12 @@ var checkDeprecatedEnvs = Effect.gen(function* () {
 });
 
 // src/server/startServer.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { resolve as resolve6 } from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve7 } from "node:path";
 import { NodeContext as NodeContext2 } from "@effect/platform-node";
-import { serve } from "@hono/node-server";
+import { createAdaptorServer } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Effect as Effect52, Layer as Layer43 } from "effect";
+import { Effect as Effect64, Layer as Layer44 } from "effect";
 
 // src/server/core/agent-session/index.ts
 import { Layer as Layer3 } from "effect";
@@ -690,6 +700,10 @@ import { Context as Context3, Effect as Effect4, Layer as Layer4, Ref } from "ef
 var getOptionalEnv2 = (key) => {
   return process.env[key] ?? void 0;
 };
+var isFlagEnabled = (value) => {
+  if (!value) return false;
+  return value === "1" || value.toLowerCase() === "true";
+};
 var LayerImpl3 = Effect4.gen(function* () {
   const ccvOptionsRef = yield* Ref.make(void 0);
   const loadCliOptions = (cliOptions) => {
@@ -703,7 +717,10 @@ var LayerImpl3 = Effect4.gen(function* () {
           hostname: cliOptions.hostname ?? getOptionalEnv2("HOSTNAME") ?? "localhost",
           password: cliOptions.password ?? getOptionalEnv2("CCV_PASSWORD") ?? void 0,
           executable: cliOptions.executable ?? getOptionalEnv2("CCV_CC_EXECUTABLE_PATH") ?? void 0,
-          claudeDir: cliOptions.claudeDir ?? getOptionalEnv2("CCV_GLOBAL_CLAUDE_DIR")
+          claudeDir: cliOptions.claudeDir ?? getOptionalEnv2("CCV_GLOBAL_CLAUDE_DIR"),
+          terminalDisabled: cliOptions.terminalDisabled ?? (isFlagEnabled(getOptionalEnv2("CCV_TERMINAL_DISABLED")) ? true : void 0),
+          terminalShell: cliOptions.terminalShell ?? getOptionalEnv2("CCV_TERMINAL_SHELL") ?? void 0,
+          terminalUnrestricted: cliOptions.terminalUnrestricted ?? (isFlagEnabled(getOptionalEnv2("CCV_TERMINAL_UNRESTRICTED")) ? true : void 0)
         };
       });
     });
@@ -940,8 +957,8 @@ var LayerImpl6 = Effect8.gen(function* () {
       dirents.filter((name) => name.endsWith(".jsonl")).map(
         (name) => Effect8.gen(function* () {
           const fullPath = path.resolve(claudeProjectPath, name);
-          const stat = yield* fs.stat(fullPath);
-          const mtime = Option.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date(0));
+          const stat2 = yield* fs.stat(fullPath);
+          const mtime = Option.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date(0));
           return {
             fullPath,
             mtime
@@ -1006,13 +1023,13 @@ var LayerImpl7 = Effect9.gen(function* () {
     if (!exists) {
       return yield* Effect9.fail(new Error("Project not found"));
     }
-    const stat = yield* fs.stat(fullPath);
+    const stat2 = yield* fs.stat(fullPath);
     const meta = yield* projectMetaService.getProjectMeta(projectId);
     return {
       project: {
         id: projectId,
         claudeProjectPath: fullPath,
-        lastModifiedAt: Option2.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date()),
+        lastModifiedAt: Option2.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date()),
         meta
       }
     };
@@ -1036,10 +1053,10 @@ var LayerImpl7 = Effect9.gen(function* () {
           (yield* context.claudeCodePaths).claudeProjectsDirPath,
           entry
         );
-        const stat = yield* Effect9.tryPromise(
+        const stat2 = yield* Effect9.tryPromise(
           () => fs.stat(fullPath).pipe(Effect9.runPromise)
         ).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
-        if (!stat || stat.type !== "Directory") {
+        if (!stat2 || stat2.type !== "Directory") {
           return null;
         }
         const id = encodeProjectId(fullPath);
@@ -1047,7 +1064,7 @@ var LayerImpl7 = Effect9.gen(function* () {
         return {
           id,
           claudeProjectPath: fullPath,
-          lastModifiedAt: Option2.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date()),
+          lastModifiedAt: Option2.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date()),
           meta
         };
       })
@@ -1241,7 +1258,6 @@ var parseMcpListOutput = (output) => {
 
 // src/server/core/claude-code/models/ClaudeCode.ts
 import * as agentSdk from "@anthropic-ai/claude-agent-sdk";
-import * as claudeCodeSdk from "@anthropic-ai/claude-code";
 import { Command, Path as Path7 } from "@effect/platform";
 import { Data, Effect as Effect11 } from "effect";
 import { uniq } from "es-toolkit";
@@ -1262,6 +1278,10 @@ var ClaudeCodePathNotFoundError = class extends Data.TaggedError(
   "ClaudeCodePathNotFoundError"
 ) {
 };
+var ClaudeCodeAgentSdkNotSupportedError = class extends Data.TaggedError(
+  "ClaudeCodeAgentSdkNotSupportedError"
+) {
+};
 var resolveClaudeCodePath = Effect11.gen(function* () {
   const path = yield* Path7.Path;
   const ccvOptionsService = yield* CcvOptionsService;
@@ -1357,57 +1377,42 @@ var getAvailableFeatures = (claudeCodeVersion) => ({
     patch: 77
   }) : false
 });
-var query3 = (prompt, options) => {
-  const { canUseTool, permissionMode, hooks, ...baseOptions } = options;
+var query2 = (prompt, options) => {
+  const {
+    canUseTool,
+    permissionMode,
+    hooks,
+    systemPrompt,
+    settingSources,
+    ...baseOptions
+  } = options;
   return Effect11.gen(function* () {
     const { claudeCodeExecutablePath, claudeCodeVersion } = yield* Config;
     const availableFeatures = getAvailableFeatures(claudeCodeVersion);
     const options2 = {
-      pathToClaudeCodeExecutable: claudeCodeExecutablePath,
       ...baseOptions,
-      disallowedTools: ["AskUserQuestion"],
+      systemPrompt,
+      settingSources,
+      pathToClaudeCodeExecutable: claudeCodeExecutablePath,
+      disallowedTools: [
+        "AskUserQuestion",
+        ...baseOptions.disallowedTools ?? []
+      ],
       // Cannot answer from web interface instead of CLI
       ...availableFeatures.canUseTool ? { canUseTool, permissionMode } : {
         permissionMode: "bypassPermissions"
       }
     };
-    if (availableFeatures.agentSdk) {
-      return agentSdk.query({
-        prompt,
-        options: {
-          systemPrompt: { type: "preset", preset: "claude_code" },
-          settingSources: ["user", "project", "local"],
-          ...options2
-        }
+    if (!availableFeatures.agentSdk) {
+      return yield* new ClaudeCodeAgentSdkNotSupportedError({
+        message: "Agent SDK is not supported in this version of Claude Code"
       });
     }
-    const fallbackCanUseTool = (() => {
-      const canUseTool2 = options2.canUseTool;
-      if (canUseTool2 === void 0) {
-        return void 0;
-      }
-      const fn = async (toolName, input, canUseToolOptions) => {
-        const response = await canUseTool2(toolName, input, {
-          signal: canUseToolOptions.signal,
-          suggestions: canUseToolOptions.suggestions,
-          toolUseID: void 0
-        });
-        return response;
-      };
-      return fn;
-    })();
-    return claudeCodeSdk.query({
+    return agentSdk.query({
       prompt,
       options: {
-        ...baseOptions,
-        disallowedTools: ["AskUserQuestion"],
-        // Cannot answer from web interface instead of CLI
-        permissionMode: (
-          // fallback unsupported permission modes
-          permissionMode === "delegate" || permissionMode === "dontAsk" ? "bypassPermissions" : permissionMode
-        ),
-        hooks,
-        canUseTool: fallbackCanUseTool
+        settingSources: ["user", "project", "local"],
+        ...options2
       }
     });
   });
@@ -1635,7 +1640,7 @@ var LayerImpl10 = Effect15.gen(function* () {
     return response;
   });
   const createCanUseToolRelatedOptions = (options) => {
-    const { taskId, userConfig, sessionId } = options;
+    const { turnId, userConfig, sessionId } = options;
     return Effect15.gen(function* () {
       const claudeCodeConfig = yield* Config;
       if (!getAvailableFeatures(claudeCodeConfig.claudeCodeVersion).canUseTool) {
@@ -1659,7 +1664,7 @@ var LayerImpl10 = Effect15.gen(function* () {
         }
         const permissionRequest = {
           id: ulid(),
-          taskId,
+          turnId,
           sessionId,
           toolName,
           toolInput,
@@ -1840,10 +1845,10 @@ var controllablePromise = () => {
   const promiseRef = {
     status: "pending"
   };
-  const promise = new Promise((resolve7, reject) => {
+  const promise = new Promise((resolve8, reject) => {
     promiseResolve = (value) => {
       promiseRef.status = "resolved";
-      resolve7(value);
+      resolve8(value);
     };
     promiseReject = (reason) => {
       promiseRef.status = "rejected";
@@ -1865,7 +1870,7 @@ import { Context as Context16, Effect as Effect21, Layer as Layer18, Option as O
 
 // src/server/core/claude-code/functions/parseUserMessage.ts
 import { z as z21 } from "zod";
-var regExp = /<(?<tag>[^>]+)>(?<content>\s*[^<]*?\s*)<\/\k<tag>>/g;
+var regExp = /<(?<tag>[^>]+)>(?<content>[\s\S]*?)<\/\k<tag>>/g;
 var matchSchema = z21.object({
   tag: z21.string(),
   content: z21.string()
@@ -2252,6 +2257,11 @@ var ignoreCommands = [
   "/mcp",
   "/memory"
 ];
+var localCommandCaveatText = "Caveat: The messages below were generated by the user while running local commands. DO NOT respond to these messages or otherwise consider them in your response unless the user explicitly asks you to.";
+var localCommandCaveatPattern = /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/;
+var isLocalCommandCaveat = (text) => {
+  return text === localCommandCaveatText || localCommandCaveatPattern.test(text);
+};
 var extractFirstUserMessage = (conversation) => {
   if (conversation.type !== "user") {
     return void 0;
@@ -2263,16 +2273,13 @@ var extractFirstUserMessage = (conversation) => {
   if (firstUserText === null) {
     return void 0;
   }
-  if (firstUserText === "Caveat: The messages below were generated by the user while running local commands. DO NOT respond to these messages or otherwise consider them in your response unless the user explicitly asks you to.") {
+  if (isLocalCommandCaveat(firstUserText)) {
     return void 0;
   }
   if (firstUserText === "Warmup") {
     return void 0;
   }
   const command = parseUserMessage(firstUserText);
-  if (command.kind === "local-command") {
-    return void 0;
-  }
   if (command.kind === "command" && ignoreCommands.includes(command.commandName)) {
     return void 0;
   }
@@ -2295,7 +2302,10 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
         const getFirstUserMessage = (jsonlFilePath, lines) => Effect20.gen(function* () {
           const cached = yield* firstUserMessageCache.get(jsonlFilePath);
           if (cached !== void 0) {
-            return cached;
+            if (cached !== null && cached.kind === "text" && isLocalCommandCaveat(cached.content)) {
+            } else {
+              return cached;
+            }
           }
           let firstUserMessage = null;
           for (const line of lines) {
@@ -2411,7 +2421,7 @@ var LayerImpl13 = Effect21.gen(function* () {
       const content = yield* fs.readFileString(sessionPath);
       const allLines = content.split("\n").filter((line) => line.trim());
       const conversations = parseJsonl(allLines.join("\n"));
-      const stat = yield* fs.stat(sessionPath);
+      const stat2 = yield* fs.stat(sessionPath);
       const meta = yield* sessionMetaService.getSessionMeta(
         projectId,
         sessionId
@@ -2440,7 +2450,7 @@ var LayerImpl13 = Effect21.gen(function* () {
         jsonlFilePath: sessionPath,
         meta,
         conversations: isBroken ? conversations : mergedConversations,
-        lastModifiedAt: Option3.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date())
+        lastModifiedAt: Option3.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date())
       };
       return sessionDetail2;
     }) : (() => {
@@ -2504,16 +2514,16 @@ var LayerImpl13 = Effect21.gen(function* () {
       (entry) => Effect21.gen(function* () {
         const fullPath = path.resolve(claudeProjectPath, entry);
         const sessionId = encodeSessionId(fullPath);
-        const stat = yield* Effect21.tryPromise(
+        const stat2 = yield* Effect21.tryPromise(
           () => fs.stat(fullPath).pipe(Effect21.runPromise)
         ).pipe(Effect21.catchAll(() => Effect21.succeed(null)));
-        if (!stat) {
+        if (!stat2) {
           return null;
         }
         return {
           id: sessionId,
           jsonlFilePath: fullPath,
-          lastModifiedAt: Option3.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date())
+          lastModifiedAt: Option3.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date())
         };
       })
     );
@@ -2698,42 +2708,6 @@ var createMessageGenerator = () => {
   };
 };
 
-// src/server/core/claude-code/functions/fallbackSdkMessage.ts
-var fallbackSdkMessage = (message) => {
-  if (message.type === "system") {
-    if (message.subtype === "init") {
-      return {
-        ...message,
-        plugins: []
-      };
-    }
-    if (message.subtype === "hook_response") {
-      return {
-        ...message
-      };
-    }
-    return message;
-  }
-  if (message.type === "result") {
-    if (message.subtype === "success") {
-      return {
-        ...message,
-        modelUsage: {
-          ...message.modelUsage
-        }
-      };
-    }
-    return {
-      ...message,
-      errors: [],
-      modelUsage: {
-        ...message.modelUsage
-      }
-    };
-  }
-  return message;
-};
-
 // src/server/core/claude-code/models/CCSessionProcess.ts
 import { Effect as Effect22 } from "effect";
 var isPublic = (process2) => {
@@ -2791,10 +2765,10 @@ var LayerImpl14 = Effect23.gen(function* () {
   const processesRef = yield* Ref8.make([]);
   const eventBus = yield* EventBus;
   const startSessionProcess = (options) => {
-    const { sessionDef, taskDef } = options;
+    const { sessionDef, turnDef } = options;
     return Effect23.gen(function* () {
       const task = {
-        def: taskDef,
+        def: turnDef,
         status: "pending"
       };
       const newProcess = {
@@ -2829,13 +2803,13 @@ var LayerImpl14 = Effect23.gen(function* () {
         return yield* Effect23.fail(
           new SessionProcessAlreadyAliveError({
             sessionProcessId,
-            aliveTaskId: firstAliveTask.def.taskId,
+            aliveTaskId: firstAliveTask.def.turnId,
             aliveTaskSessionId: firstAliveTask.def.sessionId ?? firstAliveTask.sessionId
           })
         );
       }
       const newTask = {
-        def: options.taskDef,
+        def: options.turnDef,
         status: "pending"
       };
       const newProcess = {
@@ -2875,11 +2849,11 @@ var LayerImpl14 = Effect23.gen(function* () {
       return processes;
     });
   };
-  const getTask = (taskId) => {
+  const getTask = (turnId) => {
     return Effect23.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const result = processes.flatMap((p) => {
-        const found = p.tasks.find((t) => t.def.taskId === taskId);
+        const found = p.tasks.find((t) => t.def.turnId === turnId);
         if (found === void 0) {
           return [];
         }
@@ -2891,7 +2865,7 @@ var LayerImpl14 = Effect23.gen(function* () {
         ];
       }).at(0);
       if (result === void 0) {
-        return yield* Effect23.fail(new TaskNotFoundError({ taskId }));
+        return yield* Effect23.fail(new TaskNotFoundError({ turnId }));
       }
       return result;
     });
@@ -2925,21 +2899,21 @@ var LayerImpl14 = Effect23.gen(function* () {
       return nextState;
     });
   };
-  const changeTaskState = (options) => {
-    const { sessionProcessId, taskId, nextTask } = options;
+  const changeTurnState = (options) => {
+    const { sessionProcessId, turnId, nextTask } = options;
     return Effect23.gen(function* () {
-      const { task } = yield* getTask(taskId);
+      const { task } = yield* getTask(turnId);
       yield* Ref8.update(processesRef, (processes) => {
         return processes.map(
           (p) => p.def.sessionProcessId === sessionProcessId ? {
             ...p,
             tasks: p.tasks.map(
-              (t) => t.def.taskId === task.def.taskId ? { ...nextTask } : t
+              (t) => t.def.turnId === task.def.turnId ? { ...nextTask } : t
             )
           } : p
         );
       });
-      const updated = yield* getTask(taskId);
+      const updated = yield* getTask(turnId);
       if (updated === void 0) {
         throw new Error("Unreachable: updatedProcess is undefined");
       }
@@ -2958,9 +2932,9 @@ var LayerImpl14 = Effect23.gen(function* () {
           })
         );
       }
-      const newTask = yield* changeTaskState({
+      const newTask = yield* changeTurnState({
         sessionProcessId,
-        taskId: currentProcess.currentTask.def.taskId,
+        turnId: currentProcess.currentTask.def.turnId,
         nextTask: {
           status: "running",
           def: currentProcess.currentTask.def
@@ -3044,7 +3018,7 @@ var LayerImpl14 = Effect23.gen(function* () {
     const { sessionProcessId, resultMessage } = options;
     return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
-      if (currentProcess.type !== "file_created") {
+      if (currentProcess.type !== "file_created" && currentProcess.type !== "initialized") {
         return yield* Effect23.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
@@ -3052,9 +3026,9 @@ var LayerImpl14 = Effect23.gen(function* () {
           })
         );
       }
-      const newTask = yield* changeTaskState({
+      const newTask = yield* changeTurnState({
         sessionProcessId,
-        taskId: currentProcess.currentTask.def.taskId,
+        turnId: currentProcess.currentTask.def.turnId,
         nextTask: {
           status: "completed",
           def: currentProcess.currentTask.def,
@@ -3067,7 +3041,7 @@ var LayerImpl14 = Effect23.gen(function* () {
           type: "paused",
           def: currentProcess.def,
           tasks: currentProcess.tasks.map(
-            (t) => t.def.taskId === newTask.def.taskId ? newTask : t
+            (t) => t.def.turnId === newTask.def.turnId ? newTask : t
           ),
           sessionId: currentProcess.sessionId
         }
@@ -3092,9 +3066,9 @@ var LayerImpl14 = Effect23.gen(function* () {
         sessionId: currentProcess.sessionId
       } : void 0;
       if (newTask !== void 0) {
-        yield* changeTaskState({
+        yield* changeTurnState({
           sessionProcessId,
-          taskId: newTask.def.taskId,
+          turnId: newTask.def.turnId,
           nextTask: newTask
         });
       }
@@ -3104,7 +3078,7 @@ var LayerImpl14 = Effect23.gen(function* () {
           type: "completed",
           def: currentProcess.def,
           tasks: newTask !== void 0 ? currentProcess.tasks.map(
-            (t) => t.def.taskId === newTask.def.taskId ? newTask : t
+            (t) => t.def.turnId === newTask.def.turnId ? newTask : t
           ) : currentProcess.tasks,
           sessionId: currentProcess.sessionId
         }
@@ -3129,7 +3103,7 @@ var LayerImpl14 = Effect23.gen(function* () {
     getSessionProcess,
     // task
     getTask,
-    changeTaskState
+    changeTurnState
   };
 });
 var ClaudeCodeSessionProcessService = class extends Context17.Tag(
@@ -3148,16 +3122,16 @@ var LayerImpl15 = Effect24.gen(function* () {
   const virtualConversationDatabase = yield* VirtualConversationDatabase;
   const permissionService = yield* ClaudeCodePermissionService;
   const runtime = yield* Effect24.runtime();
-  const continueTask = (options) => {
+  const continueSessionProcess = (options) => {
     const { sessionProcessId, baseSessionId, input } = options;
     return Effect24.gen(function* () {
       const { sessionProcess, task } = yield* sessionProcessService.continueSessionProcess({
         sessionProcessId,
-        taskDef: {
+        turnDef: {
           type: "continue",
           sessionId: baseSessionId,
           baseSessionId,
-          taskId: ulid2()
+          turnId: ulid2()
         }
       });
       const virtualConversation = yield* createVirtualConversation(sessionProcess, {
@@ -3180,8 +3154,8 @@ var LayerImpl15 = Effect24.gen(function* () {
       };
     });
   };
-  const startTask = (options) => {
-    const { baseSession, input, userConfig } = options;
+  const startSessionProcess = (options) => {
+    const { projectId, cwd, input, userConfig, baseSession, ccOptions } = options;
     return Effect24.gen(function* () {
       const {
         generateMessages,
@@ -3190,20 +3164,28 @@ var LayerImpl15 = Effect24.gen(function* () {
       } = createMessageGenerator();
       const { sessionProcess, task } = yield* sessionProcessService.startSessionProcess({
         sessionDef: {
-          projectId: baseSession.projectId,
-          cwd: baseSession.cwd,
+          projectId,
+          cwd,
           abortController: new AbortController(),
           setNextMessage,
           sessionProcessId: ulid2()
         },
-        taskDef: baseSession.sessionId === void 0 ? {
+        turnDef: baseSession === void 0 ? {
           type: "new",
-          taskId: ulid2()
+          turnId: ulid2(),
+          ccOptions
+        } : baseSession.type === "fork" ? {
+          type: "fork",
+          turnId: ulid2(),
+          sessionId: baseSession.sessionId,
+          baseSessionId: baseSession.sessionId,
+          ccOptions
         } : {
           type: "resume",
-          taskId: ulid2(),
+          turnId: ulid2(),
           sessionId: void 0,
-          baseSessionId: baseSession.sessionId
+          baseSessionId: baseSession.sessionId,
+          ccOptions
         }
       });
       const sessionInitializedPromise = controllablePromise();
@@ -3222,6 +3204,9 @@ var LayerImpl15 = Effect24.gen(function* () {
         const processState = yield* sessionProcessService.getSessionProcess(
           sessionProcess.def.sessionProcessId
         );
+        if (sessionProcess.def.abortController.signal.aborted) {
+          return "break";
+        }
         if (processState.type === "completed") {
           return "break";
         }
@@ -3243,7 +3228,7 @@ var LayerImpl15 = Effect24.gen(function* () {
           });
           if (processState.currentTask.def.type === "new") {
             yield* virtualConversationDatabase.createVirtualConversation(
-              baseSession.projectId,
+              projectId,
               message.session_id,
               [virtualConversation]
             );
@@ -3287,15 +3272,17 @@ var LayerImpl15 = Effect24.gen(function* () {
             message.session_id
           );
         }
-        if (message.type === "result" && processState.type === "file_created") {
-          yield* sessionProcessService.toPausedState({
-            sessionProcessId: processState.def.sessionProcessId,
-            resultMessage: message
-          });
-          yield* eventBusService.emit("sessionChanged", {
-            projectId: processState.def.projectId,
-            sessionId: message.session_id
-          });
+        if (message.type === "result") {
+          if (processState.type === "file_created" || processState.type === "initialized") {
+            yield* sessionProcessService.toPausedState({
+              sessionProcessId: processState.def.sessionProcessId,
+              resultMessage: message
+            });
+            yield* eventBusService.emit("sessionChanged", {
+              projectId: processState.def.projectId,
+              sessionId: message.session_id
+            });
+          }
           return "continue";
         }
         return "continue";
@@ -3304,32 +3291,29 @@ var LayerImpl15 = Effect24.gen(function* () {
         const messageIter = await Runtime2.runPromise(runtime)(
           Effect24.gen(function* () {
             const permissionOptions = yield* permissionService.createCanUseToolRelatedOptions({
-              taskId: task.def.taskId,
+              turnId: task.def.turnId,
               userConfig,
               sessionId: task.def.baseSessionId
             });
-            return yield* query3(generateMessages(), {
+            return yield* query2(generateMessages(), {
+              ...task.def.type === "continue" ? {} : task.def.ccOptions,
+              ...permissionOptions,
               resume: task.def.baseSessionId,
               cwd: sessionProcess.def.cwd,
-              abortController: sessionProcess.def.abortController,
-              ...permissionOptions
+              abortController: sessionProcess.def.abortController
             });
           })
         );
         setNextMessage(input);
         try {
           for await (const message of messageIter) {
-            if (sessionProcess.def.abortController.signal.aborted) {
-              break;
-            }
-            const fallbackMessage = fallbackSdkMessage(message);
             const result = await Runtime2.runPromise(runtime)(
-              handleMessage(fallbackMessage)
+              handleMessage(message)
             ).catch((error) => {
               Effect24.runFork(
-                sessionProcessService.changeTaskState({
+                sessionProcessService.changeTurnState({
                   sessionProcessId: sessionProcess.def.sessionProcessId,
-                  taskId: task.def.taskId,
+                  turnId: task.def.turnId,
                   nextTask: {
                     status: "failed",
                     def: task.def,
@@ -3358,9 +3342,9 @@ var LayerImpl15 = Effect24.gen(function* () {
             sessionFileCreatedPromise.reject(error);
           }
           await Effect24.runPromise(
-            sessionProcessService.changeTaskState({
+            sessionProcessService.changeTurnState({
               sessionProcessId: sessionProcess.def.sessionProcessId,
-              taskId: task.def.taskId,
+              turnId: task.def.turnId,
               nextTask: {
                 status: "failed",
                 def: task.def,
@@ -3424,8 +3408,8 @@ var LayerImpl15 = Effect24.gen(function* () {
     }
   });
   return {
-    continueTask,
-    startTask,
+    continueSessionProcess,
+    startSessionProcess,
     abortTask,
     abortAllTasks,
     getPublicSessionProcesses
@@ -3461,7 +3445,7 @@ var LayerImpl16 = Effect25.gen(function* () {
     };
   });
   const createSessionProcess = (options) => Effect25.gen(function* () {
-    const { projectId, input, baseSessionId } = options;
+    const { projectId, input, baseSession, ccOptions } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     const userConfig = yield* userConfigService.getUserConfig();
     if (project.meta.projectPath === null) {
@@ -3470,14 +3454,13 @@ var LayerImpl16 = Effect25.gen(function* () {
         status: 400
       };
     }
-    const result = yield* claudeCodeLifeCycleService.startTask({
-      baseSession: {
-        cwd: project.meta.projectPath,
-        projectId,
-        sessionId: baseSessionId
-      },
+    const result = yield* claudeCodeLifeCycleService.startSessionProcess({
+      projectId,
+      cwd: project.meta.projectPath,
+      baseSession,
       userConfig,
-      input
+      input,
+      ccOptions
     });
     const { sessionId } = yield* result.yieldSessionInitialized();
     return {
@@ -3500,7 +3483,7 @@ var LayerImpl16 = Effect25.gen(function* () {
         status: 400
       };
     }
-    const result = yield* claudeCodeLifeCycleService.continueTask({
+    const result = yield* claudeCodeLifeCycleService.continueSessionProcess({
       sessionProcessId,
       input,
       baseSessionId
@@ -3538,8 +3521,8 @@ var adaptInternalEventToSSE = (rawStream, options) => {
   const { timeout = 60 * 1e3, cleanUp } = options ?? {};
   const abortController = new AbortController();
   let connectionResolve;
-  const connectionPromise = new Promise((resolve7) => {
-    connectionResolve = resolve7;
+  const connectionPromise = new Promise((resolve8) => {
+    connectionResolve = resolve8;
   });
   const closeConnection = () => {
     connectionResolve?.();
@@ -4030,6 +4013,272 @@ var getFileCompletion = async (projectPath, basePath = "/") => {
   }
 };
 
+// src/server/core/file-system/functions/getFileContent.ts
+import { readFile, stat } from "node:fs/promises";
+import { extname as extname2, normalize, resolve as resolve5 } from "node:path";
+var DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Images
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "bmp",
+  "ico",
+  "webp",
+  "svg",
+  "tiff",
+  "tif",
+  // Archives
+  "zip",
+  "tar",
+  "gz",
+  "bz2",
+  "7z",
+  "rar",
+  "xz",
+  // Executables
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "bin",
+  // Documents
+  "pdf",
+  "doc",
+  "docx",
+  "xls",
+  "xlsx",
+  "ppt",
+  "pptx",
+  // Media
+  "mp3",
+  "mp4",
+  "avi",
+  "mov",
+  "mkv",
+  "wav",
+  "flac",
+  // Database
+  "db",
+  "sqlite",
+  "sqlite3",
+  // Other
+  "wasm",
+  "ttf",
+  "otf",
+  "woff",
+  "woff2",
+  "eot"
+]);
+var EXTENSION_TO_LANGUAGE = {
+  ts: "typescript",
+  tsx: "tsx",
+  js: "javascript",
+  jsx: "jsx",
+  mjs: "javascript",
+  cjs: "javascript",
+  json: "json",
+  jsonc: "json",
+  md: "markdown",
+  mdx: "markdown",
+  py: "python",
+  rs: "rust",
+  go: "go",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "scss",
+  sass: "sass",
+  less: "less",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  xml: "xml",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  fish: "fish",
+  ps1: "powershell",
+  sql: "sql",
+  graphql: "graphql",
+  gql: "graphql",
+  java: "java",
+  kt: "kotlin",
+  kts: "kotlin",
+  scala: "scala",
+  rb: "ruby",
+  php: "php",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  cc: "cpp",
+  cxx: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  swift: "swift",
+  m: "objectivec",
+  mm: "objectivec",
+  r: "r",
+  lua: "lua",
+  vim: "vim",
+  dockerfile: "dockerfile",
+  makefile: "makefile",
+  cmake: "cmake",
+  tf: "hcl",
+  hcl: "hcl",
+  proto: "protobuf",
+  prisma: "prisma",
+  vue: "vue",
+  svelte: "svelte",
+  astro: "astro",
+  zig: "zig",
+  elm: "elm",
+  ex: "elixir",
+  exs: "elixir",
+  erl: "erlang",
+  hrl: "erlang",
+  clj: "clojure",
+  cljs: "clojure",
+  cljc: "clojure",
+  hs: "haskell",
+  lhs: "haskell",
+  ml: "ocaml",
+  mli: "ocaml",
+  fs: "fsharp",
+  fsx: "fsharp",
+  fsi: "fsharp",
+  pl: "perl",
+  pm: "perl",
+  nim: "nim",
+  d: "d",
+  dart: "dart",
+  v: "v",
+  sol: "solidity",
+  ini: "ini",
+  cfg: "ini",
+  conf: "ini",
+  env: "shell",
+  gitignore: "gitignore",
+  editorconfig: "editorconfig",
+  txt: "text"
+};
+var detectLanguage = (filePath) => {
+  const ext = extname2(filePath).toLowerCase().slice(1);
+  const basename2 = filePath.split("/").pop() ?? "";
+  const lowerBasename = basename2.toLowerCase();
+  if (lowerBasename === "dockerfile") return "dockerfile";
+  if (lowerBasename === "makefile") return "makefile";
+  if (lowerBasename.startsWith(".env")) return "shell";
+  return EXTENSION_TO_LANGUAGE[ext] ?? "text";
+};
+var isBinaryExtension = (filePath) => {
+  const ext = extname2(filePath).toLowerCase().slice(1);
+  return BINARY_EXTENSIONS.has(ext);
+};
+var isBinaryContent = (buffer) => {
+  const checkLength = Math.min(buffer.length, 8192);
+  for (let i = 0; i < checkLength; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+};
+var validateFilePath = (projectRoot, filePath) => {
+  if (!filePath || filePath.trim() === "") {
+    return { valid: false, message: "File path cannot be empty" };
+  }
+  if (filePath.includes("\0")) {
+    return { valid: false, message: "File path contains invalid characters" };
+  }
+  if (filePath.includes("..")) {
+    return { valid: false, message: "Path traversal (..) is not allowed" };
+  }
+  const resolvedRoot = resolve5(projectRoot);
+  let resolvedPath;
+  if (filePath.startsWith("/")) {
+    resolvedPath = normalize(filePath);
+  } else {
+    const normalizedPath = normalize(filePath);
+    resolvedPath = resolve5(projectRoot, normalizedPath);
+  }
+  if (!resolvedPath.startsWith(`${resolvedRoot}/`) && resolvedPath !== resolvedRoot) {
+    return { valid: false, message: "Path is outside the project root" };
+  }
+  return { valid: true, resolvedPath };
+};
+var getFileContent = async (projectRoot, filePath, options = {}) => {
+  const { maxFileSize = DEFAULT_MAX_FILE_SIZE } = options;
+  const validation = validateFilePath(projectRoot, filePath);
+  if (!validation.valid) {
+    return {
+      success: false,
+      error: "INVALID_PATH",
+      message: validation.message,
+      filePath
+    };
+  }
+  const { resolvedPath } = validation;
+  if (isBinaryExtension(filePath)) {
+    return {
+      success: false,
+      error: "BINARY_FILE",
+      message: "Binary file cannot be displayed",
+      filePath
+    };
+  }
+  try {
+    const fileStat = await stat(resolvedPath);
+    if (!fileStat.isFile()) {
+      return {
+        success: false,
+        error: "NOT_FOUND",
+        message: "File not found or is a directory",
+        filePath
+      };
+    }
+    const buffer = await readFile(resolvedPath);
+    if (isBinaryContent(buffer)) {
+      return {
+        success: false,
+        error: "BINARY_FILE",
+        message: "Binary file cannot be displayed",
+        filePath
+      };
+    }
+    let content = buffer.toString("utf-8");
+    const truncated = buffer.length > maxFileSize;
+    if (truncated) {
+      const truncatedBuffer = buffer.subarray(0, maxFileSize);
+      content = truncatedBuffer.toString("utf-8");
+    }
+    const language = detectLanguage(filePath);
+    return {
+      success: true,
+      content,
+      filePath,
+      truncated,
+      language
+    };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return {
+        success: false,
+        error: "NOT_FOUND",
+        message: "File not found",
+        filePath
+      };
+    }
+    return {
+      success: false,
+      error: "READ_ERROR",
+      message: error instanceof Error ? error.message : "Failed to read file",
+      filePath
+    };
+  }
+};
+
 // src/server/core/file-system/presentation/FileSystemController.ts
 var LayerImpl19 = Effect30.gen(function* () {
   const projectRepository = yield* ProjectRepository;
@@ -4083,9 +4332,40 @@ var LayerImpl19 = Effect30.gen(function* () {
       };
     }
   });
+  const getFileContentRoute = (options) => Effect30.gen(function* () {
+    const { projectId, filePath } = options;
+    const { project } = yield* projectRepository.getProject(projectId);
+    if (project.meta.projectPath === null) {
+      return {
+        response: {
+          success: false,
+          error: "PROJECT_PATH_NOT_SET",
+          message: "Project path is not configured. Cannot read files without a project root.",
+          filePath
+        },
+        status: 400
+      };
+    }
+    const projectPath = project.meta.projectPath;
+    const result = yield* Effect30.promise(
+      () => getFileContent(projectPath, filePath)
+    );
+    if (!result.success) {
+      const statusCode = result.error === "NOT_FOUND" ? 404 : 400;
+      return {
+        response: result,
+        status: statusCode
+      };
+    }
+    return {
+      response: result,
+      status: 200
+    };
+  });
   return {
     getFileCompletionRoute,
-    getDirectoryListingRoute
+    getDirectoryListingRoute,
+    getFileContentRoute
   };
 });
 var FileSystemController = class extends Context24.Tag("FileSystemController")() {
@@ -4098,8 +4378,8 @@ var FileSystemController = class extends Context24.Tag("FileSystemController")()
 import { Context as Context27, Effect as Effect33, Either as Either2, Layer as Layer29 } from "effect";
 
 // src/server/core/git/functions/getDiff.ts
-import { readFile } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 import parseGitDiff from "parse-git-diff";
 
 // src/server/core/git/functions/utils.ts
@@ -4296,8 +4576,8 @@ async function getUntrackedFiles(cwd) {
 }
 async function createUntrackedFileDiff(cwd, filePath) {
   try {
-    const fullPath = resolve5(cwd, filePath);
-    const content = await readFile(fullPath, "utf8");
+    const fullPath = resolve6(cwd, filePath);
+    const content = await readFile2(fullPath, "utf8");
     const lines = content.split("\n");
     const diffLines = lines.map((line, index) => ({
       type: "added",
@@ -4444,9 +4724,13 @@ import { Context as Context25, Effect as Effect31, Layer as Layer27, Ref as Ref1
 import { z as z23 } from "zod";
 var envSchema = z23.object({
   // Frameworks
-  NODE_ENV: z23.enum(["development", "production", "test"]).optional().default("development"),
+  CCV_ENV: z23.enum(["development", "production", "test"]).optional().default("development"),
   NEXT_PHASE: z23.string().optional(),
-  PATH: z23.string().optional()
+  PATH: z23.string().optional(),
+  SHELL: z23.string().optional(),
+  CCV_TERMINAL_SHELL: z23.string().optional(),
+  CCV_TERMINAL_UNRESTRICTED: z23.string().optional(),
+  CCV_TERMINAL_DISABLED: z23.string().optional()
 });
 
 // src/server/core/platform/services/EnvService.ts
@@ -4477,8 +4761,20 @@ var LayerImpl20 = Effect31.gen(function* () {
       return env[key];
     });
   };
+  const getAllEnv = () => {
+    return Effect31.sync(() => {
+      const entries = [];
+      for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === "string") {
+          entries.push([key, value]);
+        }
+      }
+      return Object.fromEntries(entries);
+    });
+  };
   return {
-    getEnv
+    getEnv,
+    getAllEnv
   };
 });
 var EnvService = class extends Context25.Tag("EnvService")() {
@@ -4832,6 +5128,10 @@ var LayerImpl21 = Effect32.gen(function* () {
     );
     return parseGitCommitsOutput(result);
   });
+  const checkout = (cwd, branchName) => Effect32.gen(function* () {
+    yield* execGitCommand(["checkout", branchName], cwd);
+    return { success: true, branch: branchName };
+  });
   return {
     getBranches,
     getCurrentBranch,
@@ -4845,7 +5145,8 @@ var LayerImpl21 = Effect32.gen(function* () {
     compareCommitHash,
     getCommitsWithParent,
     findBaseBranch,
-    getCommitsBetweenBranches
+    getCommitsBetweenBranches,
+    checkout
   };
 });
 var GitService = class extends Context26.Tag("GitService")() {
@@ -5126,12 +5427,75 @@ var LayerImpl22 = Effect33.gen(function* () {
       status: 200
     };
   });
+  const getBranches = (options) => Effect33.gen(function* () {
+    const { projectId } = options;
+    const { project } = yield* projectRepository.getProject(projectId);
+    if (project.meta.projectPath === null) {
+      return {
+        response: { success: false, error: "Project path not found" },
+        status: 400
+      };
+    }
+    const projectPath = project.meta.projectPath;
+    const branchesResult = yield* Effect33.either(
+      gitService.getBranches(projectPath)
+    );
+    if (Either2.isLeft(branchesResult)) {
+      return {
+        response: { success: false, error: "Failed to get branches" },
+        status: 500
+      };
+    }
+    const currentBranchResult = yield* Effect33.either(
+      gitService.getCurrentBranch(projectPath)
+    );
+    const currentBranch = Either2.isRight(currentBranchResult) ? currentBranchResult.right : null;
+    return {
+      response: {
+        success: true,
+        data: {
+          branches: branchesResult.right.data,
+          currentBranch
+        }
+      },
+      status: 200
+    };
+  });
+  const checkoutBranch = (options) => Effect33.gen(function* () {
+    const { projectId, branchName } = options;
+    const { project } = yield* projectRepository.getProject(projectId);
+    if (project.meta.projectPath === null) {
+      return {
+        response: { success: false, error: "Project path not found" },
+        status: 400
+      };
+    }
+    const projectPath = project.meta.projectPath;
+    const checkoutResult = yield* Effect33.either(
+      gitService.checkout(projectPath, branchName)
+    );
+    if (Either2.isLeft(checkoutResult)) {
+      return {
+        response: { success: false, error: "Failed to checkout branch" },
+        status: 500
+      };
+    }
+    return {
+      response: {
+        success: true,
+        branch: checkoutResult.right.branch
+      },
+      status: 200
+    };
+  });
   return {
     getGitDiff,
     commitFiles,
     pushCommits,
     commitAndPush,
-    getCurrentRevisions
+    getCurrentRevisions,
+    getBranches,
+    checkoutBranch
   };
 });
 function parsePushError(stderr) {
@@ -5171,6 +5535,9 @@ var GitController = class extends Context27.Tag("GitController")() {
   }
 };
 
+// src/server/core/platform/ccvEnv.ts
+var isDevelopmentEnv = (ccvEnv) => ccvEnv === "development";
+
 // src/server/core/project/presentation/ProjectController.ts
 import { FileSystem as FileSystem11, Path as Path15 } from "@effect/platform";
 import { Context as Context28, Effect as Effect35, Layer as Layer30 } from "effect";
@@ -5279,12 +5646,10 @@ var LayerImpl23 = Effect35.gen(function* () {
     const userConfig = yield* userConfigService.getUserConfig();
     const claudeMdPath = path.join(projectPath, "CLAUDE.md");
     const claudeMdExists = yield* fileSystem.exists(claudeMdPath);
-    const result = yield* claudeCodeLifeCycleService.startTask({
-      baseSession: {
-        cwd: projectPath,
-        projectId,
-        sessionId: void 0
-      },
+    const result = yield* claudeCodeLifeCycleService.startSessionProcess({
+      projectId,
+      cwd: projectPath,
+      baseSession: void 0,
       userConfig,
       input: {
         text: claudeMdExists ? "describe this project" : "/init"
@@ -5340,7 +5705,17 @@ var scheduleSchema = z24.discriminatedUnion("type", [
 var messageConfigSchema = z24.object({
   content: z24.string(),
   projectId: z24.string(),
-  baseSessionId: z24.string().nullable()
+  baseSession: z24.union([
+    z24.null(),
+    z24.object({
+      type: z24.literal("fork"),
+      sessionId: z24.string()
+    }),
+    z24.object({
+      type: z24.literal("resume"),
+      sessionId: z24.string()
+    })
+  ])
 });
 var jobStatusSchema = z24.enum(["success", "failed"]);
 var schedulerJobSchema = z24.object({
@@ -5475,12 +5850,10 @@ var executeJob = (job) => Effect37.gen(function* () {
       new Error(`Project path not found for projectId: ${message.projectId}`)
     );
   }
-  yield* lifeCycleService.startTask({
-    baseSession: {
-      cwd: project.meta.projectPath,
-      projectId: message.projectId,
-      sessionId: message.baseSessionId ?? void 0
-    },
+  yield* lifeCycleService.startSessionProcess({
+    projectId: message.projectId,
+    cwd: project.meta.projectPath,
+    baseSession: message.baseSession ?? void 0,
     userConfig,
     input: {
       text: message.content
@@ -5938,7 +6311,7 @@ var LayerImpl25 = Effect40.gen(function* () {
   const hasExistingReservedJobForSession = (sessionId) => Effect40.gen(function* () {
     const jobs = yield* schedulerService.getJobs().pipe(Effect40.catchAll(() => Effect40.succeed([])));
     return jobs.some(
-      (job) => job.schedule.type === "reserved" && job.message.baseSessionId === sessionId && job.lastRunStatus === null
+      (job) => job.schedule.type === "reserved" && job.message.baseSession?.sessionId === sessionId && job.lastRunStatus === null
       // Not yet executed
     );
   });
@@ -5981,7 +6354,10 @@ var LayerImpl25 = Effect40.gen(function* () {
       message: {
         content: "continue",
         projectId: processProjectId,
-        baseSessionId: sessionId
+        baseSession: {
+          type: "resume",
+          sessionId
+        }
       },
       enabled: true
     }).pipe(
@@ -6178,8 +6554,8 @@ var LayerImpl27 = Effect42.gen(function* () {
     const documentEffects = projectEntries.map(
       (projectEntry) => Effect42.gen(function* () {
         const projectPath = path.resolve(claudeProjectsDirPath, projectEntry);
-        const stat = yield* fs.stat(projectPath).pipe(Effect42.catchAll(() => Effect42.succeed(null)));
-        if (stat?.type !== "Directory") {
+        const stat2 = yield* fs.stat(projectPath).pipe(Effect42.catchAll(() => Effect42.succeed(null)));
+        if (stat2?.type !== "Directory") {
           return [];
         }
         const projectId = encodeProjectId(projectPath);
@@ -6247,14 +6623,14 @@ var LayerImpl27 = Effect42.gen(function* () {
     yield* Ref13.set(indexCacheRef, { index, documents, builtAt: now });
     return { index, documents };
   });
-  const search = (query4, limit = 20, projectId) => Effect42.gen(function* () {
+  const search = (query3, limit = 20, projectId) => Effect42.gen(function* () {
     const { claudeProjectsDirPath } = yield* context.claudeCodePaths;
     const dirExists = yield* fs.exists(claudeProjectsDirPath);
     if (!dirExists) {
       return { results: [] };
     }
     const { index: miniSearch, documents } = yield* getIndex();
-    const searchResults = miniSearch.search(query4).slice(0, limit * 2);
+    const searchResults = miniSearch.search(query3).slice(0, limit * 2);
     const results = [];
     for (const result of searchResults) {
       if (results.length >= limit) break;
@@ -6264,7 +6640,7 @@ var LayerImpl27 = Effect42.gen(function* () {
       const score = doc.type === "user" ? result.score * 1.2 : result.score;
       const snippetLength = 150;
       const text = doc.text;
-      const queryLower = query4.toLowerCase();
+      const queryLower = query3.toLowerCase();
       const textLower = text.toLowerCase();
       const matchIndex = textLower.indexOf(queryLower);
       let snippet;
@@ -6304,8 +6680,8 @@ var SearchService = class extends Context33.Tag("SearchService")() {
 var LayerImpl28 = Effect43.gen(function* () {
   const searchService = yield* SearchService;
   const search = (options) => Effect43.gen(function* () {
-    const { query: query4, limit, projectId } = options;
-    if (query4.trim().length < 2) {
+    const { query: query3, limit, projectId } = options;
+    if (query3.trim().length < 2) {
       return {
         status: 400,
         response: {
@@ -6314,7 +6690,7 @@ var LayerImpl28 = Effect43.gen(function* () {
       };
     }
     const { results } = yield* searchService.search(
-      query4.trim(),
+      query3.trim(),
       limit,
       projectId
     );
@@ -8143,7 +8519,7 @@ var TasksService = class extends Context36.Tag("TasksService")() {
             candidates.map(
               (file) => Effect46.gen(function* () {
                 const fullPath = path.join(projectMetaDir, file);
-                const stat = yield* fs.stat(fullPath);
+                const stat2 = yield* fs.stat(fullPath);
                 const match = file.match(uuidPattern);
                 const uuid = match ? match[0] : file;
                 const tasksPath = path.join(claudeDir, TASKS_DIR_NAME, uuid);
@@ -8151,7 +8527,7 @@ var TasksService = class extends Context36.Tag("TasksService")() {
                 return {
                   file,
                   uuid,
-                  mtime: Option4.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date(0)),
+                  mtime: Option4.getOrElse(stat2.mtime, () => /* @__PURE__ */ new Date(0)),
                   hasTasks
                 };
               })
@@ -8266,21 +8642,21 @@ var TasksService = class extends Context36.Tag("TasksService")() {
           }
           return tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
         });
-        const getTask = (projectPath, taskId, specificSessionId) => Effect46.gen(function* () {
+        const getTask = (projectPath, turnId, specificSessionId) => Effect46.gen(function* () {
           const tasksDir = yield* getTasksDirOrFail(
             projectPath,
             specificSessionId
           );
-          const taskFile = path.join(tasksDir, `${taskId}.json`);
+          const taskFile = path.join(tasksDir, `${turnId}.json`);
           const exists = yield* fs.exists(taskFile);
           if (!exists) {
-            return yield* Effect46.fail(new Error(`Task ${taskId} not found`));
+            return yield* Effect46.fail(new Error(`Task ${turnId} not found`));
           }
           const content = yield* fs.readFileString(taskFile);
           const task = JSON.parse(content);
           return yield* Effect46.try(() => TaskSchema.parse(task));
         });
-        const createTask = (projectPath, taskDef, specificSessionId) => Effect46.gen(function* () {
+        const createTask = (projectPath, turnDef, specificSessionId) => Effect46.gen(function* () {
           const tasksDir = yield* getTasksDirOrFail(
             projectPath,
             specificSessionId
@@ -8306,7 +8682,7 @@ var TasksService = class extends Context36.Tag("TasksService")() {
             status: "pending",
             blocks: [],
             blockedBy: [],
-            ...taskDef
+            ...turnDef
           };
           const filePath = path.join(tasksDir, `${newId}.json`);
           yield* fs.writeFileString(filePath, JSON.stringify(newTask, null, 2));
@@ -8380,87 +8756,398 @@ var TasksController = class extends Context37.Tag("TasksController")() {
   }
 };
 
-// src/server/hono/app.ts
-import { Hono } from "hono";
-var honoApp = new Hono();
+// src/server/core/terminal/TerminalService.ts
+import { Context as Context38, Effect as Effect48, Layer as Layer40 } from "effect";
+import { ulid as ulid5 } from "ulid";
 
-// src/server/hono/initialize.ts
-import { Context as Context38, Effect as Effect48, Layer as Layer40, Ref as Ref14, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context38.Tag("InitializeService")() {
-  static {
-    this.Live = Layer40.effect(
-      this,
-      Effect48.gen(function* () {
-        const eventBus = yield* EventBus;
-        const fileWatcher = yield* FileWatcherService;
-        const projectRepository = yield* ProjectRepository;
-        const sessionRepository = yield* SessionRepository;
-        const projectMetaService = yield* ProjectMetaService;
-        const sessionMetaService = yield* SessionMetaService;
-        const virtualConversationDatabase = yield* VirtualConversationDatabase;
-        const rateLimitAutoScheduleService = yield* RateLimitAutoScheduleService;
-        const listenersRef = yield* Ref14.make({});
-        const startInitialization = () => {
-          return Effect48.gen(function* () {
-            yield* fileWatcher.startWatching();
-            yield* rateLimitAutoScheduleService.start();
-            const daemon = Effect48.repeat(
-              eventBus.emit("heartbeat", {}),
-              Schedule2.fixed("10 seconds")
-            );
-            console.log("start heartbeat");
-            yield* Effect48.forkDaemon(daemon);
-            console.log("after starting heartbeat fork");
-            const onSessionChanged = (event) => {
-              Effect48.runFork(
-                projectMetaService.invalidateProject(event.projectId)
-              );
-              Effect48.runFork(
-                sessionMetaService.invalidateSession(
-                  event.projectId,
-                  event.sessionId
-                )
-              );
-            };
-            const onSessionProcessChanged = (event) => {
-              if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect48.runFork(
-                  virtualConversationDatabase.deleteVirtualConversations(
-                    event.changed.sessionId
-                  )
-                );
-                return;
-              }
-            };
-            yield* Ref14.set(listenersRef, {
-              sessionChanged: onSessionChanged,
-              sessionProcessChanged: onSessionProcessChanged
-            });
-            yield* eventBus.on("sessionChanged", onSessionChanged);
-            yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect48.gen(function* () {
-              console.log("Initializing projects cache");
-              const { projects } = yield* projectRepository.getProjects();
-              console.log(`${projects.length} projects cache initialized`);
-              console.log("Initializing sessions cache");
-              const results = yield* Effect48.all(
-                projects.map(
-                  (project) => sessionRepository.getSessions(project.id)
-                ),
-                { concurrency: "unbounded" }
-              );
-              const totalSessions = results.reduce(
-                (s, { sessions }) => s + sessions.length,
-                0
-              );
+// src/server/core/terminal/normalizePtyChunk.ts
+var normalizePtyChunk = (chunk) => {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return null;
+};
+
+// src/server/core/terminal/rusptyAdapter.ts
+var createRusptySession = (ruspty, options) => {
+  const pty = new ruspty.Pty(options);
+  return {
+    process: {
+      write: (data) => {
+        pty.write.write(data);
+      },
+      resize: (cols, rows) => {
+        pty.resize({ cols, rows });
+      },
+      kill: () => {
+        pty.close();
+      }
+    },
+    read: pty.read
+  };
+};
+
+// src/server/core/terminal/TerminalService.ts
+var DEFAULT_COLS = 80;
+var DEFAULT_ROWS = 24;
+var MAX_BUFFER_BYTES = 1024 * 1024 * 2;
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+var MAX_SESSIONS = 10;
+var selectShell = (shellEnv, fallbackShell, unrestrictedFlag) => {
+  if (process.platform === "win32") {
+    return { command: "powershell.exe", args: ["-NoLogo"] };
+  }
+  const command = shellEnv ?? fallbackShell ?? "bash";
+  const args = [];
+  if (!unrestrictedFlag && command.toLowerCase().includes("bash")) {
+    args.push("--noprofile", "--norc", "--restricted");
+  }
+  return { command, args };
+};
+var isFlagEnabled2 = (value) => {
+  if (!value) return false;
+  return value === "1" || value.toLowerCase() === "true";
+};
+var LayerImpl30 = Effect48.gen(function* () {
+  const envService = yield* EnvService;
+  const ccvOptionsService = yield* CcvOptionsService;
+  const sessions = /* @__PURE__ */ new Map();
+  const disabledService = (reason) => {
+    const getOrCreateSession2 = (_sessionId, _cwdOverride) => Effect48.fail(new Error(`Terminal support is unavailable (${reason}).`));
+    return {
+      getOrCreateSession: getOrCreateSession2,
+      registerClient: () => Effect48.void,
+      unregisterClient: () => Effect48.void,
+      writeInput: () => Effect48.void,
+      resize: () => Effect48.void,
+      signal: () => Effect48.void,
+      snapshotSince: () => Effect48.succeed(void 0)
+    };
+  };
+  const ruspty = yield* Effect48.tryPromise({
+    try: () => import("@replit/ruspty"),
+    catch: (error) => new Error(`Failed to load @replit/ruspty: ${String(error)}`)
+  }).pipe(
+    Effect48.catchAll(
+      (error) => Effect48.sync(() => {
+        console.warn(error.message);
+        return null;
+      })
+    )
+  );
+  if (!ruspty) {
+    return disabledService("@replit/ruspty failed to load");
+  }
+  const trimBuffer = (session) => {
+    while (session.bufferBytes > MAX_BUFFER_BYTES && session.buffer.length > 0) {
+      const removed = session.buffer.shift();
+      if (removed) {
+        session.bufferBytes -= Buffer.byteLength(removed.data, "utf8");
+      }
+    }
+  };
+  const sendJson2 = (client, payload) => {
+    if (client.readyState !== 1) return;
+    client.send(JSON.stringify(payload));
+  };
+  const broadcast = (session, payload) => {
+    for (const client of session.clients) {
+      sendJson2(client, payload);
+    }
+  };
+  const destroySession = (sessionId) => {
+    const session = sessions.get(sessionId);
+    if (!session) return;
+    sessions.delete(sessionId);
+    session.exited = true;
+    for (const client of session.clients) {
+      if (client.readyState === 1) {
+        client.close(1e3, "Session closed");
+      }
+    }
+    session.clients.clear();
+    session.pty.kill();
+  };
+  const pruneSessions = () => {
+    const now = Date.now();
+    for (const [sessionId, session] of sessions.entries()) {
+      if (session.clients.size > 0) {
+        continue;
+      }
+      if (now - session.lastActivity > SESSION_TTL_MS) {
+        destroySession(sessionId);
+      }
+    }
+    if (sessions.size <= MAX_SESSIONS) return;
+    const sorted = Array.from(sessions.values()).sort(
+      (left, right) => left.lastActivity - right.lastActivity
+    );
+    for (const session of sorted.slice(0, sessions.size - MAX_SESSIONS)) {
+      destroySession(session.id);
+    }
+  };
+  const createSession = (requestedId, options) => {
+    const id = requestedId ?? ulid5();
+    const shell = selectShell(
+      options.shell,
+      options.fallbackShell,
+      options.unrestrictedFlag
+    );
+    const { process: ptyProcess, read } = createRusptySession(ruspty, {
+      command: shell.command,
+      args: shell.args,
+      envs: options.env,
+      dir: options.cwd,
+      size: { cols: DEFAULT_COLS, rows: DEFAULT_ROWS },
+      onExit: (_error, exitCode) => {
+        const current = sessions.get(id);
+        if (!current) return;
+        current.exited = true;
+        current.lastActivity = Date.now();
+        broadcast(current, { type: "exit", code: exitCode });
+        if (current.clients.size === 0) {
+          destroySession(current.id);
+        }
+      }
+    });
+    const session = {
+      id,
+      pty: ptyProcess,
+      seq: 0,
+      buffer: [],
+      bufferBytes: 0,
+      lastActivity: Date.now(),
+      clients: /* @__PURE__ */ new Set(),
+      exited: false,
+      inputBuffer: ""
+    };
+    read.on("data", (chunk) => {
+      const data = normalizePtyChunk(chunk);
+      if (data === null) return;
+      const current = sessions.get(session.id);
+      if (!current || current.exited) return;
+      current.lastActivity = Date.now();
+      current.seq += 1;
+      current.buffer.push({ seq: current.seq, data });
+      current.bufferBytes += Buffer.byteLength(data, "utf8");
+      trimBuffer(current);
+      broadcast(current, {
+        type: "output",
+        seq: current.seq,
+        data
+      });
+    });
+    sessions.set(id, session);
+    return session;
+  };
+  const getSession = (sessionId) => {
+    if (!sessionId) return void 0;
+    return sessions.get(sessionId);
+  };
+  const getOrCreateSession = (sessionId, cwdOverride) => Effect48.gen(function* () {
+    const terminalDisabledEnv = yield* envService.getEnv(
+      "CCV_TERMINAL_DISABLED"
+    );
+    const terminalDisabledOption = yield* ccvOptionsService.getCcvOptions("terminalDisabled");
+    const terminalDisabled = terminalDisabledOption ?? isFlagEnabled2(terminalDisabledEnv);
+    if (terminalDisabled) {
+      return yield* Effect48.fail(
+        new Error(
+          "Terminal support is unavailable (CCV_TERMINAL_DISABLED is enabled)."
+        )
+      );
+    }
+    const cwd = cwdOverride ?? process.cwd();
+    const terminalShellOption = yield* ccvOptionsService.getCcvOptions("terminalShell");
+    const shell = terminalShellOption ?? (yield* envService.getEnv("CCV_TERMINAL_SHELL"));
+    const fallbackShell = yield* envService.getEnv("SHELL");
+    const terminalUnrestrictedOption = yield* ccvOptionsService.getCcvOptions(
+      "terminalUnrestricted"
+    );
+    const terminalUnrestrictedEnv = yield* envService.getEnv(
+      "CCV_TERMINAL_UNRESTRICTED"
+    );
+    const unrestrictedFlag = terminalUnrestrictedOption ?? isFlagEnabled2(terminalUnrestrictedEnv);
+    const env = yield* envService.getAllEnv();
+    const existing = getSession(sessionId);
+    if (existing) {
+      existing.lastActivity = Date.now();
+      return existing;
+    }
+    return createSession(sessionId, {
+      cwd,
+      shell,
+      fallbackShell,
+      unrestrictedFlag,
+      env
+    });
+  });
+  const registerClient = (sessionId, client) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    session.clients.add(client);
+    session.lastActivity = Date.now();
+  });
+  const unregisterClient = (sessionId, client) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    session.clients.delete(client);
+    session.lastActivity = Date.now();
+    if (session.exited && session.clients.size === 0) {
+      destroySession(session.id);
+    }
+  });
+  const writeInput = (sessionId, data) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session || session.exited) return;
+    session.lastActivity = Date.now();
+    const combined = session.inputBuffer + data;
+    const lines = combined.split(/\r\n|\n|\r/);
+    session.inputBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0) {
+        console.log(`[terminal] session ${session.id} command: ${trimmed}`);
+      }
+    }
+    session.pty.write(data);
+  });
+  const resize = (sessionId, cols, rows) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session || session.exited) return;
+    session.lastActivity = Date.now();
+    session.pty.resize(cols, rows);
+  });
+  const signal = (sessionId, name) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session || session.exited) return;
+    session.lastActivity = Date.now();
+    if (name === "SIGINT") {
+      session.pty.write("");
+    }
+  });
+  const snapshotSince = (sessionId, lastSeq) => Effect48.sync(() => {
+    const session = getSession(sessionId);
+    if (!session) return void 0;
+    const chunks = session.buffer.filter((chunk) => chunk.seq > lastSeq);
+    if (chunks.length === 0) return void 0;
+    const data = chunks.map((chunk) => chunk.data).join("");
+    return { seq: session.seq, data };
+  });
+  const cleanupLoop = Effect48.forever(
+    Effect48.gen(function* () {
+      yield* Effect48.sleep("1 minute");
+      pruneSessions();
+    })
+  );
+  yield* Effect48.forkScoped(cleanupLoop);
+  return {
+    getOrCreateSession,
+    registerClient,
+    unregisterClient,
+    writeInput,
+    resize,
+    signal,
+    snapshotSince
+  };
+});
+var TerminalService = class extends Context38.Tag("TerminalService")() {
+  static {
+    this.Live = Layer40.effect(this, LayerImpl30);
+  }
+};
+
+// src/server/hono/app.ts
+import { Hono } from "hono";
+var honoApp = new Hono();
+
+// src/server/hono/initialize.ts
+import { Context as Context39, Effect as Effect49, Layer as Layer41, Ref as Ref14, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context39.Tag("InitializeService")() {
+  static {
+    this.Live = Layer41.effect(
+      this,
+      Effect49.gen(function* () {
+        const eventBus = yield* EventBus;
+        const fileWatcher = yield* FileWatcherService;
+        const projectRepository = yield* ProjectRepository;
+        const sessionRepository = yield* SessionRepository;
+        const projectMetaService = yield* ProjectMetaService;
+        const sessionMetaService = yield* SessionMetaService;
+        const virtualConversationDatabase = yield* VirtualConversationDatabase;
+        const rateLimitAutoScheduleService = yield* RateLimitAutoScheduleService;
+        const listenersRef = yield* Ref14.make({});
+        const startInitialization = () => {
+          return Effect49.gen(function* () {
+            yield* fileWatcher.startWatching();
+            yield* rateLimitAutoScheduleService.start();
+            const daemon = Effect49.repeat(
+              eventBus.emit("heartbeat", {}),
+              Schedule2.fixed("10 seconds")
+            );
+            console.log("start heartbeat");
+            yield* Effect49.forkDaemon(daemon);
+            console.log("after starting heartbeat fork");
+            const onSessionChanged = (event) => {
+              Effect49.runFork(
+                projectMetaService.invalidateProject(event.projectId)
+              );
+              Effect49.runFork(
+                sessionMetaService.invalidateSession(
+                  event.projectId,
+                  event.sessionId
+                )
+              );
+            };
+            const onSessionProcessChanged = (event) => {
+              if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
+                Effect49.runFork(
+                  virtualConversationDatabase.deleteVirtualConversations(
+                    event.changed.sessionId
+                  )
+                );
+                return;
+              }
+            };
+            yield* Ref14.set(listenersRef, {
+              sessionChanged: onSessionChanged,
+              sessionProcessChanged: onSessionProcessChanged
+            });
+            yield* eventBus.on("sessionChanged", onSessionChanged);
+            yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
+            yield* Effect49.gen(function* () {
+              console.log("Initializing projects cache");
+              const { projects } = yield* projectRepository.getProjects();
+              console.log(`${projects.length} projects cache initialized`);
+              console.log("Initializing sessions cache");
+              const results = yield* Effect49.all(
+                projects.map(
+                  (project) => sessionRepository.getSessions(project.id)
+                ),
+                { concurrency: "unbounded" }
+              );
+              const totalSessions = results.reduce(
+                (s, { sessions }) => s + sessions.length,
+                0
+              );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect48.catchAll(() => Effect48.void),
-              Effect48.withSpan("initialize-cache")
+              Effect49.catchAll(() => Effect49.void),
+              Effect49.withSpan("initialize-cache")
             );
-          }).pipe(Effect48.withSpan("start-initialization"));
+          }).pipe(Effect49.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect48.gen(function* () {
+        const stopCleanup = () => Effect49.gen(function* () {
           const listeners = yield* Ref14.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
@@ -8485,221 +9172,101 @@ var InitializeService = class extends Context38.Tag("InitializeService")() {
 };
 
 // src/server/hono/middleware/auth.middleware.ts
-import { Context as Context39, Effect as Effect49, Layer as Layer41 } from "effect";
+import { Context as Context40, Effect as Effect50, Layer as Layer42, Runtime as Runtime3 } from "effect";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 var generateSessionToken = (password) => {
   if (!password) return "";
   return Buffer.from(`ccv-session:${password}`).toString("base64");
 };
-var PUBLIC_API_ROUTES = [
-  "/api/auth/login",
-  "/api/auth/check",
-  "/api/auth/logout",
-  "/api/config",
-  // Allow config access for theme/locale loading
-  "/api/version"
-];
-var LayerImpl30 = Effect49.gen(function* () {
+var getBearerToken = (authorization) => {
+  if (!authorization) return void 0;
+  const [scheme, token] = authorization.split(" ");
+  if (!scheme || !token) return void 0;
+  if (scheme.toLowerCase() !== "bearer") return void 0;
+  const trimmedToken = token.trim();
+  return trimmedToken.length > 0 ? trimmedToken : void 0;
+};
+var createAuthRequiredMiddleware = (authEnabled, validSessionToken, authPassword) => {
+  return createMiddleware(async (c, next) => {
+    if (!c.req.path.startsWith("/api")) {
+      return next();
+    }
+    if (!authEnabled) {
+      return next();
+    }
+    const sessionToken = getCookie(c, "ccv-session");
+    const bearerToken = getBearerToken(c.req.header("Authorization"));
+    const cookieAuthorized = sessionToken === validSessionToken;
+    const bearerAuthorized = authPassword !== void 0 && bearerToken === authPassword;
+    if (!cookieAuthorized && !bearerAuthorized) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    await next();
+  });
+};
+var LayerImpl31 = Effect50.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
-  return Effect49.gen(function* () {
-    const anthPassword = yield* ccvOptionsService.getCcvOptions("password");
-    const authEnabled = anthPassword !== void 0;
-    const validSessionToken = generateSessionToken(anthPassword);
-    const authMiddleware = createMiddleware(async (c, next) => {
-      if (PUBLIC_API_ROUTES.includes(c.req.path)) {
-        return next();
-      }
-      if (!c.req.path.startsWith("/api")) {
-        return next();
-      }
-      if (!authEnabled) {
-        return next();
-      }
-      const sessionToken = getCookie(c, "ccv-session");
-      if (!sessionToken || sessionToken !== validSessionToken) {
-        return c.json({ error: "Unauthorized" }, 401);
-      }
-      await next();
+  const runtime = yield* Effect50.runtime();
+  const runPromise = Runtime3.runPromise(runtime);
+  return yield* Effect50.gen(function* () {
+    const getAuthState = Effect50.gen(function* () {
+      const authPassword = yield* ccvOptionsService.getCcvOptions("password");
+      const authEnabled = authPassword !== void 0;
+      const validSessionToken = generateSessionToken(authPassword);
+      return { authEnabled, authPassword, validSessionToken };
     });
+    const authRequiredMiddleware = createMiddleware(
+      async (c, next) => {
+        if (!c.req.path.startsWith("/api")) {
+          return next();
+        }
+        const { authEnabled, validSessionToken, authPassword } = await runPromise(getAuthState);
+        return createAuthRequiredMiddleware(
+          authEnabled,
+          validSessionToken,
+          authPassword
+        )(c, next);
+      }
+    );
     return {
-      authEnabled,
-      anthPassword,
-      validSessionToken,
-      authMiddleware
+      getAuthState,
+      authRequiredMiddleware
     };
   });
 });
-var AuthMiddleware = class extends Context39.Tag("AuthMiddleware")() {
+var AuthMiddleware = class extends Context40.Tag("AuthMiddleware")() {
   static {
-    this.Live = Layer41.effect(this, LayerImpl30);
+    this.Live = Layer42.effect(this, LayerImpl31);
   }
 };
 
-// src/server/hono/route.ts
-import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect51, Runtime as Runtime3 } from "effect";
-import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
-import { streamSSE } from "hono/streaming";
+// src/server/hono/routes/index.ts
+import { zValidator as zValidator8 } from "@hono/zod-validator";
+import { Effect as Effect62, Runtime as Runtime5 } from "effect";
+import { setCookie as setCookie3 } from "hono/cookie";
 import prexit from "prexit";
-import { z as z31 } from "zod";
-
-// src/server/core/claude-code/schema.ts
-import { z as z27 } from "zod";
-var mediaTypeSchema = z27.enum([
-  "image/png",
-  "image/jpeg",
-  "image/gif",
-  "image/webp"
-]);
-var imageBlockSchema = z27.object({
-  type: z27.literal("image"),
-  source: z27.object({
-    type: z27.literal("base64"),
-    media_type: mediaTypeSchema,
-    data: z27.string()
-  })
-});
-var documentBlockSchema = z27.object({
-  type: z27.literal("document"),
-  source: z27.union([
-    z27.object({
-      type: z27.literal("text"),
-      media_type: z27.enum(["text/plain"]),
-      data: z27.string()
-    }),
-    z27.object({
-      type: z27.literal("base64"),
-      media_type: z27.enum(["application/pdf"]),
-      data: z27.string()
-    })
-  ])
-});
-var userMessageInputSchema = z27.object({
-  text: z27.string().min(1),
-  images: z27.array(imageBlockSchema).optional(),
-  documents: z27.array(documentBlockSchema).optional()
-});
-
-// src/server/core/git/schema.ts
-import { z as z28 } from "zod";
-var CommitRequestSchema = z28.object({
-  projectId: z28.string().min(1),
-  files: z28.array(z28.string().min(1)).min(1),
-  message: z28.string().trim().min(1)
-});
-var PushRequestSchema = z28.object({
-  projectId: z28.string().min(1)
-});
-var CommitResultSuccessSchema = z28.object({
-  success: z28.literal(true),
-  commitSha: z28.string().length(40),
-  filesCommitted: z28.number().int().positive(),
-  message: z28.string()
-});
-var CommitResultErrorSchema = z28.object({
-  success: z28.literal(false),
-  error: z28.string(),
-  errorCode: z28.enum([
-    "EMPTY_MESSAGE",
-    "NO_FILES",
-    "PROJECT_NOT_FOUND",
-    "NOT_A_REPOSITORY",
-    "HOOK_FAILED",
-    "GIT_COMMAND_ERROR"
-  ]),
-  details: z28.string().optional()
-});
-var CommitResultSchema = z28.discriminatedUnion("success", [
-  CommitResultSuccessSchema,
-  CommitResultErrorSchema
-]);
-var PushResultSuccessSchema = z28.object({
-  success: z28.literal(true),
-  remote: z28.string(),
-  branch: z28.string(),
-  objectsPushed: z28.number().int().optional()
-});
-var PushResultErrorSchema = z28.object({
-  success: z28.literal(false),
-  error: z28.string(),
-  errorCode: z28.enum([
-    "PROJECT_NOT_FOUND",
-    "NOT_A_REPOSITORY",
-    "NO_UPSTREAM",
-    "NON_FAST_FORWARD",
-    "AUTH_FAILED",
-    "NETWORK_ERROR",
-    "TIMEOUT",
-    "GIT_COMMAND_ERROR"
-  ]),
-  details: z28.string().optional()
-});
-var PushResultSchema = z28.discriminatedUnion("success", [
-  PushResultSuccessSchema,
-  PushResultErrorSchema
-]);
-var CommitAndPushResultSuccessSchema = z28.object({
-  success: z28.literal(true),
-  commitSha: z28.string().length(40),
-  filesCommitted: z28.number().int().positive(),
-  message: z28.string(),
-  remote: z28.string(),
-  branch: z28.string()
-});
-var CommitAndPushResultErrorSchema = z28.object({
-  success: z28.literal(false),
-  commitSucceeded: z28.boolean(),
-  commitSha: z28.string().length(40).optional(),
-  error: z28.string(),
-  errorCode: z28.enum([
-    "EMPTY_MESSAGE",
-    "NO_FILES",
-    "PROJECT_NOT_FOUND",
-    "NOT_A_REPOSITORY",
-    "HOOK_FAILED",
-    "GIT_COMMAND_ERROR",
-    "NO_UPSTREAM",
-    "NON_FAST_FORWARD",
-    "AUTH_FAILED",
-    "NETWORK_ERROR",
-    "TIMEOUT"
-  ]),
-  details: z28.string().optional()
-});
-var CommitAndPushResultSchema = z28.discriminatedUnion("success", [
-  CommitAndPushResultSuccessSchema,
-  CommitAndPushResultErrorSchema
-]);
 
 // src/server/lib/config/config.ts
-import z30 from "zod";
+import z28 from "zod";
 
 // src/lib/i18n/schema.ts
-import z29 from "zod";
-var localeSchema = z29.enum(["ja", "en", "zh_CN"]);
+import z27 from "zod";
+var localeSchema = z27.enum(["ja", "en", "zh_CN"]);
 
 // src/server/lib/config/config.ts
-var userConfigSchema = z30.object({
-  hideNoUserMessageSession: z30.boolean().optional().default(true),
-  unifySameTitleSession: z30.boolean().optional().default(false),
-  enterKeyBehavior: z30.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
-  permissionMode: z30.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
+var userConfigSchema = z28.object({
+  hideNoUserMessageSession: z28.boolean().optional().default(true),
+  unifySameTitleSession: z28.boolean().optional().default(false),
+  enterKeyBehavior: z28.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+  permissionMode: z28.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
   locale: localeSchema.optional().default("en"),
-  theme: z30.enum(["light", "dark", "system"]).optional().default("system"),
-  searchHotkey: z30.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
-  autoScheduleContinueOnRateLimit: z30.boolean().optional().default(false)
+  theme: z28.enum(["light", "dark", "system"]).optional().default("system"),
+  searchHotkey: z28.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
+  autoScheduleContinueOnRateLimit: z28.boolean().optional().default(false)
 });
 var defaultUserConfig = userConfigSchema.parse({});
 
-// src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect50 } from "effect";
-var effectToResponse = async (ctx, effect) => {
-  const result = await Effect50.runPromise(effect);
-  const result2 = ctx.json(result.response, result.status);
-  return result2;
-};
-
 // src/server/hono/middleware/config.middleware.ts
 import { getCookie as getCookie2, setCookie } from "hono/cookie";
 import { createMiddleware as createMiddleware2 } from "hono/factory";
@@ -8737,46 +9304,22 @@ var configMiddleware = createMiddleware2(
   }
 );
 
-// src/server/hono/route.ts
-var routes = (app, options) => Effect51.gen(function* () {
-  const ccvOptionsService = yield* CcvOptionsService;
-  yield* ccvOptionsService.loadCliOptions(options);
-  const envService = yield* EnvService;
-  const userConfigService = yield* UserConfigService;
-  const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
-  const initializeService = yield* InitializeService;
-  const projectController = yield* ProjectController;
-  const sessionController = yield* SessionController;
-  const agentSessionController = yield* AgentSessionController;
-  const gitController = yield* GitController;
-  const claudeCodeSessionProcessController = yield* ClaudeCodeSessionProcessController;
-  const claudeCodePermissionController = yield* ClaudeCodePermissionController;
-  const sseController = yield* SSEController;
-  const fileSystemController = yield* FileSystemController;
-  const claudeCodeController = yield* ClaudeCodeController;
-  const schedulerController = yield* SchedulerController;
-  const featureFlagController = yield* FeatureFlagController;
-  const searchController = yield* SearchController;
-  const tasksController = yield* TasksController;
-  const authMiddlewareService = yield* AuthMiddleware;
-  const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* authMiddlewareService;
-  const runtime = yield* Effect51.runtime();
-  if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
-    yield* initializeService.startInitialization();
-    prexit(async () => {
-      await Runtime3.runPromise(runtime)(initializeService.stopCleanup());
-    });
-  }
-  return app.use(configMiddleware).use(authMiddleware).use(async (c, next) => {
-    await Effect51.runPromise(
-      userConfigService.setUserConfig({
-        ...c.get("userConfig")
-      })
-    );
-    await next();
-  }).post(
-    "/api/auth/login",
-    zValidator("json", z31.object({ password: z31.string() })),
+// src/server/hono/runtime.ts
+import { Effect as Effect51 } from "effect";
+var getHonoRuntime = Effect51.runtime();
+
+// src/server/hono/routes/authRoutes.ts
+import { zValidator } from "@hono/zod-validator";
+import { Effect as Effect52 } from "effect";
+import { Hono as Hono2 } from "hono";
+import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
+import { z as z29 } from "zod";
+var authRoutes = Effect52.gen(function* () {
+  const { getAuthState } = yield* AuthMiddleware;
+  const { validSessionToken, authEnabled, authPassword } = yield* getAuthState;
+  return new Hono2().post(
+    "/login",
+    zValidator("json", z29.object({ password: z29.string() })),
     async (c) => {
       const { password } = c.req.valid("json");
       if (!authEnabled) {
@@ -8787,7 +9330,7 @@ var routes = (app, options) => Effect51.gen(function* () {
           500
         );
       }
-      if (password !== anthPassword) {
+      if (password !== authPassword) {
         return c.json({ error: "Invalid password" }, 401);
       }
       setCookie2(c, "ccv-session", validSessionToken, {
@@ -8801,459 +9344,785 @@ var routes = (app, options) => Effect51.gen(function* () {
       });
       return c.json({ success: true });
     }
-  ).post("/api/auth/logout", async (c) => {
+  ).post("/logout", async (c) => {
     deleteCookie(c, "ccv-session", { path: "/" });
     return c.json({ success: true });
-  }).get("/api/auth/check", async (c) => {
+  }).get("/check", async (c) => {
     const sessionToken = getCookie3(c, "ccv-session");
     const isAuthenticated = authEnabled ? sessionToken === validSessionToken : true;
     return c.json({ authenticated: isAuthenticated, authEnabled });
-  }).get("/api/config", async (c) => {
-    return c.json({
-      config: c.get("userConfig")
-    });
-  }).put("/api/config", zValidator("json", userConfigSchema), async (c) => {
-    const { ...config } = c.req.valid("json");
-    setCookie2(c, "ccv-config", JSON.stringify(config));
-    return c.json({
-      config
-    });
-  }).get("/api/version", async (c) => {
-    return c.json({
-      version: package_default.version
-    });
-  }).get("/api/projects", async (c) => {
+  });
+});
+
+// src/server/hono/routes/claudeCodeRoutes.ts
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { Effect as Effect54 } from "effect";
+import { Hono as Hono3 } from "hono";
+import { z as z31 } from "zod";
+
+// src/server/core/claude-code/schema.ts
+import { z as z30 } from "zod";
+var mediaTypeSchema = z30.enum([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+var imageBlockSchema = z30.object({
+  type: z30.literal("image"),
+  source: z30.object({
+    type: z30.literal("base64"),
+    media_type: mediaTypeSchema,
+    data: z30.string()
+  })
+});
+var documentBlockSchema = z30.object({
+  type: z30.literal("document"),
+  source: z30.union([
+    z30.object({
+      type: z30.literal("text"),
+      media_type: z30.enum(["text/plain"]),
+      data: z30.string()
+    }),
+    z30.object({
+      type: z30.literal("base64"),
+      media_type: z30.enum(["application/pdf"]),
+      data: z30.string()
+    })
+  ])
+});
+var userMessageInputSchema = z30.object({
+  text: z30.string().min(1),
+  images: z30.array(imageBlockSchema).optional(),
+  documents: z30.array(documentBlockSchema).optional()
+});
+var sandboxNetworkConfigSchema = z30.object({
+  allowedDomains: z30.array(z30.string()).optional(),
+  allowUnixSockets: z30.array(z30.string()).optional(),
+  allowAllUnixSockets: z30.boolean().optional(),
+  allowLocalBinding: z30.boolean().optional(),
+  httpProxyPort: z30.number().optional(),
+  socksProxyPort: z30.number().optional()
+});
+var sandboxSettingsSchema = z30.object({
+  enabled: z30.boolean().optional(),
+  autoAllowBashIfSandboxed: z30.boolean().optional(),
+  allowUnsandboxedCommands: z30.boolean().optional(),
+  network: sandboxNetworkConfigSchema.optional()
+});
+var ccOptionsSchema = z30.object({
+  disallowedTools: z30.array(z30.string()).optional(),
+  settingSources: z30.array(z30.enum(["user", "project", "local"])).optional(),
+  systemPrompt: z30.union([
+    z30.string(),
+    z30.object({
+      type: z30.literal("preset"),
+      preset: z30.literal("claude_code"),
+      append: z30.string().optional()
+    })
+  ]).optional(),
+  model: z30.string().optional(),
+  sandbox: sandboxSettingsSchema.optional(),
+  maxTurns: z30.number().optional(),
+  maxThinkingTokens: z30.number().optional(),
+  env: z30.record(z30.string(), z30.string().optional()).optional(),
+  maxBudgetUsd: z30.number().optional()
+});
+
+// src/server/lib/effect/toEffectResponse.ts
+import { Effect as Effect53 } from "effect";
+var effectToResponse = async (ctx, effect) => {
+  const result = await Effect53.runPromise(effect);
+  const result2 = ctx.json(result.response, result.status);
+  return result2;
+};
+
+// src/server/hono/routes/claudeCodeRoutes.ts
+var normalizeUserMessageInput = (input) => {
+  const images = input.images?.map((image) => ({
+    type: image.type,
+    source: image.source
+  }));
+  const documents = input.documents?.map((document) => {
+    if (!document.source) {
+      throw new Error("Document source is required");
+    }
+    return {
+      type: document.type,
+      source: document.source
+    };
+  });
+  return {
+    text: input.text,
+    images,
+    documents
+  };
+};
+var claudeCodeRoutes = Effect54.gen(function* () {
+  const claudeCodeController = yield* ClaudeCodeController;
+  const claudeCodeSessionProcessController = yield* ClaudeCodeSessionProcessController;
+  const claudeCodePermissionController = yield* ClaudeCodePermissionController;
+  const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
+  const runtime = yield* getHonoRuntime;
+  return new Hono3().get("/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      projectController.getProjects()
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect54.provide(runtime))
     );
     return response;
-  }).get(
-    "/api/projects/:projectId",
-    zValidator("query", z31.object({ cursor: z31.string().optional() })),
+  }).get("/features", async (c) => {
+    const response = await effectToResponse(
+      c,
+      claudeCodeController.getAvailableFeatures().pipe(Effect54.provide(runtime))
+    );
+    return response;
+  }).get("/session-processes", async (c) => {
+    const response = await effectToResponse(
+      c,
+      claudeCodeSessionProcessController.getSessionProcesses()
+    );
+    return response;
+  }).post(
+    "/session-processes",
+    zValidator2(
+      "json",
+      z31.object({
+        projectId: z31.string(),
+        input: userMessageInputSchema,
+        baseSession: z31.union([
+          z31.undefined(),
+          z31.object({
+            type: z31.literal("fork"),
+            sessionId: z31.string()
+          }),
+          z31.object({
+            type: z31.literal("resume"),
+            sessionId: z31.string()
+          })
+        ]),
+        ccOptions: ccOptionsSchema.optional()
+      })
+    ),
     async (c) => {
+      const body = c.req.valid("json");
+      const input = normalizeUserMessageInput(body.input);
+      const { baseSession, ...rest } = body;
       const response = await effectToResponse(
         c,
-        projectController.getProject({
-          ...c.req.param(),
-          ...c.req.valid("query")
-        }).pipe(Effect51.provide(runtime))
+        claudeCodeSessionProcessController.createSessionProcess({
+          ...rest,
+          input,
+          baseSession: baseSession ?? void 0
+        })
       );
       return response;
     }
   ).post(
-    "/api/projects",
-    zValidator(
+    "/session-processes/:sessionProcessId/continue",
+    zValidator2(
       "json",
       z31.object({
-        projectPath: z31.string().min(1, "Project path is required")
+        projectId: z31.string(),
+        input: userMessageInputSchema,
+        baseSessionId: z31.string()
       })
     ),
     async (c) => {
+      const body = c.req.valid("json");
+      const input = normalizeUserMessageInput(body.input);
       const response = await effectToResponse(
         c,
-        projectController.createProject({
-          ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        claudeCodeSessionProcessController.continueSessionProcess({
+          ...c.req.param(),
+          ...body,
+          input
+        }).pipe(Effect54.provide(runtime))
       );
       return response;
     }
-  ).get("/api/projects/:projectId/latest-session", async (c) => {
-    const response = await effectToResponse(
-      c,
-      projectController.getProjectLatestSession({
-        ...c.req.param()
-      }).pipe(Effect51.provide(runtime))
-    );
-    return response;
-  }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
-    const response = await effectToResponse(
-      c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
-    );
-    return response;
-  }).get(
-    "/api/projects/:projectId/sessions/:sessionId/export",
+  ).post(
+    "/session-processes/:sessionProcessId/abort",
+    zValidator2("json", z31.object({ projectId: z31.string() })),
     async (c) => {
-      const response = await effectToResponse(
-        c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect51.provide(runtime))
+      const { sessionProcessId } = c.req.param();
+      void Effect54.runFork(
+        claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
-      return response;
+      return c.json({ message: "Task aborted" });
     }
-  ).delete("/api/projects/:projectId/sessions/:sessionId", async (c) => {
-    const response = await effectToResponse(
-      c,
-      sessionController.deleteSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
-    );
-    return response;
-  }).get(
-    "/api/projects/:projectId/agent-sessions/:agentId",
-    zValidator("query", z31.object({ sessionId: z31.string().optional() })),
+  ).post(
+    "/permission-response",
+    zValidator2(
+      "json",
+      z31.object({
+        permissionRequestId: z31.string(),
+        decision: z31.enum(["allow", "deny"])
+      })
+    ),
     async (c) => {
-      const { projectId, agentId } = c.req.param();
-      const { sessionId } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        agentSessionController.getAgentSession({
-          projectId,
-          agentId,
-          sessionId
-        }).pipe(Effect51.provide(runtime))
+        claudeCodePermissionController.permissionResponse({
+          permissionResponse: c.req.valid("json")
+        })
       );
       return response;
     }
-  ).get("/api/projects/:projectId/git/current-revisions", async (c) => {
+  );
+});
+
+// src/server/hono/routes/featureFlagRoutes.ts
+import { Effect as Effect55 } from "effect";
+import { Hono as Hono4 } from "hono";
+var featureFlagRoutes = Effect55.gen(function* () {
+  const featureFlagController = yield* FeatureFlagController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono4().get("/", async (c) => {
     const response = await effectToResponse(
       c,
-      gitController.getCurrentRevisions({
-        ...c.req.param()
-      }).pipe(Effect51.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect55.provide(runtime))
     );
     return response;
-  }).post(
-    "/api/projects/:projectId/git/diff",
-    zValidator(
-      "json",
-      z31.object({
-        fromRef: z31.string().min(1, "fromRef is required"),
-        toRef: z31.string().min(1, "toRef is required")
+  });
+});
+
+// src/server/hono/routes/fileSystemRoutes.ts
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { Effect as Effect56 } from "effect";
+import { Hono as Hono5 } from "hono";
+import { z as z32 } from "zod";
+var fileSystemRoutes = Effect56.gen(function* () {
+  const fileSystemController = yield* FileSystemController;
+  return new Hono5().get(
+    "/file-completion",
+    zValidator3(
+      "query",
+      z32.object({
+        projectId: z32.string(),
+        basePath: z32.string().optional().default("/api/")
       })
     ),
     async (c) => {
       const response = await effectToResponse(
         c,
-        gitController.getGitDiff({
-          ...c.req.param(),
-          ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        fileSystemController.getFileCompletionRoute({
+          ...c.req.valid("query")
+        })
       );
       return response;
     }
-  ).post(
-    "/api/projects/:projectId/git/commit",
-    zValidator("json", CommitRequestSchema),
+  ).get(
+    "/directory-browser",
+    zValidator3(
+      "query",
+      z32.object({
+        currentPath: z32.string().optional(),
+        showHidden: z32.string().optional().transform((val) => val === "true")
+      })
+    ),
     async (c) => {
       const response = await effectToResponse(
         c,
-        gitController.commitFiles({
-          ...c.req.param(),
-          ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        fileSystemController.getDirectoryListingRoute({
+          ...c.req.valid("query")
+        })
       );
       return response;
     }
-  ).post(
-    "/api/projects/:projectId/git/push",
-    zValidator("json", PushRequestSchema),
+  );
+});
+
+// src/server/hono/routes/projectRoutes.ts
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import { Effect as Effect57 } from "effect";
+import { Hono as Hono6 } from "hono";
+import { z as z34 } from "zod";
+
+// src/server/core/git/schema.ts
+import { z as z33 } from "zod";
+var CommitRequestSchema = z33.object({
+  files: z33.array(z33.string().min(1)).min(1),
+  message: z33.string().trim().min(1)
+});
+var CommitResultSuccessSchema = z33.object({
+  success: z33.literal(true),
+  commitSha: z33.string().length(40),
+  filesCommitted: z33.number().int().positive(),
+  message: z33.string()
+});
+var CommitResultErrorSchema = z33.object({
+  success: z33.literal(false),
+  error: z33.string(),
+  errorCode: z33.enum([
+    "EMPTY_MESSAGE",
+    "NO_FILES",
+    "PROJECT_NOT_FOUND",
+    "NOT_A_REPOSITORY",
+    "HOOK_FAILED",
+    "GIT_COMMAND_ERROR"
+  ]),
+  details: z33.string().optional()
+});
+var CommitResultSchema = z33.discriminatedUnion("success", [
+  CommitResultSuccessSchema,
+  CommitResultErrorSchema
+]);
+var PushResultSuccessSchema = z33.object({
+  success: z33.literal(true),
+  remote: z33.string(),
+  branch: z33.string(),
+  objectsPushed: z33.number().int().optional()
+});
+var PushResultErrorSchema = z33.object({
+  success: z33.literal(false),
+  error: z33.string(),
+  errorCode: z33.enum([
+    "PROJECT_NOT_FOUND",
+    "NOT_A_REPOSITORY",
+    "NO_UPSTREAM",
+    "NON_FAST_FORWARD",
+    "AUTH_FAILED",
+    "NETWORK_ERROR",
+    "TIMEOUT",
+    "GIT_COMMAND_ERROR"
+  ]),
+  details: z33.string().optional()
+});
+var PushResultSchema = z33.discriminatedUnion("success", [
+  PushResultSuccessSchema,
+  PushResultErrorSchema
+]);
+var CommitAndPushResultSuccessSchema = z33.object({
+  success: z33.literal(true),
+  commitSha: z33.string().length(40),
+  filesCommitted: z33.number().int().positive(),
+  message: z33.string(),
+  remote: z33.string(),
+  branch: z33.string()
+});
+var CommitAndPushResultErrorSchema = z33.object({
+  success: z33.literal(false),
+  commitSucceeded: z33.boolean(),
+  commitSha: z33.string().length(40).optional(),
+  error: z33.string(),
+  errorCode: z33.enum([
+    "EMPTY_MESSAGE",
+    "NO_FILES",
+    "PROJECT_NOT_FOUND",
+    "NOT_A_REPOSITORY",
+    "HOOK_FAILED",
+    "GIT_COMMAND_ERROR",
+    "NO_UPSTREAM",
+    "NON_FAST_FORWARD",
+    "AUTH_FAILED",
+    "NETWORK_ERROR",
+    "TIMEOUT"
+  ]),
+  details: z33.string().optional()
+});
+var CommitAndPushResultSchema = z33.discriminatedUnion("success", [
+  CommitAndPushResultSuccessSchema,
+  CommitAndPushResultErrorSchema
+]);
+
+// src/server/hono/routes/projectRoutes.ts
+var projectRoutes = Effect57.gen(function* () {
+  const projectController = yield* ProjectController;
+  const sessionController = yield* SessionController;
+  const agentSessionController = yield* AgentSessionController;
+  const claudeCodeController = yield* ClaudeCodeController;
+  const fileSystemController = yield* FileSystemController;
+  const gitController = yield* GitController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono6().get("/", async (c) => {
+    const response = await effectToResponse(
+      c,
+      projectController.getProjects()
+    );
+    return response;
+  }).get(
+    "/:projectId",
+    zValidator4("query", z34.object({ cursor: z34.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
-        gitController.pushCommits({
+        projectController.getProject({
           ...c.req.param(),
-          ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+          ...c.req.valid("query")
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
   ).post(
-    "/api/projects/:projectId/git/commit-and-push",
-    zValidator("json", CommitRequestSchema),
+    "/",
+    zValidator4(
+      "json",
+      z34.object({
+        projectPath: z34.string().min(1, "Project path is required")
+      })
+    ),
     async (c) => {
       const response = await effectToResponse(
         c,
-        gitController.commitAndPush({
-          ...c.req.param(),
+        projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
-  ).get("/api/projects/:projectId/claude-commands", async (c) => {
+  ).get("/:projectId/latest-session", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCommands({
+      projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect51.provide(runtime))
+      }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get("/api/projects/:projectId/mcp/list", async (c) => {
+  }).get("/:projectId/sessions/:sessionId", async (c) => {
+    const projectId = c.req.param("projectId");
+    const sessionId = c.req.param("sessionId");
     const response = await effectToResponse(
       c,
-      claudeCodeController.getMcpListRoute({
-        ...c.req.param()
-      }).pipe(Effect51.provide(runtime))
+      sessionController.getSession({ projectId, sessionId }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get("/api/cc/meta", async (c) => {
+  }).get("/:projectId/sessions/:sessionId/export", async (c) => {
+    const projectId = c.req.param("projectId");
+    const sessionId = c.req.param("sessionId");
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect51.provide(runtime))
+      sessionController.exportSessionHtml({ projectId, sessionId }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get("/api/cc/features", async (c) => {
+  }).delete("/:projectId/sessions/:sessionId", async (c) => {
+    const projectId = c.req.param("projectId");
+    const sessionId = c.req.param("sessionId");
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect51.provide(runtime))
+      sessionController.deleteSession({ projectId, sessionId }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get("/api/cc/session-processes", async (c) => {
+  }).get("/:projectId/agent-sessions/:agentId", async (c) => {
+    const projectId = c.req.param("projectId");
+    const agentId = c.req.param("agentId");
     const response = await effectToResponse(
       c,
-      claudeCodeSessionProcessController.getSessionProcesses()
+      agentSessionController.getAgentSession({ projectId, agentId })
     );
     return response;
-  }).post(
-    "/api/cc/session-processes",
-    zValidator(
-      "json",
-      z31.object({
-        projectId: z31.string(),
-        input: userMessageInputSchema,
-        baseSessionId: z31.string().optional()
+  }).get("/:projectId/claude-commands", async (c) => {
+    const response = await effectToResponse(
+      c,
+      claudeCodeController.getClaudeCommands({
+        ...c.req.param()
+      }).pipe(Effect57.provide(runtime))
+    );
+    return response;
+  }).get("/:projectId/mcp/list", async (c) => {
+    const response = await effectToResponse(
+      c,
+      claudeCodeController.getMcpListRoute({
+        ...c.req.param()
+      }).pipe(Effect57.provide(runtime))
+    );
+    return response;
+  }).get(
+    "/:projectId/files",
+    zValidator4(
+      "query",
+      z34.object({
+        filePath: z34.string().min(1, "filePath is required")
       })
     ),
     async (c) => {
+      const { projectId } = c.req.param();
+      const { filePath } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        claudeCodeSessionProcessController.createSessionProcess(
-          c.req.valid("json")
-        )
+        fileSystemController.getFileContentRoute({
+          projectId,
+          filePath
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
-  ).post(
-    "/api/cc/session-processes/:sessionProcessId/continue",
-    zValidator(
+  ).get("/:projectId/git/current-revisions", async (c) => {
+    const projectId = c.req.param("projectId");
+    const response = await effectToResponse(
+      c,
+      gitController.getCurrentRevisions({
+        projectId
+      }).pipe(Effect57.provide(runtime))
+    );
+    return response;
+  }).post(
+    "/:projectId/git/diff",
+    zValidator4(
       "json",
-      z31.object({
-        projectId: z31.string(),
-        input: userMessageInputSchema,
-        baseSessionId: z31.string()
+      z34.object({
+        fromRef: z34.string().min(1, "fromRef is required"),
+        toRef: z34.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
+      const projectId = c.req.param("projectId");
       const response = await effectToResponse(
         c,
-        claudeCodeSessionProcessController.continueSessionProcess({
-          ...c.req.param(),
+        gitController.getGitDiff({
+          projectId,
           ...c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
   ).post(
-    "/api/cc/session-processes/:sessionProcessId/abort",
-    zValidator("json", z31.object({ projectId: z31.string() })),
-    async (c) => {
-      const { sessionProcessId } = c.req.param();
-      void Effect51.runFork(
-        claudeCodeLifeCycleService.abortTask(sessionProcessId)
-      );
-      return c.json({ message: "Task aborted" });
-    }
-  ).post(
-    "/api/cc/permission-response",
-    zValidator(
-      "json",
-      z31.object({
-        permissionRequestId: z31.string(),
-        decision: z31.enum(["allow", "deny"])
-      })
-    ),
+    "/:projectId/git/commit",
+    zValidator4("json", CommitRequestSchema),
     async (c) => {
+      const projectId = c.req.param("projectId");
       const response = await effectToResponse(
         c,
-        claudeCodePermissionController.permissionResponse({
-          permissionResponse: c.req.valid("json")
-        })
+        gitController.commitFiles({
+          projectId,
+          ...c.req.valid("json")
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
-  ).get("/api/sse", async (c) => {
-    return streamSSE(
-      c,
-      async (rawStream) => {
-        await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect51.provide(TypeSafeSSE.make(rawStream)))
-        );
-      },
-      async (err) => {
-        console.error("Streaming error:", err);
-      }
-    );
-  }).get("/api/scheduler/jobs", async (c) => {
+  ).post("/:projectId/git/push", async (c) => {
+    const projectId = c.req.param("projectId");
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect51.provide(runtime))
+      gitController.pushCommits({
+        projectId
+      }).pipe(Effect57.provide(runtime))
     );
     return response;
   }).post(
-    "/api/scheduler/jobs",
-    zValidator("json", newSchedulerJobSchema),
-    async (c) => {
-      const response = await effectToResponse(
-        c,
-        schedulerController.addJob({
-          job: c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
-      );
-      return response;
-    }
-  ).patch(
-    "/api/scheduler/jobs/:id",
-    zValidator("json", updateSchedulerJobSchema),
+    "/:projectId/git/commit-and-push",
+    zValidator4("json", CommitRequestSchema),
     async (c) => {
+      const projectId = c.req.param("projectId");
       const response = await effectToResponse(
         c,
-        schedulerController.updateJob({
-          id: c.req.param("id"),
-          job: c.req.valid("json")
-        }).pipe(Effect51.provide(runtime))
+        gitController.commitAndPush({
+          projectId,
+          ...c.req.valid("json")
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
-  ).delete("/api/scheduler/jobs/:id", async (c) => {
+  ).get("/:projectId/git/branches", async (c) => {
+    const projectId = c.req.param("projectId");
     const response = await effectToResponse(
       c,
-      schedulerController.deleteJob({
-        id: c.req.param("id")
-      }).pipe(Effect51.provide(runtime))
+      gitController.getBranches({
+        projectId
+      }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get(
-    "/api/fs/file-completion",
-    zValidator(
-      "query",
-      z31.object({
-        projectId: z31.string(),
-        basePath: z31.string().optional().default("/api/")
+  }).post(
+    "/:projectId/git/checkout",
+    zValidator4(
+      "json",
+      z34.object({
+        branchName: z34.string().min(1, "branchName is required")
       })
     ),
     async (c) => {
+      const projectId = c.req.param("projectId");
       const response = await effectToResponse(
         c,
-        fileSystemController.getFileCompletionRoute({
-          ...c.req.valid("query")
-        })
+        gitController.checkoutBranch({
+          projectId,
+          ...c.req.valid("json")
+        }).pipe(Effect57.provide(runtime))
       );
       return response;
     }
-  ).get(
-    "/api/fs/directory-browser",
-    zValidator(
-      "query",
-      z31.object({
-        currentPath: z31.string().optional(),
-        showHidden: z31.string().optional().transform((val) => val === "true")
-      })
-    ),
+  );
+});
+
+// src/server/hono/routes/schedulerRoutes.ts
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { Effect as Effect58 } from "effect";
+import { Hono as Hono7 } from "hono";
+var schedulerRoutes = Effect58.gen(function* () {
+  const schedulerController = yield* SchedulerController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono7().get("/jobs", async (c) => {
+    const response = await effectToResponse(
+      c,
+      schedulerController.getJobs().pipe(Effect58.provide(runtime))
+    );
+    return response;
+  }).post("/jobs", zValidator5("json", newSchedulerJobSchema), async (c) => {
+    const response = await effectToResponse(
+      c,
+      schedulerController.addJob({
+        job: c.req.valid("json")
+      }).pipe(Effect58.provide(runtime))
+    );
+    return response;
+  }).patch(
+    "/jobs/:id",
+    zValidator5("json", updateSchedulerJobSchema),
     async (c) => {
       const response = await effectToResponse(
         c,
-        fileSystemController.getDirectoryListingRoute({
-          ...c.req.valid("query")
-        })
+        schedulerController.updateJob({
+          id: c.req.param("id"),
+          job: c.req.valid("json")
+        }).pipe(Effect58.provide(runtime))
       );
       return response;
     }
-  ).get(
-    "/api/search",
-    zValidator(
+  ).delete("/jobs/:id", async (c) => {
+    const response = await effectToResponse(
+      c,
+      schedulerController.deleteJob({
+        id: c.req.param("id")
+      }).pipe(Effect58.provide(runtime))
+    );
+    return response;
+  });
+});
+
+// src/server/hono/routes/searchRoutes.ts
+import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { Effect as Effect59 } from "effect";
+import { Hono as Hono8 } from "hono";
+import { z as z35 } from "zod";
+var searchRoutes = Effect59.gen(function* () {
+  const searchController = yield* SearchController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono8().get(
+    "/",
+    zValidator6(
       "query",
-      z31.object({
-        q: z31.string().min(2),
-        limit: z31.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
-        projectId: z31.string().optional()
+      z35.object({
+        q: z35.string().min(2),
+        limit: z35.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z35.string().optional()
       })
     ),
     async (c) => {
       const { q, limit, projectId } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        searchController.search({ query: q, limit, projectId }).pipe(Effect51.provide(runtime))
+        searchController.search({ query: q, limit, projectId }).pipe(Effect59.provide(runtime))
       );
       return response;
     }
-  ).get("/api/flags", async (c) => {
-    const response = await effectToResponse(
+  );
+});
+
+// src/server/hono/routes/sseRoutes.ts
+import { Effect as Effect60, Runtime as Runtime4 } from "effect";
+import { Hono as Hono9 } from "hono";
+import { streamSSE } from "hono/streaming";
+var sseRoutes = Effect60.gen(function* () {
+  const sseController = yield* SSEController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono9().get("/sse", async (c) => {
+    return streamSSE(
       c,
-      featureFlagController.getFlags().pipe(Effect51.provide(runtime))
+      async (rawStream) => {
+        await Runtime4.runPromise(runtime)(
+          sseController.handleSSE(rawStream).pipe(Effect60.provide(TypeSafeSSE.make(rawStream)))
+        );
+      },
+      async (err) => {
+        console.error("Streaming error:", err);
+      }
     );
-    return response;
-  }).get(
-    "/api/tasks",
-    zValidator(
+  });
+});
+
+// src/server/hono/routes/tasksRoutes.ts
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { Effect as Effect61 } from "effect";
+import { Hono as Hono10 } from "hono";
+import { z as z36 } from "zod";
+var tasksRoutes = Effect61.gen(function* () {
+  const tasksController = yield* TasksController;
+  const runtime = yield* getHonoRuntime;
+  return new Hono10().get(
+    "/",
+    zValidator7(
       "query",
-      z31.object({
-        projectId: z31.string(),
-        sessionId: z31.string().optional()
+      z36.object({
+        projectId: z36.string(),
+        sessionId: z36.string().optional()
       })
     ),
     async (c) => {
       const { projectId, sessionId } = c.req.valid("query");
       const projectPath = decodeProjectId(projectId);
+      const status = 200;
       const response = await effectToResponse(
         c,
         tasksController.listTasks(projectPath, sessionId).pipe(
-          Effect51.map((tasks) => ({
-            status: 200,
+          Effect61.map((tasks) => ({
+            status,
             response: tasks
           })),
-          Effect51.provide(runtime)
+          Effect61.provide(runtime)
         )
       );
       return response;
     }
   ).post(
-    "/api/tasks",
-    zValidator(
+    "/",
+    zValidator7(
       "query",
-      z31.object({
-        projectId: z31.string(),
-        sessionId: z31.string().optional()
+      z36.object({
+        projectId: z36.string(),
+        sessionId: z36.string().optional()
       })
     ),
-    zValidator("json", TaskCreateSchema),
+    zValidator7("json", TaskCreateSchema),
     async (c) => {
       const { projectId, sessionId } = c.req.valid("query");
       const body = c.req.valid("json");
       const projectPath = decodeProjectId(projectId);
+      const status = 200;
       const response = await effectToResponse(
         c,
         tasksController.createTask(projectPath, body, sessionId).pipe(
-          Effect51.map((task) => ({
-            status: 200,
+          Effect61.map((task) => ({
+            status,
             response: task
           })),
-          Effect51.provide(runtime)
+          Effect61.provide(runtime)
         )
       );
       return response;
     }
   ).patch(
-    "/api/tasks/:id",
-    zValidator(
+    "/:taskId",
+    zValidator7(
       "query",
-      z31.object({
-        projectId: z31.string(),
-        sessionId: z31.string().optional()
+      z36.object({
+        projectId: z36.string(),
+        sessionId: z36.string().optional()
       })
     ),
-    zValidator("json", TaskUpdateSchema.omit({ taskId: true })),
+    zValidator7("json", TaskUpdateSchema.omit({ taskId: true })),
     async (c) => {
-      const { id } = c.req.param();
+      const { taskId } = c.req.param();
       const { projectId, sessionId } = c.req.valid("query");
       const body = c.req.valid("json");
       const projectPath = decodeProjectId(projectId);
+      const status = 200;
       const response = await effectToResponse(
         c,
-        tasksController.updateTask(projectPath, { ...body, taskId: id }, sessionId).pipe(
-          Effect51.map((task) => ({
-            status: 200,
+        tasksController.updateTask(projectPath, { ...body, taskId }, sessionId).pipe(
+          Effect61.map((task) => ({
+            status,
             response: task
           })),
-          Effect51.provide(runtime)
+          Effect61.provide(runtime)
         )
       );
       return response;
@@ -9261,26 +10130,197 @@ var routes = (app, options) => Effect51.gen(function* () {
   );
 });
 
+// src/server/hono/routes/index.ts
+var routes = (app, options) => Effect62.gen(function* () {
+  const ccvOptionsService = yield* CcvOptionsService;
+  yield* ccvOptionsService.loadCliOptions(options);
+  const envService = yield* EnvService;
+  const userConfigService = yield* UserConfigService;
+  const initializeService = yield* InitializeService;
+  const { authRequiredMiddleware } = yield* AuthMiddleware;
+  const runtime = yield* getHonoRuntime;
+  if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
+    yield* initializeService.startInitialization();
+    prexit(async () => {
+      await Runtime5.runPromise(runtime)(initializeService.stopCleanup());
+    });
+  }
+  return app.use(configMiddleware).use(async (c, next) => {
+    await Runtime5.runPromise(
+      runtime,
+      userConfigService.setUserConfig({
+        ...c.get("userConfig")
+      })
+    );
+    await next();
+  }).get("/api/version", async (c) => {
+    return c.json({
+      version: package_default.version
+    });
+  }).route("/api/auth", yield* authRoutes).use(authRequiredMiddleware).get("/api/config", async (c) => {
+    return c.json({
+      config: c.get("userConfig")
+    });
+  }).put("/api/config", zValidator8("json", userConfigSchema), async (c) => {
+    const { ...config } = c.req.valid("json");
+    setCookie3(c, "ccv-config", JSON.stringify(config));
+    return c.json({
+      config
+    });
+  }).route("/api/projects", yield* projectRoutes).route("/api/claude-code", yield* claudeCodeRoutes).route("/api/scheduler", yield* schedulerRoutes).route("/api/file-system", yield* fileSystemRoutes).route("/api/search", yield* searchRoutes).route("/api/feature-flags", yield* featureFlagRoutes).route("/api/tasks", yield* tasksRoutes).route("/api/sse", yield* sseRoutes);
+});
+
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer42 } from "effect";
-var platformLayer = Layer42.mergeAll(
+import { Layer as Layer43 } from "effect";
+var platformLayer = Layer43.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
   EnvService.Live,
   CcvOptionsService.Live
 ).pipe(
-  Layer42.provide(EnvService.Live),
-  Layer42.provide(CcvOptionsService.Live),
-  Layer42.provide(NodeContext.layer)
+  Layer43.provide(EnvService.Live),
+  Layer43.provide(CcvOptionsService.Live),
+  Layer43.provide(NodeContext.layer)
 );
 
+// src/server/terminal/terminalWebSocket.ts
+import { Effect as Effect63, Runtime as Runtime6 } from "effect";
+import WebSocket, { WebSocketServer } from "ws";
+var parseCookies = (cookieHeader) => {
+  const result = {};
+  if (!cookieHeader) return result;
+  const parts = cookieHeader.split(";");
+  for (const part of parts) {
+    const [rawKey, ...rest] = part.trim().split("=");
+    if (!rawKey) continue;
+    result[rawKey] = rest.join("=");
+  }
+  return result;
+};
+var parseClientMessage = (payload) => {
+  try {
+    const parsed = JSON.parse(payload);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    if (parsed.type === "input" && typeof parsed.data === "string") {
+      return { type: "input", data: parsed.data };
+    }
+    if (parsed.type === "resize" && typeof parsed.cols === "number" && typeof parsed.rows === "number") {
+      return { type: "resize", cols: parsed.cols, rows: parsed.rows };
+    }
+    if (parsed.type === "signal" && typeof parsed.name === "string") {
+      return { type: "signal", name: parsed.name };
+    }
+    if (parsed.type === "sync" && typeof parsed.lastSeq === "number") {
+      return { type: "sync", lastSeq: parsed.lastSeq };
+    }
+    if (parsed.type === "ping") {
+      return { type: "ping" };
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+var sendJson = (client, payload) => {
+  if (client.readyState !== WebSocket.OPEN) return;
+  client.send(JSON.stringify(payload));
+};
+var baseUrlForRequest = (req) => {
+  const host = req.headers.host ?? "localhost";
+  return `http://${host}`;
+};
+var setupTerminalWebSocket = (server) => Effect63.gen(function* () {
+  const terminalService = yield* TerminalService;
+  const { getAuthState } = yield* AuthMiddleware;
+  const { authEnabled, validSessionToken } = yield* getAuthState;
+  const runtime = yield* Effect63.runtime();
+  const runPromise = Runtime6.runPromise(runtime);
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", baseUrlForRequest(req));
+    if (url.pathname !== "/ws/terminal") return;
+    if (authEnabled) {
+      const cookies = parseCookies(req.headers.cookie);
+      if (cookies["ccv-session"] !== validSessionToken) {
+        socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+  wss.on("connection", (ws, req) => {
+    const url = new URL(req.url ?? "/", baseUrlForRequest(req));
+    const sessionIdParam = url.searchParams.get("sessionId");
+    const requestedSessionId = sessionIdParam && sessionIdParam.length > 0 ? sessionIdParam : void 0;
+    const cwdParam = url.searchParams.get("cwd");
+    const cwd = cwdParam && cwdParam.length > 0 ? cwdParam : void 0;
+    runPromise(terminalService.getOrCreateSession(requestedSessionId, cwd)).then((session) => {
+      sendJson(ws, {
+        type: "hello",
+        sessionId: session.id,
+        seq: session.seq
+      });
+      return runPromise(
+        terminalService.registerClient(session.id, ws)
+      ).then(() => session);
+    }).then((session) => {
+      ws.on("message", (data) => {
+        const text = typeof data === "string" ? data : data instanceof Buffer ? data.toString("utf8") : void 0;
+        if (!text) return;
+        const message = parseClientMessage(text);
+        if (!message) return;
+        if (message.type === "input") {
+          void runPromise(
+            terminalService.writeInput(session.id, message.data)
+          );
+          return;
+        }
+        if (message.type === "resize") {
+          void runPromise(
+            terminalService.resize(session.id, message.cols, message.rows)
+          );
+          return;
+        }
+        if (message.type === "signal") {
+          void runPromise(terminalService.signal(session.id, message.name));
+          return;
+        }
+        if (message.type === "sync") {
+          void runPromise(
+            terminalService.snapshotSince(session.id, message.lastSeq)
+          ).then((snapshot) => {
+            if (!snapshot) return;
+            sendJson(ws, {
+              type: "snapshot",
+              seq: snapshot.seq,
+              data: snapshot.data
+            });
+          });
+          return;
+        }
+        if (message.type === "ping") {
+          sendJson(ws, { type: "pong" });
+        }
+      });
+      ws.on("close", () => {
+        void runPromise(terminalService.unregisterClient(session.id, ws));
+      });
+    }).catch(() => {
+      ws.close(1011, "Session initialization failed");
+    });
+  });
+});
+
 // src/server/startServer.ts
 var startServer = async (options) => {
-  const isDevelopment = process.env.NODE_ENV === "development";
+  const isDevelopment = isDevelopmentEnv(process.env.CCV_ENV);
   if (!isDevelopment) {
-    const staticPath = resolve6(import.meta.dirname, "static");
+    const staticPath = resolve7(import.meta.dirname, "static");
     console.log("Serving static files from ", staticPath);
     honoApp.use(
       "/assets/*",
@@ -9292,12 +10332,18 @@ var startServer = async (options) => {
       if (c.req.path.startsWith("/api")) {
         return next();
       }
-      const html = await readFile2(resolve6(staticPath, "index.html"), "utf-8");
+      const html = await readFile3(resolve7(staticPath, "index.html"), "utf-8");
       return c.html(html);
     });
   }
-  const program2 = routes(honoApp, options).pipe(Effect52.provide(MainLayer));
-  await Effect52.runPromise(program2);
+  const server = createAdaptorServer({
+    fetch: honoApp.fetch
+  });
+  const program2 = Effect64.gen(function* () {
+    yield* routes(honoApp, options);
+    yield* setupTerminalWebSocket(server);
+  }).pipe(Effect64.provide(MainLayer), Effect64.scoped);
+  await Effect64.runPromise(program2);
   const port = isDevelopment ? (
     // biome-ignore lint/style/noProcessEnv: allow only here
     process.env.DEV_BE_PORT ?? "3401"
@@ -9306,29 +10352,24 @@ var startServer = async (options) => {
     options.port ?? process.env.PORT ?? "3000"
   );
   const hostname = options.hostname ?? process.env.HOSTNAME ?? "localhost";
-  serve(
-    {
-      fetch: honoApp.fetch,
-      port: parseInt(port, 10),
-      hostname
-    },
-    (info) => {
-      console.log(`Server is running on http://${hostname}:${info.port}`);
-    }
-  );
+  server.listen(parseInt(port, 10), hostname, () => {
+    const info = server.address();
+    const serverPort = typeof info === "object" && info !== null ? info.port : port;
+    console.log(`Server is running on http://${hostname}:${serverPort}`);
+  });
 };
-var PlatformLayer = Layer43.mergeAll(platformLayer, NodeContext2.layer);
-var InfraBasics = Layer43.mergeAll(
+var PlatformLayer = Layer44.mergeAll(platformLayer, NodeContext2.layer);
+var InfraBasics = Layer44.mergeAll(
   VirtualConversationDatabase.Live,
   ProjectMetaService.Live,
   SessionMetaService.Live
 );
-var InfraRepos = Layer43.mergeAll(
+var InfraRepos = Layer44.mergeAll(
   ProjectRepository.Live,
   SessionRepository.Live
-).pipe(Layer43.provideMerge(InfraBasics));
-var InfraLayer = AgentSessionLayer.pipe(Layer43.provideMerge(InfraRepos));
-var DomainBase = Layer43.mergeAll(
+).pipe(Layer44.provideMerge(InfraBasics));
+var InfraLayer = AgentSessionLayer.pipe(Layer44.provideMerge(InfraRepos));
+var DomainBase = Layer44.mergeAll(
   ClaudeCodePermissionService.Live,
   ClaudeCodeSessionProcessService.Live,
   ClaudeCodeService.Live,
@@ -9339,17 +10380,18 @@ var DomainBase = Layer43.mergeAll(
   TasksService.Live
 );
 var DomainLayer = ClaudeCodeLifeCycleService.Live.pipe(
-  Layer43.provideMerge(DomainBase)
+  Layer44.provideMerge(DomainBase)
 );
-var AppServices = Layer43.mergeAll(
+var AppServices = Layer44.mergeAll(
   FileWatcherService.Live,
   RateLimitAutoScheduleService.Live,
-  AuthMiddleware.Live
+  AuthMiddleware.Live,
+  TerminalService.Live
 );
 var ApplicationLayer = InitializeService.Live.pipe(
-  Layer43.provideMerge(AppServices)
+  Layer44.provideMerge(AppServices)
 );
-var PresentationLayer = Layer43.mergeAll(
+var PresentationLayer = Layer44.mergeAll(
   ProjectController.Live,
   SessionController.Live,
   AgentSessionController.Live,
@@ -9365,17 +10407,23 @@ var PresentationLayer = Layer43.mergeAll(
   TasksController.Live
 );
 var MainLayer = PresentationLayer.pipe(
-  Layer43.provideMerge(ApplicationLayer),
-  Layer43.provideMerge(DomainLayer),
-  Layer43.provideMerge(InfraLayer),
-  Layer43.provideMerge(PlatformLayer)
+  Layer44.provideMerge(ApplicationLayer),
+  Layer44.provideMerge(DomainLayer),
+  Layer44.provideMerge(InfraLayer),
+  Layer44.provideMerge(PlatformLayer)
 );
 
 // src/server/main.ts
 var program = new Command3();
 program.name(package_default.name).version(package_default.version).description(package_default.description);
-program.option("-p, --port <port>", "port to listen on").option("-h, --hostname <hostname>", "hostname to listen on").option("-P, --password <password>", "password to authenticate").option("-e, --executable <executable>", "path to claude code executable").option("--claude-dir <claude-dir>", "path to claude directory").action(async (options) => {
-  await Effect53.runPromise(checkDeprecatedEnvs);
+program.option("-p, --port <port>", "port to listen on").option("-h, --hostname <hostname>", "hostname to listen on").option("-P, --password <password>", "password to authenticate").option("-e, --executable <executable>", "path to claude code executable").option("--claude-dir <claude-dir>", "path to claude directory").option(
+  "--terminal-disabled",
+  "disable the in-app terminal panel when enabled"
+).option("--terminal-shell <path>", "shell executable for terminal sessions").option(
+  "--terminal-unrestricted",
+  "disable restricted shell flags for bash sessions"
+).action(async (options) => {
+  await Effect65.runPromise(checkDeprecatedEnvs);
   await startServer(options);
 });
 var main = async () => {