@kimuson/claude-code-viewer 0.4.14 → 0.5.0

package/dist/main.js

@@ -1,19 +1,230 @@
-#!/usr/bin/env node
-
 // src/server/main.ts
+import { Command as Command3 } from "commander";
+import { Effect as Effect49 } from "effect";
+
+// package.json
+var package_default = {
+  name: "@kimuson/claude-code-viewer",
+  version: "0.5.0",
+  description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/d-kimuson/claude-code-viewer.git"
+  },
+  homepage: "https://github.com/d-kimuson/claude-code-viewer",
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20.19.0"
+  },
+  bin: {
+    "claude-code-viewer": "./dist/main.js"
+  },
+  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",
+    start: "node dist/main.js",
+    build: "./scripts/build.sh",
+    "build:frontend": "vite build",
+    "build:backend": "esbuild src/server/main.ts --format=esm --bundle --packages=external --sourcemap --platform=node --outfile=dist/main.js",
+    lint: "run-s 'lint:*'",
+    "lint:biome-format": "biome format .",
+    "lint:biome-lint": "biome check .",
+    fix: "run-s 'fix:*'",
+    "fix:biome-format": "biome format --write .",
+    "fix:biome-lint": "biome check --write --unsafe .",
+    typecheck: "tsc --noEmit",
+    test: "vitest --run",
+    "test:watch": "vitest",
+    e2e: "./scripts/e2e/exec_e2e.sh",
+    "e2e:start-server": "./scripts/e2e/start_server.sh",
+    "e2e:capture-snapshots": "./scripts/e2e/capture_snapshots.sh",
+    "lingui:extract": "lingui extract --clean && node ./scripts/lingui-sort.js",
+    "lingui:compile": "lingui compile --typescript",
+    prepare: "lefthook install"
+  },
+  dependencies: {
+    "@anthropic-ai/claude-agent-sdk": "0.1.30",
+    "@anthropic-ai/claude-code": "2.0.24",
+    "@anthropic-ai/sdk": "0.67.0",
+    "@effect/cluster": "0.55.0",
+    "@effect/experimental": "0.57.11",
+    "@effect/platform": "0.93.6",
+    "@effect/platform-node": "0.103.0",
+    "@effect/rpc": "0.72.2",
+    "@effect/sql": "0.48.6",
+    "@effect/workflow": "0.15.1",
+    "@hono/node-server": "1.19.5",
+    "@hono/zod-validator": "0.7.4",
+    "@lingui/core": "5.5.1",
+    "@lingui/react": "5.5.1",
+    "@radix-ui/react-avatar": "1.1.10",
+    "@radix-ui/react-checkbox": "1.3.3",
+    "@radix-ui/react-collapsible": "1.1.12",
+    "@radix-ui/react-dialog": "1.1.15",
+    "@radix-ui/react-hover-card": "1.1.15",
+    "@radix-ui/react-popover": "1.1.15",
+    "@radix-ui/react-select": "2.2.6",
+    "@radix-ui/react-slot": "1.2.3",
+    "@radix-ui/react-tabs": "1.1.13",
+    "@radix-ui/react-tooltip": "1.2.8",
+    "@tailwindcss/vite": "4.1.16",
+    "@tanstack/react-devtools": "0.7.8",
+    "@tanstack/react-query": "5.90.5",
+    "@tanstack/react-router": "1.133.32",
+    "@tanstack/react-router-devtools": "1.133.32",
+    "class-variance-authority": "0.7.1",
+    clsx: "2.1.1",
+    commander: "^14.0.2",
+    "date-fns": "4.1.0",
+    effect: "3.19.9",
+    "es-toolkit": "1.41.0",
+    hono: "4.10.3",
+    jotai: "2.15.0",
+    "lucide-react": "0.548.0",
+    minisearch: "7.2.0",
+    "parse-git-diff": "0.0.19",
+    prexit: "2.3.0",
+    react: "19.2.0",
+    "react-dom": "19.2.0",
+    "react-error-boundary": "6.0.0",
+    "react-helmet-async": "2.0.5",
+    "react-markdown": "10.1.0",
+    "react-syntax-highlighter": "15.6.6",
+    "remark-gfm": "4.0.1",
+    sonner: "2.0.7",
+    "tailwind-merge": "3.3.1",
+    ulid: "3.0.1",
+    zod: "4.1.13"
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.3.1",
+    "@effect/language-service": "0.60.0",
+    "@lingui/cli": "5.5.1",
+    "@lingui/conf": "5.5.1",
+    "@lingui/format-json": "5.5.1",
+    "@lingui/loader": "5.5.1",
+    "@lingui/vite-plugin": "5.5.1",
+    "@tailwindcss/postcss": "4.1.16",
+    "@tanstack/router-plugin": "1.133.32",
+    "@tsconfig/strictest": "2.0.6",
+    "@types/node": "24.9.1",
+    "@types/react": "19.2.2",
+    "@types/react-dom": "19.2.2",
+    "@types/react-syntax-highlighter": "15.5.13",
+    "@vitejs/plugin-react-swc": "4.2.0",
+    dotenv: "17.2.3",
+    esbuild: "0.25.11",
+    lefthook: "2.0.8",
+    "npm-run-all2": "8.0.4",
+    playwright: "1.56.1",
+    "release-it": "19.0.5",
+    "release-it-pnpm": "4.6.6",
+    tailwindcss: "4.1.16",
+    tsx: "4.20.6",
+    "tw-animate-css": "1.4.0",
+    typescript: "5.9.3",
+    vite: "7.1.12",
+    vitest: "4.0.3"
+  },
+  packageManager: "pnpm@10.18.3+sha512.bbd16e6d7286fd7e01f6b3c0b3c932cda2965c06a908328f74663f10a9aea51f1129eea615134bf992831b009eabe167ecb7008b597f40ff9bc75946aadfb08d"
+};
+
+// src/server/core/platform/services/DeprecatedEnvDetector.ts
+import { Console, Effect } from "effect";
+var DEPRECATED_ENVS = {
+  // Removed in PR #101
+  CLAUDE_CODE_VIEWER_AUTH_PASSWORD: {
+    type: "removed",
+    newEnv: "CCV_PASSWORD",
+    cliOption: "--password"
+  },
+  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: {
+    type: "removed",
+    newEnv: "CCV_CC_EXECUTABLE_PATH",
+    cliOption: "--executable"
+  }
+};
+var getOptionalEnv = (key) => {
+  return process.env[key] ?? void 0;
+};
+var detectDeprecatedEnvs = () => {
+  const warnings = [];
+  for (const [envKey, config] of Object.entries(DEPRECATED_ENVS)) {
+    const value = getOptionalEnv(envKey);
+    if (value !== void 0) {
+      if (config.type === "removed") {
+        warnings.push({
+          type: "removed",
+          envKey,
+          message: `Environment variable ${envKey} has been removed.`,
+          suggestion: config.newEnv ? `Please use ${config.newEnv} environment variable or ${config.cliOption} CLI option instead.` : `Please use ${config.cliOption} CLI option instead.`
+        });
+      } else {
+        warnings.push({
+          type: "deprecated",
+          envKey,
+          message: `Environment variable ${envKey} is deprecated and will be removed in a future release.`,
+          suggestion: config.newEnv ? `Please migrate to ${config.newEnv} environment variable or ${config.cliOption} CLI option.` : `Please use ${config.cliOption} CLI option instead.`
+        });
+      }
+    }
+  }
+  return warnings;
+};
+var formatWarning = (warning) => {
+  const prefix = warning.type === "removed" ? "\u274C REMOVED" : "\u26A0\uFE0F  DEPRECATED";
+  return `${prefix}: ${warning.message}
+   \u2192 ${warning.suggestion}`;
+};
+var checkDeprecatedEnvs = Effect.gen(function* () {
+  const warnings = detectDeprecatedEnvs();
+  if (warnings.length === 0) {
+    return;
+  }
+  const hasRemovedEnvs = warnings.some((warning) => warning.type === "removed");
+  yield* Console.log("");
+  yield* Console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  yield* Console.log("  Migration Guide");
+  yield* Console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  yield* Console.log("");
+  for (const warning of warnings) {
+    yield* Console.log(formatWarning(warning));
+    yield* Console.log("");
+  }
+  yield* Console.log("For more details, see:");
+  yield* Console.log(
+    "  https://github.com/d-kimuson/claude-code-viewer#configuration"
+  );
+  yield* Console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  yield* Console.log("");
+  if (hasRemovedEnvs) {
+    yield* Effect.fail(
+      new Error(
+        "Cannot start server: removed environment variables detected. Please update your configuration."
+      )
+    );
+  }
+});
+
+// src/server/startServer.ts
 import { readFile as readFile2 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 import { NodeContext as NodeContext2 } from "@effect/platform-node";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Effect as Effect46 } from "effect";
+import { Effect as Effect48 } from "effect";
 
 // src/server/core/agent-session/index.ts
 import { Layer as Layer3 } from "effect";
 
 // src/server/core/agent-session/infrastructure/AgentSessionRepository.ts
 import { FileSystem, Path } from "@effect/platform";
-import { Context, Effect, Layer } from "effect";
+import { Context, Effect as Effect2, Layer } from "effect";
 
 // src/lib/conversation-schema/index.ts
 import { z as z16 } from "zod";
@@ -197,6 +408,12 @@ var QueueOperationEntrySchema = z11.union([
     operation: z11.literal("dequeue"),
     sessionId: z11.string(),
     timestamp: z11.iso.datetime()
+  }),
+  z11.object({
+    type: z11.literal("queue-operation"),
+    operation: z11.literal("remove"),
+    sessionId: z11.string(),
+    timestamp: z11.iso.datetime()
   })
 ]);
 
@@ -210,14 +427,40 @@ var SummaryEntrySchema = z12.object({
 
 // src/lib/conversation-schema/entry/SystemEntrySchema.ts
 import { z as z13 } from "zod";
-var SystemEntrySchema = BaseEntrySchema.extend({
-  // discriminator
+var HookInfoSchema = z13.object({
+  command: z13.string()
+});
+var SystemEntryWithContentSchema = BaseEntrySchema.extend({
   type: z13.literal("system"),
-  // required
   content: z13.string(),
   toolUseID: z13.string(),
+  level: z13.enum(["info"]),
+  subtype: z13.undefined().optional()
+});
+var StopHookSummaryEntrySchema = BaseEntrySchema.extend({
+  type: z13.literal("system"),
+  subtype: z13.literal("stop_hook_summary"),
+  toolUseID: z13.string(),
+  level: z13.enum(["info", "suggestion"]),
+  slug: z13.string().optional(),
+  hookCount: z13.number(),
+  hookInfos: z13.array(HookInfoSchema),
+  hookErrors: z13.array(z13.unknown()),
+  preventedContinuation: z13.boolean(),
+  stopReason: z13.string(),
+  hasOutput: z13.boolean()
+});
+var LocalCommandEntrySchema = BaseEntrySchema.extend({
+  type: z13.literal("system"),
+  subtype: z13.literal("local_command"),
+  content: z13.string(),
   level: z13.enum(["info"])
 });
+var SystemEntrySchema = z13.union([
+  StopHookSummaryEntrySchema,
+  LocalCommandEntrySchema,
+  SystemEntryWithContentSchema
+]);
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
 import { z as z15 } from "zod";
@@ -287,10 +530,10 @@ var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
 };
 
 // src/server/core/agent-session/infrastructure/AgentSessionRepository.ts
-var LayerImpl = Effect.gen(function* () {
+var LayerImpl = Effect2.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const getAgentSessionByAgentId = (projectId, agentId) => Effect.gen(function* () {
+  const getAgentSessionByAgentId = (projectId, agentId) => Effect2.gen(function* () {
     const projectPath = decodeProjectId(projectId);
     const agentFilePath = path.resolve(projectPath, `agent-${agentId}.jsonl`);
     const exists = yield* fs.exists(agentFilePath);
@@ -314,10 +557,10 @@ var AgentSessionRepository = class extends Context.Tag(
 };
 
 // src/server/core/agent-session/presentation/AgentSessionController.ts
-import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
-var LayerImpl2 = Effect2.gen(function* () {
+import { Context as Context2, Effect as Effect3, Layer as Layer2 } from "effect";
+var LayerImpl2 = Effect3.gen(function* () {
   const repository = yield* AgentSessionRepository;
-  const getAgentSession = (params) => Effect2.gen(function* () {
+  const getAgentSession = (params) => Effect3.gen(function* () {
     const { projectId, agentId } = params;
     const conversations = yield* repository.getAgentSessionByAgentId(
       projectId,
@@ -357,80 +600,78 @@ var AgentSessionLayer = Layer3.mergeAll(AgentSessionRepository.Live);
 
 // src/server/core/claude-code/presentation/ClaudeCodeController.ts
 import { FileSystem as FileSystem6, Path as Path8 } from "@effect/platform";
-import { Context as Context9, Effect as Effect12, Layer as Layer11 } from "effect";
+import { Context as Context9, Effect as Effect13, Layer as Layer11 } from "effect";
 
 // src/server/core/platform/services/ApplicationContext.ts
 import { homedir } from "node:os";
 import { Path as Path2 } from "@effect/platform";
-import { Effect as Effect4, Context as EffectContext, Layer as Layer5 } from "effect";
+import { Effect as Effect5, Context as EffectContext, Layer as Layer5 } from "effect";
 
-// src/server/core/platform/services/EnvService.ts
-import { Context as Context3, Effect as Effect3, Layer as Layer4, Ref } from "effect";
-
-// src/server/core/platform/schema.ts
-import { z as z17 } from "zod";
-var envSchema = z17.object({
-  NODE_ENV: z17.enum(["development", "production", "test"]).optional().default("development"),
-  GLOBAL_CLAUDE_DIR: z17.string().optional(),
-  NEXT_PHASE: z17.string().optional(),
-  PORT: z17.string().optional().default("3000").transform((val) => parseInt(val, 10)),
-  PATH: z17.string().optional(),
-  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: z17.string().optional(),
-  CLAUDE_CODE_VIEWER_AUTH_PASSWORD: z17.string().optional()
-});
-
-// src/server/core/platform/services/EnvService.ts
-var LayerImpl3 = Effect3.gen(function* () {
-  const envRef = yield* Ref.make(void 0);
-  const parseEnv = () => {
-    const parsed = envSchema.safeParse(process.env);
-    if (!parsed.success) {
-      console.error(parsed.error);
-      throw new Error(`Invalid environment variables: ${parsed.error.message}`);
-    }
-    return parsed.data;
-  };
-  const getEnv = (key) => {
-    return Effect3.gen(function* () {
-      yield* Ref.update(envRef, (existingEnv) => {
-        if (existingEnv === void 0) {
-          return parseEnv();
-        }
-        return existingEnv;
+// src/server/core/platform/services/CcvOptionsService.ts
+import { Context as Context3, Effect as Effect4, Layer as Layer4, Ref } from "effect";
+var getOptionalEnv2 = (key) => {
+  return process.env[key] ?? void 0;
+};
+var LayerImpl3 = Effect4.gen(function* () {
+  const ccvOptionsRef = yield* Ref.make(void 0);
+  const loadCliOptions = (cliOptions) => {
+    return Effect4.gen(function* () {
+      yield* Ref.update(ccvOptionsRef, () => {
+        return {
+          port: Number.parseInt(
+            cliOptions.port ?? getOptionalEnv2("PORT") ?? "3000",
+            10
+          ),
+          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")
+        };
       });
-      const env = yield* Ref.get(envRef);
-      if (env === void 0) {
-        throw new Error(
-          "Unexpected error: Environment variables are not loaded"
-        );
+    });
+  };
+  const getCcvOptions = (key) => {
+    return Effect4.gen(function* () {
+      const ccvOptions = yield* Ref.get(ccvOptionsRef);
+      if (ccvOptions === void 0) {
+        throw new Error("Unexpected error: CCV options are not loaded");
       }
-      return env[key];
+      return ccvOptions[key];
     });
   };
   return {
-    getEnv
+    loadCliOptions,
+    getCcvOptions
   };
 });
-var EnvService = class extends Context3.Tag("EnvService")() {
+var CcvOptionsService = class extends Context3.Tag("CcvOptionsService")() {
   static {
     this.Live = Layer4.effect(this, LayerImpl3);
   }
 };
 
 // src/server/core/platform/services/ApplicationContext.ts
-var LayerImpl4 = Effect4.gen(function* () {
+var LayerImpl4 = Effect5.gen(function* () {
   const path = yield* Path2.Path;
-  const envService = yield* EnvService;
-  const globalClaudeDirectoryPath = yield* envService.getEnv("GLOBAL_CLAUDE_DIR").pipe(
-    Effect4.map(
-      (envVar) => envVar === void 0 ? path.resolve(homedir(), ".claude") : path.resolve(envVar)
-    )
-  );
-  const claudeCodePaths = {
-    globalClaudeDirectoryPath,
-    claudeCommandsDirPath: path.resolve(globalClaudeDirectoryPath, "commands"),
-    claudeProjectsDirPath: path.resolve(globalClaudeDirectoryPath, "projects")
-  };
+  const ccvOptionsService = yield* CcvOptionsService;
+  const claudeCodePaths = Effect5.gen(function* () {
+    const globalClaudeDirectoryPath = yield* ccvOptionsService.getCcvOptions("claudeDir").pipe(
+      Effect5.map(
+        (envVar) => envVar === void 0 ? path.resolve(homedir(), ".claude") : path.resolve(envVar)
+      )
+    );
+    return {
+      globalClaudeDirectoryPath,
+      claudeCommandsDirPath: path.resolve(
+        globalClaudeDirectoryPath,
+        "commands"
+      ),
+      claudeProjectsDirPath: path.resolve(
+        globalClaudeDirectoryPath,
+        "projects"
+      )
+    };
+  });
   return {
     claudeCodePaths
   };
@@ -443,20 +684,20 @@ var ApplicationContext = class extends EffectContext.Tag("ApplicationContext")()
 
 // src/server/core/project/infrastructure/ProjectRepository.ts
 import { FileSystem as FileSystem4, Path as Path5 } from "@effect/platform";
-import { Context as Context7, Effect as Effect8, Layer as Layer9, Option as Option2 } from "effect";
+import { Context as Context7, Effect as Effect9, Layer as Layer9, Option as Option2 } from "effect";
 
 // src/server/core/project/services/ProjectMetaService.ts
 import { FileSystem as FileSystem3, Path as Path4 } from "@effect/platform";
-import { Context as Context6, Effect as Effect7, Layer as Layer8, Option, Ref as Ref3 } from "effect";
-import { z as z19 } from "zod";
+import { Context as Context6, Effect as Effect8, Layer as Layer8, Option, Ref as Ref3 } from "effect";
+import { z as z18 } from "zod";
 
 // src/server/lib/storage/FileCacheStorage/index.ts
-import { Context as Context5, Effect as Effect6, Layer as Layer7, Ref as Ref2, Runtime } from "effect";
+import { Context as Context5, Effect as Effect7, Layer as Layer7, Ref as Ref2, Runtime } from "effect";
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
 import { FileSystem as FileSystem2, Path as Path3 } from "@effect/platform";
-import { Context as Context4, Effect as Effect5, Layer as Layer6 } from "effect";
-import { z as z18 } from "zod";
+import { Context as Context4, Effect as Effect6, Layer as Layer6 } from "effect";
+import { z as z17 } from "zod";
 
 // src/server/lib/config/paths.ts
 import { homedir as homedir2 } from "node:os";
@@ -468,13 +709,13 @@ var claudeCodeViewerCacheDirPath = resolve(
 );
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
-var saveSchema = z18.array(z18.tuple([z18.string(), z18.unknown()]));
-var LayerImpl5 = Effect5.gen(function* () {
+var saveSchema = z17.array(z17.tuple([z17.string(), z17.unknown()]));
+var LayerImpl5 = Effect6.gen(function* () {
   const path = yield* Path3.Path;
   const getCacheFilePath = (key) => path.resolve(claudeCodeViewerCacheDirPath, `${key}.json`);
   const load = (key) => {
     const cacheFilePath = getCacheFilePath(key);
-    return Effect5.gen(function* () {
+    return Effect6.gen(function* () {
       const fs = yield* FileSystem2.FileSystem;
       if (!(yield* fs.exists(claudeCodeViewerCacheDirPath))) {
         yield* fs.makeDirectory(claudeCodeViewerCacheDirPath, {
@@ -505,7 +746,7 @@ var LayerImpl5 = Effect5.gen(function* () {
   };
   const save = (key, entries) => {
     const cacheFilePath = getCacheFilePath(key);
-    return Effect5.gen(function* () {
+    return Effect6.gen(function* () {
       const fs = yield* FileSystem2.FileSystem;
       yield* fs.writeFileString(cacheFilePath, JSON.stringify(entries));
     });
@@ -525,10 +766,10 @@ var PersistentService = class extends Context4.Tag("PersistentService")() {
 var FileCacheStorage = () => Context5.GenericTag("FileCacheStorage");
 var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
   FileCacheStorage(),
-  Effect6.gen(function* () {
+  Effect7.gen(function* () {
     const persistentService = yield* PersistentService;
-    const runtime = yield* Effect6.runtime();
-    const storageRef = yield* Effect6.gen(function* () {
+    const runtime = yield* Effect7.runtime();
+    const storageRef = yield* Effect7.gen(function* () {
       const persistedData = yield* persistentService.load(storageKey);
       const initialMap = /* @__PURE__ */ new Map();
       for (const [key, value] of persistedData) {
@@ -543,11 +784,11 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
       Runtime.runFork(runtime)(persistentService.save(storageKey, entries));
     };
     return {
-      get: (key) => Effect6.gen(function* () {
+      get: (key) => Effect7.gen(function* () {
         const storage = yield* Ref2.get(storageRef);
         return storage.get(key);
       }),
-      set: (key, value) => Effect6.gen(function* () {
+      set: (key, value) => Effect7.gen(function* () {
         const before = yield* Ref2.get(storageRef);
         const beforeString = JSON.stringify(Array.from(before.entries()));
         yield* Ref2.update(storageRef, (map) => {
@@ -560,7 +801,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
           syncToFile(Array.from(after.entries()));
         }
       }),
-      invalidate: (key) => Effect6.gen(function* () {
+      invalidate: (key) => Effect7.gen(function* () {
         const before = yield* Ref2.get(storageRef);
         if (!before.has(key)) {
           return;
@@ -572,7 +813,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
         const after = yield* Ref2.get(storageRef);
         syncToFile(Array.from(after.entries()));
       }),
-      getAll: () => Effect6.gen(function* () {
+      getAll: () => Effect7.gen(function* () {
         const storage = yield* Ref2.get(storageRef);
         return new Map(storage);
       })
@@ -581,13 +822,13 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
 );
 
 // src/server/core/project/services/ProjectMetaService.ts
-var ProjectPathSchema = z19.string().nullable();
-var LayerImpl6 = Effect7.gen(function* () {
+var ProjectPathSchema = z18.string().nullable();
+var LayerImpl6 = Effect8.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path4.Path;
   const projectPathCache = yield* FileCacheStorage();
   const projectMetaCacheRef = yield* Ref3.make(/* @__PURE__ */ new Map());
-  const extractProjectPathFromJsonl = (filePath) => Effect7.gen(function* () {
+  const extractProjectPathFromJsonl = (filePath) => Effect8.gen(function* () {
     const cached = yield* projectPathCache.get(filePath);
     if (cached !== void 0) {
       return cached;
@@ -608,7 +849,7 @@ var LayerImpl6 = Effect7.gen(function* () {
     }
     return cwd;
   });
-  const getProjectMeta = (projectId) => Effect7.gen(function* () {
+  const getProjectMeta = (projectId) => Effect8.gen(function* () {
     const metaCache = yield* Ref3.get(projectMetaCacheRef);
     const cached = metaCache.get(projectId);
     if (cached !== void 0) {
@@ -616,9 +857,9 @@ var LayerImpl6 = Effect7.gen(function* () {
     }
     const claudeProjectPath = decodeProjectId(projectId);
     const dirents = yield* fs.readDirectory(claudeProjectPath);
-    const fileEntries = yield* Effect7.all(
+    const fileEntries = yield* Effect8.all(
       dirents.filter((name) => name.endsWith(".jsonl")).map(
-        (name) => Effect7.gen(function* () {
+        (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));
@@ -652,7 +893,7 @@ var LayerImpl6 = Effect7.gen(function* () {
     });
     return projectMeta;
   });
-  const invalidateProject = (projectId) => Effect7.gen(function* () {
+  const invalidateProject = (projectId) => Effect8.gen(function* () {
     yield* Ref3.update(projectMetaCacheRef, (cache) => {
       cache.delete(projectId);
       return cache;
@@ -675,16 +916,16 @@ var ProjectMetaService = class extends Context6.Tag("ProjectMetaService")() {
 };
 
 // src/server/core/project/infrastructure/ProjectRepository.ts
-var LayerImpl7 = Effect8.gen(function* () {
+var LayerImpl7 = Effect9.gen(function* () {
   const fs = yield* FileSystem4.FileSystem;
   const path = yield* Path5.Path;
   const projectMetaService = yield* ProjectMetaService;
   const context = yield* ApplicationContext;
-  const getProject = (projectId) => Effect8.gen(function* () {
+  const getProject = (projectId) => Effect9.gen(function* () {
     const fullPath = decodeProjectId(projectId);
     const exists = yield* fs.exists(fullPath);
     if (!exists) {
-      return yield* Effect8.fail(new Error("Project not found"));
+      return yield* Effect9.fail(new Error("Project not found"));
     }
     const stat = yield* fs.stat(fullPath);
     const meta = yield* projectMetaService.getProjectMeta(projectId);
@@ -697,28 +938,28 @@ var LayerImpl7 = Effect8.gen(function* () {
       }
     };
   });
-  const getProjects = () => Effect8.gen(function* () {
+  const getProjects = () => Effect9.gen(function* () {
     const dirExists = yield* fs.exists(
-      context.claudeCodePaths.claudeProjectsDirPath
+      (yield* context.claudeCodePaths).claudeProjectsDirPath
     );
     if (!dirExists) {
       console.warn(
-        `Claude projects directory not found at ${context.claudeCodePaths.claudeProjectsDirPath}`
+        `Claude projects directory not found at ${(yield* context.claudeCodePaths).claudeProjectsDirPath}`
       );
       return { projects: [] };
     }
     const entries = yield* fs.readDirectory(
-      context.claudeCodePaths.claudeProjectsDirPath
+      (yield* context.claudeCodePaths).claudeProjectsDirPath
     );
     const projectEffects = entries.map(
-      (entry) => Effect8.gen(function* () {
+      (entry) => Effect9.gen(function* () {
         const fullPath = path.resolve(
-          context.claudeCodePaths.claudeProjectsDirPath,
+          (yield* context.claudeCodePaths).claudeProjectsDirPath,
           entry
         );
-        const stat = yield* Effect8.tryPromise(
-          () => fs.stat(fullPath).pipe(Effect8.runPromise)
-        ).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
+        const stat = yield* Effect9.tryPromise(
+          () => fs.stat(fullPath).pipe(Effect9.runPromise)
+        ).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
         if (!stat || stat.type !== "Directory") {
           return null;
         }
@@ -732,7 +973,7 @@ var LayerImpl7 = Effect8.gen(function* () {
         };
       })
     );
-    const projectsWithNulls = yield* Effect8.all(projectEffects, {
+    const projectsWithNulls = yield* Effect9.all(projectEffects, {
       concurrency: "unbounded"
     });
     const projects = projectsWithNulls.filter(
@@ -756,24 +997,24 @@ var ProjectRepository = class extends Context7.Tag("ProjectRepository")() {
 
 // src/server/core/claude-code/functions/scanCommandFiles.ts
 import { FileSystem as FileSystem5, Path as Path6 } from "@effect/platform";
-import { Effect as Effect9 } from "effect";
+import { Effect as Effect10 } from "effect";
 var pathToCommandName = (filePath, baseDir) => {
   const normalizedBaseDir = baseDir.endsWith("/") ? baseDir.slice(0, -1) : baseDir;
   const relativePath = filePath.startsWith(normalizedBaseDir) ? filePath.slice(normalizedBaseDir.length + 1) : filePath;
   return relativePath.replace(/\.md$/, "").replace(/\//g, ":");
 };
-var scanCommandFilesRecursively = (dirPath) => Effect9.gen(function* () {
+var scanCommandFilesRecursively = (dirPath) => Effect10.gen(function* () {
   const fs = yield* FileSystem5.FileSystem;
   const path = yield* Path6.Path;
-  const scanDirectory = (currentPath) => Effect9.gen(function* () {
+  const scanDirectory = (currentPath) => Effect10.gen(function* () {
     const exists = yield* fs.exists(currentPath);
     if (!exists) {
       return [];
     }
     const items = yield* fs.readDirectory(currentPath);
-    const results = yield* Effect9.forEach(
+    const results = yield* Effect10.forEach(
       items,
-      (item) => Effect9.gen(function* () {
+      (item) => Effect10.gen(function* () {
         if (item.startsWith(".")) {
           return [];
         }
@@ -792,7 +1033,7 @@ var scanCommandFilesRecursively = (dirPath) => Effect9.gen(function* () {
     return results.flat();
   });
   return yield* scanDirectory(dirPath).pipe(
-    Effect9.match({
+    Effect10.match({
       onSuccess: (items) => items,
       onFailure: () => []
     })
@@ -800,12 +1041,12 @@ var scanCommandFilesRecursively = (dirPath) => Effect9.gen(function* () {
 });
 
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-var versionSchema = z20.object({
-  major: z20.string().transform((value) => Number.parseInt(value, 10)),
-  minor: z20.string().transform((value) => Number.parseInt(value, 10)),
-  patch: z20.string().transform((value) => Number.parseInt(value, 10))
+var versionSchema = z19.object({
+  major: z19.string().transform((value) => Number.parseInt(value, 10)),
+  minor: z19.string().transform((value) => Number.parseInt(value, 10)),
+  patch: z19.string().transform((value) => Number.parseInt(value, 10))
 }).refine(
   (data) => [data.major, data.minor, data.patch].every((value) => !Number.isNaN(value))
 );
@@ -826,7 +1067,7 @@ var greaterThan = (a, b) => a.major > b.major || a.major === b.major && (a.minor
 var greaterThanOrEqual = (a, b) => equals(a, b) || greaterThan(a, b);
 
 // src/server/core/claude-code/services/ClaudeCodeService.ts
-import { Context as Context8, Data as Data2, Effect as Effect11, Layer as Layer10 } from "effect";
+import { Context as Context8, Data as Data2, Effect as Effect12, Layer as Layer10 } from "effect";
 
 // src/server/core/claude-code/functions/parseMcpListOutput.ts
 var parseMcpListOutput = (output) => {
@@ -855,7 +1096,7 @@ import {
   query as claudeCodeQuery
 } from "@anthropic-ai/claude-code";
 import { Command, Path as Path7 } from "@effect/platform";
-import { Data, Effect as Effect10 } from "effect";
+import { Data, Effect as Effect11 } from "effect";
 import { uniq } from "es-toolkit";
 var npxCacheRegExp = /_npx[/\\].*node_modules[\\/]\.bin/;
 var localNodeModulesBinRegExp = new RegExp(
@@ -874,22 +1115,20 @@ var ClaudeCodePathNotFoundError = class extends Data.TaggedError(
   "ClaudeCodePathNotFoundError"
 ) {
 };
-var resolveClaudeCodePath = Effect10.gen(function* () {
+var resolveClaudeCodePath = Effect11.gen(function* () {
   const path = yield* Path7.Path;
-  const envService = yield* EnvService;
-  const specifiedExecutablePath = yield* envService.getEnv(
-    "CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH"
-  );
+  const ccvOptionsService = yield* CcvOptionsService;
+  const specifiedExecutablePath = yield* ccvOptionsService.getCcvOptions("executable");
   if (specifiedExecutablePath !== void 0) {
     return path.resolve(specifiedExecutablePath);
   }
   const claudePaths = yield* Command.string(
     Command.make("which", "-a", "claude").pipe(Command.runInShell(true))
   ).pipe(
-    Effect10.map(
+    Effect11.map(
       (output) => output.split("\n").map((line) => line.trim()).filter((line) => line !== "") ?? []
     ),
-    Effect10.map(
+    Effect11.map(
       (paths) => uniq(paths).toSorted((a, b) => {
         const aPriority = claudeCodePathPriority(a);
         const bPriority = claudeCodePathPriority(b);
@@ -902,11 +1141,11 @@ var resolveClaudeCodePath = Effect10.gen(function* () {
         return 0;
       })
     ),
-    Effect10.catchAll(() => Effect10.succeed([]))
+    Effect11.catchAll(() => Effect11.succeed([]))
   );
   const resolvedClaudePath = claudePaths.at(0);
   if (resolvedClaudePath === void 0) {
-    return yield* Effect10.fail(
+    return yield* Effect11.fail(
       new ClaudeCodePathNotFoundError({
         message: "Claude Code CLI not found in any location"
       })
@@ -914,7 +1153,7 @@ var resolveClaudeCodePath = Effect10.gen(function* () {
   }
   return resolvedClaudePath;
 });
-var Config = Effect10.gen(function* () {
+var Config = Effect11.gen(function* () {
   const claudeCodeExecutablePath = yield* resolveClaudeCodePath;
   const claudeCodeVersion = fromCLIString(
     yield* Command.string(Command.make(claudeCodeExecutablePath, "--version"))
@@ -924,7 +1163,7 @@ var Config = Effect10.gen(function* () {
     claudeCodeVersion
   };
 });
-var getMcpListOutput = (projectCwd) => Effect10.gen(function* () {
+var getMcpListOutput = (projectCwd) => Effect11.gen(function* () {
   const { claudeCodeExecutablePath } = yield* Config;
   const output = yield* Command.string(
     Command.make(
@@ -964,7 +1203,7 @@ var getAvailableFeatures = (claudeCodeVersion) => ({
 });
 var query = (prompt, options) => {
   const { canUseTool, permissionMode, ...baseOptions } = options;
-  return Effect10.gen(function* () {
+  return Effect11.gen(function* () {
     const { claudeCodeExecutablePath, claudeCodeVersion } = yield* Config;
     const availableFeatures = getAvailableFeatures(claudeCodeVersion);
     const options2 = {
@@ -1014,23 +1253,23 @@ var ProjectPathNotFoundError = class extends Data2.TaggedError(
   "ProjectPathNotFoundError"
 ) {
 };
-var LayerImpl8 = Effect11.gen(function* () {
+var LayerImpl8 = Effect12.gen(function* () {
   const projectRepository = yield* ProjectRepository;
-  const getClaudeCodeMeta = () => Effect11.gen(function* () {
+  const getClaudeCodeMeta = () => Effect12.gen(function* () {
     const config = yield* Config;
     return config;
   });
-  const getAvailableFeatures2 = () => Effect11.gen(function* () {
+  const getAvailableFeatures2 = () => Effect12.gen(function* () {
     const config = yield* Config;
     const features = getAvailableFeatures(
       config.claudeCodeVersion
     );
     return features;
   });
-  const getMcpList = (projectId) => Effect11.gen(function* () {
+  const getMcpList = (projectId) => Effect12.gen(function* () {
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
-      return yield* Effect11.fail(new ProjectPathNotFoundError({ projectId }));
+      return yield* Effect12.fail(new ProjectPathNotFoundError({ projectId }));
     }
     const output = yield* getMcpListOutput(
       project.meta.projectPath
@@ -1050,17 +1289,17 @@ var ClaudeCodeService = class extends Context8.Tag("ClaudeCodeService")() {
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeController.ts
-var LayerImpl9 = Effect12.gen(function* () {
+var LayerImpl9 = Effect13.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeService = yield* ClaudeCodeService;
   const context = yield* ApplicationContext;
   yield* FileSystem6.FileSystem;
   const path = yield* Path8.Path;
-  const getClaudeCommands = (options) => Effect12.gen(function* () {
+  const getClaudeCommands = (options) => Effect13.gen(function* () {
     const { projectId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     const globalCommands = yield* scanCommandFilesRecursively(
-      context.claudeCodePaths.claudeCommandsDirPath
+      (yield* context.claudeCodePaths).claudeCommandsDirPath
     );
     const projectCommands = project.meta.projectPath === null ? [] : yield* scanCommandFilesRecursively(
       path.resolve(project.meta.projectPath, ".claude", "commands")
@@ -1074,7 +1313,7 @@ var LayerImpl9 = Effect12.gen(function* () {
       status: 200
     };
   });
-  const getMcpListRoute = (options) => Effect12.gen(function* () {
+  const getMcpListRoute = (options) => Effect13.gen(function* () {
     const { projectId } = options;
     const servers = yield* claudeCodeService.getMcpList(projectId);
     return {
@@ -1082,7 +1321,7 @@ var LayerImpl9 = Effect12.gen(function* () {
       status: 200
     };
   });
-  const getClaudeCodeMeta = () => Effect12.gen(function* () {
+  const getClaudeCodeMeta = () => Effect13.gen(function* () {
     const config = yield* claudeCodeService.getClaudeCodeMeta();
     return {
       response: {
@@ -1092,7 +1331,7 @@ var LayerImpl9 = Effect12.gen(function* () {
       status: 200
     };
   });
-  const getAvailableFeatures2 = () => Effect12.gen(function* () {
+  const getAvailableFeatures2 = () => Effect13.gen(function* () {
     const features = yield* claudeCodeService.getAvailableFeatures();
     const featuresList = Object.entries(features).flatMap(([key, value]) => {
       return [
@@ -1121,15 +1360,15 @@ var ClaudeCodeController = class extends Context9.Tag("ClaudeCodeController")()
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodePermissionController.ts
-import { Context as Context12, Effect as Effect15, Layer as Layer14 } from "effect";
+import { Context as Context12, Effect as Effect16, Layer as Layer14 } from "effect";
 
 // src/server/core/claude-code/services/ClaudeCodePermissionService.ts
-import { Context as Context11, Effect as Effect14, Layer as Layer13, Ref as Ref4 } from "effect";
+import { Context as Context11, Effect as Effect15, Layer as Layer13, Ref as Ref4 } from "effect";
 import { ulid } from "ulid";
 
 // src/server/core/events/services/EventBus.ts
-import { Context as Context10, Effect as Effect13, Layer as Layer12 } from "effect";
-var layerImpl = Effect13.gen(function* () {
+import { Context as Context10, Effect as Effect14, Layer as Layer12 } from "effect";
+var layerImpl = Effect14.gen(function* () {
   const listenersMap = /* @__PURE__ */ new Map();
   const getListeners = (event) => {
     if (!listenersMap.has(event)) {
@@ -1137,7 +1376,7 @@ var layerImpl = Effect13.gen(function* () {
     }
     return listenersMap.get(event);
   };
-  const emit = (event, data) => Effect13.gen(function* () {
+  const emit = (event, data) => Effect14.gen(function* () {
     const listeners = getListeners(event);
     void Promise.allSettled(
       Array.from(listeners).map(async (listener) => {
@@ -1145,11 +1384,11 @@ var layerImpl = Effect13.gen(function* () {
       })
     );
   });
-  const on = (event, listener) => Effect13.sync(() => {
+  const on = (event, listener) => Effect14.sync(() => {
     const listeners = getListeners(event);
     listeners.add(listener);
   });
-  const off = (event, listener) => Effect13.sync(() => {
+  const off = (event, listener) => Effect14.sync(() => {
     const listeners = getListeners(event);
     listeners.delete(listener);
   });
@@ -1166,11 +1405,11 @@ var EventBus = class extends Context10.Tag("EventBus")() {
 };
 
 // src/server/core/claude-code/services/ClaudeCodePermissionService.ts
-var LayerImpl10 = Effect14.gen(function* () {
+var LayerImpl10 = Effect15.gen(function* () {
   const pendingPermissionRequestsRef = yield* Ref4.make(/* @__PURE__ */ new Map());
   const permissionResponsesRef = yield* Ref4.make(/* @__PURE__ */ new Map());
   const eventBus = yield* EventBus;
-  const waitPermissionResponse = (request, options) => Effect14.gen(function* () {
+  const waitPermissionResponse = (request, options) => Effect15.gen(function* () {
     yield* Ref4.update(pendingPermissionRequestsRef, (requests) => {
       requests.set(request.id, request);
       return requests;
@@ -1186,14 +1425,14 @@ var LayerImpl10 = Effect14.gen(function* () {
       if (response !== null) {
         break;
       }
-      yield* Effect14.sleep(1e3);
+      yield* Effect15.sleep(1e3);
       passedMs += 1e3;
     }
     return response;
   });
   const createCanUseToolRelatedOptions = (options) => {
     const { taskId, userConfig, sessionId } = options;
-    return Effect14.gen(function* () {
+    return Effect15.gen(function* () {
       const claudeCodeConfig = yield* Config;
       if (!getAvailableFeatures(claudeCodeConfig.claudeCodeVersion).canUseTool) {
         return {
@@ -1222,7 +1461,7 @@ var LayerImpl10 = Effect14.gen(function* () {
           toolInput,
           timestamp: Date.now()
         };
-        const response = await Effect14.runPromise(
+        const response = await Effect15.runPromise(
           waitPermissionResponse(permissionRequest, { timeoutMs: 6e4 })
         );
         if (response === null) {
@@ -1249,7 +1488,7 @@ var LayerImpl10 = Effect14.gen(function* () {
       };
     });
   };
-  const respondToPermissionRequest = (response) => Effect14.gen(function* () {
+  const respondToPermissionRequest = (response) => Effect15.gen(function* () {
     yield* Ref4.update(permissionResponsesRef, (responses) => {
       responses.set(response.permissionRequestId, response);
       return responses;
@@ -1273,11 +1512,11 @@ var ClaudeCodePermissionService = class extends Context11.Tag(
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodePermissionController.ts
-var LayerImpl11 = Effect15.gen(function* () {
+var LayerImpl11 = Effect16.gen(function* () {
   const claudeCodePermissionService = yield* ClaudeCodePermissionService;
-  const permissionResponse = (options) => Effect15.sync(() => {
+  const permissionResponse = (options) => Effect16.sync(() => {
     const { permissionResponse: permissionResponse2 } = options;
-    Effect15.runFork(
+    Effect16.runFork(
       claudeCodePermissionService.respondToPermissionRequest(
         permissionResponse2
       )
@@ -1302,10 +1541,10 @@ var ClaudeCodePermissionController = class extends Context12.Tag(
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeSessionProcessController.ts
-import { Context as Context19, Effect as Effect24, Layer as Layer21 } from "effect";
+import { Context as Context19, Effect as Effect25, Layer as Layer21 } from "effect";
 
 // src/server/core/platform/services/UserConfigService.ts
-import { Context as Context13, Effect as Effect16, Layer as Layer15, Ref as Ref5 } from "effect";
+import { Context as Context13, Effect as Effect17, Layer as Layer15, Ref as Ref5 } from "effect";
 
 // src/lib/i18n/localeDetection.ts
 var DEFAULT_LOCALE = "en";
@@ -1357,7 +1596,7 @@ var detectLocaleFromAcceptLanguage = (header) => {
 };
 
 // src/server/core/platform/services/UserConfigService.ts
-var LayerImpl12 = Effect16.gen(function* () {
+var LayerImpl12 = Effect17.gen(function* () {
   const configRef = yield* Ref5.make({
     hideNoUserMessageSession: true,
     unifySameTitleSession: false,
@@ -1366,10 +1605,10 @@ var LayerImpl12 = Effect16.gen(function* () {
     locale: DEFAULT_LOCALE,
     theme: "system"
   });
-  const setUserConfig = (newConfig) => Effect16.gen(function* () {
+  const setUserConfig = (newConfig) => Effect17.gen(function* () {
     yield* Ref5.update(configRef, () => newConfig);
   });
-  const getUserConfig = () => Effect16.gen(function* () {
+  const getUserConfig = () => Effect17.gen(function* () {
     const config = yield* Ref5.get(configRef);
     return config;
   });
@@ -1385,7 +1624,7 @@ var UserConfigService = class extends Context13.Tag("UserConfigService")() {
 };
 
 // src/server/core/claude-code/services/ClaudeCodeLifeCycleService.ts
-import { Context as Context18, Effect as Effect23, Layer as Layer20, Runtime as Runtime2 } from "effect";
+import { Context as Context18, Effect as Effect24, Layer as Layer20, Runtime as Runtime2 } from "effect";
 import { ulid as ulid2 } from "ulid";
 
 // src/lib/controllablePromise.ts
@@ -1416,29 +1655,29 @@ var controllablePromise = () => {
 
 // src/server/core/session/infrastructure/SessionRepository.ts
 import { FileSystem as FileSystem9, Path as Path11 } from "@effect/platform";
-import { Context as Context16, Effect as Effect20, Layer as Layer18, Option as Option3 } from "effect";
+import { Context as Context16, Effect as Effect21, Layer as Layer18, Option as Option3 } from "effect";
 
 // src/server/core/claude-code/functions/parseUserMessage.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 var regExp = /<(?<tag>[^>]+)>(?<content>\s*[^<]*?\s*)<\/\k<tag>>/g;
-var matchSchema = z21.object({
-  tag: z21.string(),
-  content: z21.string()
+var matchSchema = z20.object({
+  tag: z20.string(),
+  content: z20.string()
 });
-var parsedUserMessageSchema = z21.union([
-  z21.object({
-    kind: z21.literal("command"),
-    commandName: z21.string(),
-    commandArgs: z21.string().optional(),
-    commandMessage: z21.string().optional()
+var parsedUserMessageSchema = z20.union([
+  z20.object({
+    kind: z20.literal("command"),
+    commandName: z20.string(),
+    commandArgs: z20.string().optional(),
+    commandMessage: z20.string().optional()
   }),
-  z21.object({
-    kind: z21.literal("local-command"),
-    stdout: z21.string()
+  z20.object({
+    kind: z20.literal("local-command"),
+    stdout: z20.string()
   }),
-  z21.object({
-    kind: z21.literal("text"),
-    content: z21.string()
+  z20.object({
+    kind: z20.literal("text"),
+    content: z20.string()
   })
 ]);
 var parseUserMessage = (content) => {
@@ -1496,28 +1735,28 @@ var decodeSessionId = (projectId, sessionId) => {
 var isRegularSessionFile = (filename) => filename.endsWith(".jsonl") && !filename.startsWith("agent-");
 
 // src/server/core/session/infrastructure/VirtualConversationDatabase.ts
-import { Context as Context14, Effect as Effect17, Layer as Layer16, Ref as Ref6 } from "effect";
+import { Context as Context14, Effect as Effect18, Layer as Layer16, Ref as Ref6 } from "effect";
 var VirtualConversationDatabase = class extends Context14.Tag(
   "VirtualConversationDatabase"
 )() {
   static {
     this.Live = Layer16.effect(
       this,
-      Effect17.gen(function* () {
+      Effect18.gen(function* () {
         const storageRef = yield* Ref6.make([]);
-        const getProjectVirtualConversations = (projectId) => Effect17.gen(function* () {
+        const getProjectVirtualConversations = (projectId) => Effect18.gen(function* () {
           const conversations = yield* Ref6.get(storageRef);
           return conversations.filter(
             (conversation) => conversation.projectId === projectId
           );
         });
-        const getSessionVirtualConversation = (sessionId) => Effect17.gen(function* () {
+        const getSessionVirtualConversation = (sessionId) => Effect18.gen(function* () {
           const conversations = yield* Ref6.get(storageRef);
           return conversations.find(
             (conversation) => conversation.sessionId === sessionId
           ) ?? null;
         });
-        const createVirtualConversation2 = (projectId, sessionId, createConversations) => Effect17.gen(function* () {
+        const createVirtualConversation2 = (projectId, sessionId, createConversations) => Effect18.gen(function* () {
           yield* Ref6.update(storageRef, (conversations) => {
             const existingRecord = conversations.find(
               (record) => record.projectId === projectId && record.sessionId === sessionId
@@ -1536,7 +1775,7 @@ var VirtualConversationDatabase = class extends Context14.Tag(
             return conversations;
           });
         });
-        const deleteVirtualConversations = (sessionId) => Effect17.gen(function* () {
+        const deleteVirtualConversations = (sessionId) => Effect18.gen(function* () {
           yield* Ref6.update(storageRef, (conversations) => {
             return conversations.filter((c) => c.sessionId !== sessionId);
           });
@@ -1554,7 +1793,7 @@ var VirtualConversationDatabase = class extends Context14.Tag(
 
 // src/server/core/session/services/SessionMetaService.ts
 import { FileSystem as FileSystem8, Path as Path10 } from "@effect/platform";
-import { Context as Context15, Effect as Effect19, Layer as Layer17, Ref as Ref7 } from "effect";
+import { Context as Context15, Effect as Effect20, Layer as Layer17, Ref as Ref7 } from "effect";
 
 // src/server/core/session/constants/pricing.ts
 var MODEL_PRICING = {
@@ -1715,8 +1954,8 @@ var aggregateTokenUsageAndCost = (fileContents) => {
 
 // src/server/core/session/functions/getAgentSessionFilesForSession.ts
 import { FileSystem as FileSystem7, Path as Path9 } from "@effect/platform";
-import { Effect as Effect18 } from "effect";
-var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect18.gen(function* () {
+import { Effect as Effect19 } from "effect";
+var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect19.gen(function* () {
   const fs = yield* FileSystem7.FileSystem;
   const path = yield* Path9.Path;
   const entries = yield* fs.readDirectory(projectPath);
@@ -1726,7 +1965,7 @@ var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect18.gen(fu
   const matchingFilePaths = [];
   for (const agentFile of agentFiles) {
     const filePath = path.join(projectPath, agentFile);
-    const maybeMatches = yield* Effect18.gen(function* () {
+    const maybeMatches = yield* Effect19.gen(function* () {
       const content = yield* fs.readFileString(filePath);
       const firstLine = content.split("\n")[0];
       if (!firstLine || firstLine.trim() === "") {
@@ -1742,7 +1981,7 @@ var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect18.gen(fu
       }
       return false;
     }).pipe(
-      Effect18.catchAll(() => Effect18.succeed(false))
+      Effect19.catchAll(() => Effect19.succeed(false))
       // On any error, skip this file
     );
     if (maybeMatches) {
@@ -1809,14 +2048,14 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
   static {
     this.Live = Layer17.effect(
       this,
-      Effect19.gen(function* () {
+      Effect20.gen(function* () {
         const fs = yield* FileSystem8.FileSystem;
         const path = yield* Path10.Path;
         const firstUserMessageCache = yield* FileCacheStorage();
         const sessionMetaCacheRef = yield* Ref7.make(
           /* @__PURE__ */ new Map()
         );
-        const getFirstUserMessage = (jsonlFilePath, lines) => Effect19.gen(function* () {
+        const getFirstUserMessage = (jsonlFilePath, lines) => Effect20.gen(function* () {
           const cached = yield* firstUserMessageCache.get(jsonlFilePath);
           if (cached !== void 0) {
             return cached;
@@ -1839,7 +2078,7 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
           }
           return firstUserMessage;
         });
-        const getSessionMeta = (projectId, sessionId) => Effect19.gen(function* () {
+        const getSessionMeta = (projectId, sessionId) => Effect20.gen(function* () {
           const metaCache = yield* Ref7.get(sessionMetaCacheRef);
           const cached = metaCache.get(sessionId);
           if (cached !== void 0) {
@@ -1868,12 +2107,12 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
             projectPath,
             actualSessionId
           ).pipe(
-            Effect19.provide(Layer17.succeed(FileSystem8.FileSystem, fs)),
-            Effect19.provide(Layer17.succeed(Path10.Path, path))
+            Effect20.provide(Layer17.succeed(FileSystem8.FileSystem, fs)),
+            Effect20.provide(Layer17.succeed(Path10.Path, path))
           ) : [];
           const agentContents = [];
           for (const agentPath of agentFilePaths) {
-            const agentContent = yield* fs.readFileString(agentPath).pipe(Effect19.catchAll(() => Effect19.succeed("")));
+            const agentContent = yield* fs.readFileString(agentPath).pipe(Effect20.catchAll(() => Effect20.succeed("")));
             if (agentContent !== "") {
               agentContents.push(agentContent);
             }
@@ -1895,7 +2134,7 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
           });
           return sessionMeta;
         });
-        const invalidateSession = (_projectId, sessionId) => Effect19.gen(function* () {
+        const invalidateSession = (_projectId, sessionId) => Effect20.gen(function* () {
           yield* Ref7.update(sessionMetaCacheRef, (cache) => {
             cache.delete(sessionId);
             return cache;
@@ -1919,18 +2158,18 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
 };
 
 // src/server/core/session/infrastructure/SessionRepository.ts
-var LayerImpl13 = Effect20.gen(function* () {
+var LayerImpl13 = Effect21.gen(function* () {
   const fs = yield* FileSystem9.FileSystem;
   const path = yield* Path11.Path;
   const sessionMetaService = yield* SessionMetaService;
   const virtualConversationDatabase = yield* VirtualConversationDatabase;
-  const getSession = (projectId, sessionId) => Effect20.gen(function* () {
+  const getSession = (projectId, sessionId) => Effect21.gen(function* () {
     const sessionPath = decodeSessionId(projectId, sessionId);
     const virtualConversation = yield* virtualConversationDatabase.getSessionVirtualConversation(
       sessionId
     );
     const exists = yield* fs.exists(sessionPath);
-    const sessionDetail = yield* exists ? Effect20.gen(function* () {
+    const sessionDetail = yield* exists ? Effect21.gen(function* () {
       const content = yield* fs.readFileString(sessionPath);
       const allLines = content.split("\n").filter((line) => line.trim());
       const conversations = parseJsonl(allLines.join("\n"));
@@ -1968,7 +2207,7 @@ var LayerImpl13 = Effect20.gen(function* () {
       return sessionDetail2;
     }) : (() => {
       if (virtualConversation === null) {
-        return Effect20.succeed(null);
+        return Effect21.succeed(null);
       }
       const lastConversation = virtualConversation.conversations.filter(
         (conversation) => conversation.type === "user" || conversation.type === "assistant" || conversation.type === "system"
@@ -1998,13 +2237,13 @@ var LayerImpl13 = Effect20.gen(function* () {
         conversations: virtualConversation.conversations,
         lastModifiedAt: lastConversation !== void 0 ? new Date(lastConversation.timestamp) : /* @__PURE__ */ new Date()
       };
-      return Effect20.succeed(virtualSession);
+      return Effect21.succeed(virtualSession);
     })();
     return {
       session: sessionDetail
     };
   });
-  const getSessions = (projectId, options) => Effect20.gen(function* () {
+  const getSessions = (projectId, options) => Effect21.gen(function* () {
     const { maxCount = 20, cursor } = options ?? {};
     const claudeProjectPath = decodeProjectId(projectId);
     const dirExists = yield* fs.exists(claudeProjectPath);
@@ -2012,8 +2251,8 @@ var LayerImpl13 = Effect20.gen(function* () {
       console.warn(`Project directory not found at ${claudeProjectPath}`);
       return { sessions: [] };
     }
-    const dirents = yield* Effect20.tryPromise({
-      try: () => fs.readDirectory(claudeProjectPath).pipe(Effect20.runPromise),
+    const dirents = yield* Effect21.tryPromise({
+      try: () => fs.readDirectory(claudeProjectPath).pipe(Effect21.runPromise),
       catch: (error) => {
         console.warn(
           `Failed to read sessions for project ${projectId}:`,
@@ -2021,14 +2260,14 @@ var LayerImpl13 = Effect20.gen(function* () {
         );
         return new Error("Failed to read directory");
       }
-    }).pipe(Effect20.catchAll(() => Effect20.succeed([])));
+    }).pipe(Effect21.catchAll(() => Effect21.succeed([])));
     const sessionEffects = dirents.filter(isRegularSessionFile).map(
-      (entry) => Effect20.gen(function* () {
+      (entry) => Effect21.gen(function* () {
         const fullPath = path.resolve(claudeProjectPath, entry);
         const sessionId = encodeSessionId(fullPath);
-        const stat = yield* Effect20.tryPromise(
-          () => fs.stat(fullPath).pipe(Effect20.runPromise)
-        ).pipe(Effect20.catchAll(() => Effect20.succeed(null)));
+        const stat = yield* Effect21.tryPromise(
+          () => fs.stat(fullPath).pipe(Effect21.runPromise)
+        ).pipe(Effect21.catchAll(() => Effect21.succeed(null)));
         if (!stat) {
           return null;
         }
@@ -2039,7 +2278,7 @@ var LayerImpl13 = Effect20.gen(function* () {
         };
       })
     );
-    const sessionsWithNulls = yield* Effect20.all(sessionEffects, {
+    const sessionsWithNulls = yield* Effect21.all(sessionEffects, {
       concurrency: "unbounded"
     });
     const sessions = sessionsWithNulls.filter((s) => s !== null).sort(
@@ -2054,9 +2293,9 @@ var LayerImpl13 = Effect20.gen(function* () {
         index + 1,
         Math.min(index + 1 + maxCount, sessions.length)
       );
-      const sessionsWithMeta2 = yield* Effect20.all(
+      const sessionsWithMeta2 = yield* Effect21.all(
         sessionsToReturn2.map(
-          (item) => Effect20.gen(function* () {
+          (item) => Effect21.gen(function* () {
             const meta = yield* sessionMetaService.getSessionMeta(
               projectId,
               item.id
@@ -2119,9 +2358,9 @@ var LayerImpl13 = Effect20.gen(function* () {
       0,
       Math.min(maxCount, sessions.length)
     );
-    const sessionsWithMeta = yield* Effect20.all(
+    const sessionsWithMeta = yield* Effect21.all(
       sessionsToReturn.map(
-        (item) => Effect20.gen(function* () {
+        (item) => Effect21.gen(function* () {
           const meta = yield* sessionMetaService.getSessionMeta(
             projectId,
             item.id
@@ -2245,7 +2484,7 @@ var fallbackSdkMessage = (message) => {
 };
 
 // src/server/core/claude-code/models/CCSessionProcess.ts
-import { Effect as Effect21 } from "effect";
+import { Effect as Effect22 } from "effect";
 var isPublic = (process2) => {
   return process2.type === "initialized" || process2.type === "file_created" || process2.type === "paused";
 };
@@ -2256,7 +2495,7 @@ var getAliveTasks = (process2) => {
 };
 var createVirtualConversation = (process2, ctx) => {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return Effect21.gen(function* () {
+  return Effect22.gen(function* () {
     const config = yield* Config;
     const virtualConversation = {
       type: "user",
@@ -2278,7 +2517,7 @@ var createVirtualConversation = (process2, ctx) => {
 };
 
 // src/server/core/claude-code/services/ClaudeCodeSessionProcessService.ts
-import { Context as Context17, Data as Data3, Effect as Effect22, Layer as Layer19, Ref as Ref8 } from "effect";
+import { Context as Context17, Data as Data3, Effect as Effect23, Layer as Layer19, Ref as Ref8 } from "effect";
 var SessionProcessNotFoundError = class extends Data3.TaggedError(
   "SessionProcessNotFoundError"
 ) {
@@ -2297,12 +2536,12 @@ var IllegalStateChangeError = class extends Data3.TaggedError(
 };
 var TaskNotFoundError = class extends Data3.TaggedError("TaskNotFoundError") {
 };
-var LayerImpl14 = Effect22.gen(function* () {
+var LayerImpl14 = Effect23.gen(function* () {
   const processesRef = yield* Ref8.make([]);
   const eventBus = yield* EventBus;
   const startSessionProcess = (options) => {
     const { sessionDef, taskDef } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const task = {
         def: taskDef,
         status: "pending"
@@ -2325,10 +2564,10 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const continueSessionProcess = (options) => {
     const { sessionProcessId } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const process2 = yield* getSessionProcess(sessionProcessId);
       if (process2.type !== "paused") {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new SessionProcessNotPausedError({
             sessionProcessId
           })
@@ -2336,7 +2575,7 @@ var LayerImpl14 = Effect22.gen(function* () {
       }
       const [firstAliveTask] = getAliveTasks(process2);
       if (firstAliveTask !== void 0) {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new SessionProcessAlreadyAliveError({
             sessionProcessId,
             aliveTaskId: firstAliveTask.def.taskId,
@@ -2366,13 +2605,13 @@ var LayerImpl14 = Effect22.gen(function* () {
     });
   };
   const getSessionProcess = (sessionProcessId) => {
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const result = processes.find(
         (p) => p.def.sessionProcessId === sessionProcessId
       );
       if (result === void 0) {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new SessionProcessNotFoundError({ sessionProcessId })
         );
       }
@@ -2380,13 +2619,13 @@ var LayerImpl14 = Effect22.gen(function* () {
     });
   };
   const getSessionProcesses = () => {
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       return processes;
     });
   };
   const getTask = (taskId) => {
-    return Effect22.gen(function* () {
+    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);
@@ -2401,14 +2640,14 @@ var LayerImpl14 = Effect22.gen(function* () {
         ];
       }).at(0);
       if (result === void 0) {
-        return yield* Effect22.fail(new TaskNotFoundError({ taskId }));
+        return yield* Effect23.fail(new TaskNotFoundError({ taskId }));
       }
       return result;
     });
   };
   const dangerouslyChangeProcessState = (options) => {
     const { sessionProcessId, nextState } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const targetProcess = processes.find(
         (p) => p.def.sessionProcessId === sessionProcessId
@@ -2437,7 +2676,7 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const changeTaskState = (options) => {
     const { sessionProcessId, taskId, nextTask } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const { task } = yield* getTask(taskId);
       yield* Ref8.update(processesRef, (processes) => {
         return processes.map(
@@ -2458,10 +2697,10 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const toNotInitializedState = (options) => {
     const { sessionProcessId, rawUserMessage } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "pending") {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "not_initialized"
@@ -2494,10 +2733,10 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const toInitializedState = (options) => {
     const { sessionProcessId, initContext } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "not_initialized") {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "initialized"
@@ -2523,10 +2762,10 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const toFileCreatedState = (options) => {
     const { sessionProcessId } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "initialized") {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "file_created"
@@ -2552,10 +2791,10 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const toPausedState = (options) => {
     const { sessionProcessId, resultMessage } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "file_created") {
-        return yield* Effect22.fail(
+        return yield* Effect23.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "paused"
@@ -2589,7 +2828,7 @@ var LayerImpl14 = Effect22.gen(function* () {
   };
   const toCompletedState = (options) => {
     const { sessionProcessId, error } = options;
-    return Effect22.gen(function* () {
+    return Effect23.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       const currentTask = currentProcess.type === "not_initialized" || currentProcess.type === "initialized" || currentProcess.type === "file_created" ? currentProcess.currentTask : void 0;
       const newTask = currentTask !== void 0 ? error !== void 0 ? {
@@ -2651,16 +2890,16 @@ var ClaudeCodeSessionProcessService = class extends Context17.Tag(
 };
 
 // src/server/core/claude-code/services/ClaudeCodeLifeCycleService.ts
-var LayerImpl15 = Effect23.gen(function* () {
+var LayerImpl15 = Effect24.gen(function* () {
   const eventBusService = yield* EventBus;
   const sessionRepository = yield* SessionRepository;
   const sessionProcessService = yield* ClaudeCodeSessionProcessService;
   const virtualConversationDatabase = yield* VirtualConversationDatabase;
   const permissionService = yield* ClaudeCodePermissionService;
-  const runtime = yield* Effect23.runtime();
+  const runtime = yield* Effect24.runtime();
   const continueTask = (options) => {
     const { sessionProcessId, baseSessionId, input } = options;
-    return Effect23.gen(function* () {
+    return Effect24.gen(function* () {
       const { sessionProcess, task } = yield* sessionProcessService.continueSessionProcess({
         sessionProcessId,
         taskDef: {
@@ -2688,7 +2927,7 @@ var LayerImpl15 = Effect23.gen(function* () {
   };
   const startTask = (options) => {
     const { baseSession, input, userConfig } = options;
-    return Effect23.gen(function* () {
+    return Effect24.gen(function* () {
       const {
         generateMessages,
         setNextMessage,
@@ -2716,7 +2955,7 @@ var LayerImpl15 = Effect23.gen(function* () {
       const sessionFileCreatedPromise = controllablePromise();
       setMessageGeneratorHooks({
         onNewUserMessageResolved: async (input2) => {
-          Effect23.runFork(
+          Effect24.runFork(
             sessionProcessService.toNotInitializedState({
               sessionProcessId: sessionProcess.def.sessionProcessId,
               rawUserMessage: input2.text
@@ -2724,7 +2963,7 @@ var LayerImpl15 = Effect23.gen(function* () {
           );
         }
       });
-      const handleMessage = (message) => Effect23.gen(function* () {
+      const handleMessage = (message) => Effect24.gen(function* () {
         const processState = yield* sessionProcessService.getSessionProcess(
           sessionProcess.def.sessionProcessId
         );
@@ -2732,7 +2971,7 @@ var LayerImpl15 = Effect23.gen(function* () {
           return "break";
         }
         if (processState.type === "paused") {
-          yield* Effect23.die(
+          yield* Effect24.die(
             new Error("Illegal state: paused is not expected")
           );
         }
@@ -2804,7 +3043,7 @@ var LayerImpl15 = Effect23.gen(function* () {
       });
       const handleSessionProcessDaemon = async () => {
         const messageIter = await Runtime2.runPromise(runtime)(
-          Effect23.gen(function* () {
+          Effect24.gen(function* () {
             const permissionOptions = yield* permissionService.createCanUseToolRelatedOptions({
               taskId: task.def.taskId,
               userConfig,
@@ -2825,7 +3064,7 @@ var LayerImpl15 = Effect23.gen(function* () {
             const result = await Runtime2.runPromise(runtime)(
               handleMessage(fallbackMessage)
             ).catch((error) => {
-              Effect23.runFork(
+              Effect24.runFork(
                 sessionProcessService.changeTaskState({
                   sessionProcessId: sessionProcess.def.sessionProcessId,
                   taskId: task.def.taskId,
@@ -2856,7 +3095,7 @@ var LayerImpl15 = Effect23.gen(function* () {
           if (sessionFileCreatedPromise.status === "pending") {
             sessionFileCreatedPromise.reject(error);
           }
-          await Effect23.runPromise(
+          await Effect24.runPromise(
             sessionProcessService.changeTaskState({
               sessionProcessId: sessionProcess.def.sessionProcessId,
               taskId: task.def.taskId,
@@ -2879,8 +3118,8 @@ var LayerImpl15 = Effect23.gen(function* () {
         }
         throw error;
       }).finally(() => {
-        Effect23.runFork(
-          Effect23.gen(function* () {
+        Effect24.runFork(
+          Effect24.gen(function* () {
             const currentProcess = yield* sessionProcessService.getSessionProcess(
               sessionProcess.def.sessionProcessId
             );
@@ -2896,16 +3135,16 @@ var LayerImpl15 = Effect23.gen(function* () {
         daemonPromise,
         awaitSessionInitialized: async () => await sessionInitializedPromise.promise,
         awaitSessionFileCreated: async () => await sessionFileCreatedPromise.promise,
-        yieldSessionInitialized: () => Effect23.promise(() => sessionInitializedPromise.promise),
-        yieldSessionFileCreated: () => Effect23.promise(() => sessionFileCreatedPromise.promise)
+        yieldSessionInitialized: () => Effect24.promise(() => sessionInitializedPromise.promise),
+        yieldSessionFileCreated: () => Effect24.promise(() => sessionFileCreatedPromise.promise)
       };
     });
   };
-  const getPublicSessionProcesses = () => Effect23.gen(function* () {
+  const getPublicSessionProcesses = () => Effect24.gen(function* () {
     const processes = yield* sessionProcessService.getSessionProcesses();
     return processes.filter((process2) => isPublic(process2));
   });
-  const abortTask = (sessionProcessId) => Effect23.gen(function* () {
+  const abortTask = (sessionProcessId) => Effect24.gen(function* () {
     const currentProcess = yield* sessionProcessService.getSessionProcess(sessionProcessId);
     currentProcess.def.abortController.abort();
     yield* sessionProcessService.toCompletedState({
@@ -2913,7 +3152,7 @@ var LayerImpl15 = Effect23.gen(function* () {
       error: new Error("Task aborted")
     });
   });
-  const abortAllTasks = () => Effect23.gen(function* () {
+  const abortAllTasks = () => Effect24.gen(function* () {
     const processes = yield* sessionProcessService.getSessionProcesses();
     for (const process2 of processes) {
       yield* sessionProcessService.toCompletedState({
@@ -2939,11 +3178,11 @@ var ClaudeCodeLifeCycleService = class extends Context18.Tag(
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeSessionProcessController.ts
-var LayerImpl16 = Effect24.gen(function* () {
+var LayerImpl16 = Effect25.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const userConfigService = yield* UserConfigService;
-  const getSessionProcesses = () => Effect24.gen(function* () {
+  const getSessionProcesses = () => Effect25.gen(function* () {
     const publicSessionProcesses = yield* claudeCodeLifeCycleService.getPublicSessionProcesses();
     return {
       response: {
@@ -2959,7 +3198,7 @@ var LayerImpl16 = Effect24.gen(function* () {
       status: 200
     };
   });
-  const createSessionProcess = (options) => Effect24.gen(function* () {
+  const createSessionProcess = (options) => Effect25.gen(function* () {
     const { projectId, input, baseSessionId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     const userConfig = yield* userConfigService.getUserConfig();
@@ -2990,7 +3229,7 @@ var LayerImpl16 = Effect24.gen(function* () {
       }
     };
   });
-  const continueSessionProcess = (options) => Effect24.gen(function* () {
+  const continueSessionProcess = (options) => Effect25.gen(function* () {
     const { projectId, input, baseSessionId, sessionProcessId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -3030,7 +3269,7 @@ var ClaudeCodeSessionProcessController = class extends Context19.Tag(
 };
 
 // src/server/core/events/presentation/SSEController.ts
-import { Context as Context21, Effect as Effect26, Layer as Layer23 } from "effect";
+import { Context as Context21, Effect as Effect27, Layer as Layer23 } from "effect";
 
 // src/server/core/events/functions/adaptInternalEventToSSE.ts
 var adaptInternalEventToSSE = (rawStream, options) => {
@@ -3057,12 +3296,12 @@ var adaptInternalEventToSSE = (rawStream, options) => {
 };
 
 // src/server/core/events/functions/typeSafeSSE.ts
-import { Context as Context20, Effect as Effect25, Layer as Layer22 } from "effect";
+import { Context as Context20, Effect as Effect26, Layer as Layer22 } from "effect";
 import { ulid as ulid3 } from "ulid";
 var TypeSafeSSE = class extends Context20.Tag("TypeSafeSSE")() {
   static {
     this.make = (stream) => Layer22.succeed(this, {
-      writeSSE: (event, data) => Effect25.tryPromise({
+      writeSSE: (event, data) => Effect26.tryPromise({
         try: async () => {
           const id = ulid3();
           await stream.writeSSE({
@@ -3087,29 +3326,29 @@ var TypeSafeSSE = class extends Context20.Tag("TypeSafeSSE")() {
 };
 
 // src/server/core/events/presentation/SSEController.ts
-var LayerImpl17 = Effect26.gen(function* () {
+var LayerImpl17 = Effect27.gen(function* () {
   const eventBus = yield* EventBus;
-  const handleSSE = (rawStream) => Effect26.gen(function* () {
+  const handleSSE = (rawStream) => Effect27.gen(function* () {
     const typeSafeSSE = yield* TypeSafeSSE;
     yield* typeSafeSSE.writeSSE("connect", {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
     const onHeartbeat = () => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("heartbeat", {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
     };
     const onSessionListChanged = (event) => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("sessionListChanged", {
           projectId: event.projectId
         })
       );
     };
     const onSessionChanged = (event) => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("sessionChanged", {
           projectId: event.projectId,
           sessionId: event.sessionId
@@ -3117,7 +3356,7 @@ var LayerImpl17 = Effect26.gen(function* () {
       );
     };
     const onAgentSessionChanged = (event) => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("agentSessionChanged", {
           projectId: event.projectId,
           agentSessionId: event.agentSessionId
@@ -3125,14 +3364,14 @@ var LayerImpl17 = Effect26.gen(function* () {
       );
     };
     const onSessionProcessChanged = (event) => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("sessionProcessChanged", {
           processes: event.processes
         })
       );
     };
     const onPermissionRequested = (event) => {
-      Effect26.runFork(
+      Effect27.runFork(
         typeSafeSSE.writeSSE("permissionRequested", {
           permissionRequest: event.permissionRequest
         })
@@ -3147,8 +3386,8 @@ var LayerImpl17 = Effect26.gen(function* () {
     const { connectionPromise } = adaptInternalEventToSSE(rawStream, {
       timeout: 5 * 60 * 1e3,
       cleanUp: async () => {
-        await Effect26.runPromise(
-          Effect26.gen(function* () {
+        await Effect27.runPromise(
+          Effect27.gen(function* () {
             yield* eventBus.off("sessionListChanged", onSessionListChanged);
             yield* eventBus.off("sessionChanged", onSessionChanged);
             yield* eventBus.off("agentSessionChanged", onAgentSessionChanged);
@@ -3162,7 +3401,7 @@ var LayerImpl17 = Effect26.gen(function* () {
         );
       }
     });
-    yield* Effect26.promise(() => connectionPromise);
+    yield* Effect27.promise(() => connectionPromise);
   });
   return {
     handleSSE
@@ -3177,19 +3416,19 @@ var SSEController = class extends Context21.Tag("SSEController")() {
 // src/server/core/events/services/fileWatcher.ts
 import { watch } from "node:fs";
 import { Path as Path12 } from "@effect/platform";
-import { Context as Context22, Effect as Effect27, Layer as Layer24, Ref as Ref9 } from "effect";
+import { Context as Context22, Effect as Effect28, Layer as Layer24, Ref as Ref9 } from "effect";
 
 // src/server/core/events/functions/parseSessionFilePath.ts
-import z22 from "zod";
+import z21 from "zod";
 var sessionFileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl$/;
 var agentFileRegExp = /(?<projectId>.*?)\/agent-(?<agentSessionId>.*?)\.jsonl$/;
-var sessionFileGroupSchema = z22.object({
-  projectId: z22.string(),
-  sessionId: z22.string()
+var sessionFileGroupSchema = z21.object({
+  projectId: z21.string(),
+  sessionId: z21.string()
 });
-var agentFileGroupSchema = z22.object({
-  projectId: z22.string(),
-  agentSessionId: z22.string()
+var agentFileGroupSchema = z21.object({
+  projectId: z21.string(),
+  agentSessionId: z21.string()
 });
 var parseSessionFilePath = (filePath) => {
   const agentMatch = filePath.match(agentFileRegExp);
@@ -3218,7 +3457,7 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
   static {
     this.Live = Layer24.effect(
       this,
-      Effect27.gen(function* () {
+      Effect28.gen(function* () {
         const path = yield* Path12.Path;
         const eventBus = yield* EventBus;
         const context = yield* ApplicationContext;
@@ -3228,31 +3467,32 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
           /* @__PURE__ */ new Map()
         );
         const debounceTimersRef = yield* Ref9.make(/* @__PURE__ */ new Map());
-        const startWatching = () => Effect27.gen(function* () {
+        const startWatching = () => Effect28.gen(function* () {
           const isWatching = yield* Ref9.get(isWatchingRef);
           if (isWatching) return;
+          const claudeCodePaths = yield* context.claudeCodePaths;
           yield* Ref9.set(isWatchingRef, true);
-          yield* Effect27.tryPromise({
+          yield* Effect28.tryPromise({
             try: async () => {
               console.log(
                 "Starting file watcher on:",
-                context.claudeCodePaths.claudeProjectsDirPath
+                claudeCodePaths.claudeProjectsDirPath
               );
               const watcher = watch(
-                context.claudeCodePaths.claudeProjectsDirPath,
+                claudeCodePaths.claudeProjectsDirPath,
                 { persistent: false, recursive: true },
                 (_eventType, filename) => {
                   if (!filename) return;
                   const fileMatch = parseSessionFilePath(filename);
                   if (fileMatch === null) return;
                   const fullPath = path.join(
-                    context.claudeCodePaths.claudeProjectsDirPath,
+                    claudeCodePaths.claudeProjectsDirPath,
                     filename
                   );
                   const encodedProjectId = encodeProjectIdFromSessionFilePath(fullPath);
                   const debounceKey = fileMatch.type === "agent" ? `${encodedProjectId}/agent-${fileMatch.agentSessionId}` : `${encodedProjectId}/${fileMatch.sessionId}`;
-                  Effect27.runPromise(
-                    Effect27.gen(function* () {
+                  Effect28.runPromise(
+                    Effect28.gen(function* () {
                       const timers = yield* Ref9.get(debounceTimersRef);
                       const existingTimer = timers.get(debounceKey);
                       if (existingTimer) {
@@ -3260,27 +3500,27 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
                       }
                       const newTimer = setTimeout(() => {
                         if (fileMatch.type === "agent") {
-                          Effect27.runFork(
+                          Effect28.runFork(
                             eventBus.emit("agentSessionChanged", {
                               projectId: encodedProjectId,
                               agentSessionId: fileMatch.agentSessionId
                             })
                           );
                         } else {
-                          Effect27.runFork(
+                          Effect28.runFork(
                             eventBus.emit("sessionChanged", {
                               projectId: encodedProjectId,
                               sessionId: fileMatch.sessionId
                             })
                           );
-                          Effect27.runFork(
+                          Effect28.runFork(
                             eventBus.emit("sessionListChanged", {
                               projectId: encodedProjectId
                             })
                           );
                         }
-                        Effect27.runPromise(
-                          Effect27.gen(function* () {
+                        Effect28.runPromise(
+                          Effect28.gen(function* () {
                             const currentTimers = yield* Ref9.get(debounceTimersRef);
                             currentTimers.delete(debounceKey);
                             yield* Ref9.set(debounceTimersRef, currentTimers);
@@ -3293,7 +3533,7 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
                   );
                 }
               );
-              await Effect27.runPromise(Ref9.set(watcherRef, watcher));
+              await Effect28.runPromise(Ref9.set(watcherRef, watcher));
               console.log("File watcher initialization completed");
             },
             catch: (error) => {
@@ -3304,10 +3544,10 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
             }
           }).pipe(
             // エラーが発生しても続行する
-            Effect27.catchAll(() => Effect27.void)
+            Effect28.catchAll(() => Effect28.void)
           );
         });
-        const stop = () => Effect27.gen(function* () {
+        const stop = () => Effect28.gen(function* () {
           const timers = yield* Ref9.get(debounceTimersRef);
           for (const [, timer] of timers) {
             clearTimeout(timer);
@@ -3315,12 +3555,12 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
           yield* Ref9.set(debounceTimersRef, /* @__PURE__ */ new Map());
           const watcher = yield* Ref9.get(watcherRef);
           if (watcher) {
-            yield* Effect27.sync(() => watcher.close());
+            yield* Effect28.sync(() => watcher.close());
             yield* Ref9.set(watcherRef, null);
           }
           const projectWatchers = yield* Ref9.get(projectWatchersRef);
           for (const [, projectWatcher] of projectWatchers) {
-            yield* Effect27.sync(() => projectWatcher.close());
+            yield* Effect28.sync(() => projectWatcher.close());
           }
           yield* Ref9.set(projectWatchersRef, /* @__PURE__ */ new Map());
           yield* Ref9.set(isWatchingRef, false);
@@ -3335,10 +3575,10 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
 };
 
 // src/server/core/feature-flag/presentation/FeatureFlagController.ts
-import { Context as Context23, Effect as Effect28, Layer as Layer25 } from "effect";
-var LayerImpl18 = Effect28.gen(function* () {
+import { Context as Context23, Effect as Effect29, Layer as Layer25 } from "effect";
+var LayerImpl18 = Effect29.gen(function* () {
   const claudeCodeService = yield* ClaudeCodeService;
-  const getFlags = () => Effect28.gen(function* () {
+  const getFlags = () => Effect29.gen(function* () {
     const claudeCodeFeatures = yield* claudeCodeService.getAvailableFeatures();
     return {
       response: {
@@ -3372,7 +3612,7 @@ var FeatureFlagController = class extends Context23.Tag("FeatureFlagController")
 
 // src/server/core/file-system/presentation/FileSystemController.ts
 import { homedir as homedir3 } from "node:os";
-import { Context as Context24, Effect as Effect29, Layer as Layer26 } from "effect";
+import { Context as Context24, Effect as Effect30, Layer as Layer26 } from "effect";
 
 // src/server/core/file-system/functions/getDirectoryListing.ts
 import { existsSync } from "node:fs";
@@ -3505,9 +3745,9 @@ var getFileCompletion = async (projectPath, basePath = "/") => {
 };
 
 // src/server/core/file-system/presentation/FileSystemController.ts
-var LayerImpl19 = Effect29.gen(function* () {
+var LayerImpl19 = Effect30.gen(function* () {
   const projectRepository = yield* ProjectRepository;
-  const getFileCompletionRoute = (options) => Effect29.gen(function* () {
+  const getFileCompletionRoute = (options) => Effect30.gen(function* () {
     const { projectId, basePath } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -3518,7 +3758,7 @@ var LayerImpl19 = Effect29.gen(function* () {
     }
     const projectPath = project.meta.projectPath;
     try {
-      const result = yield* Effect29.promise(
+      const result = yield* Effect30.promise(
         () => getFileCompletion(projectPath, basePath)
       );
       return {
@@ -3533,7 +3773,7 @@ var LayerImpl19 = Effect29.gen(function* () {
       };
     }
   });
-  const getDirectoryListingRoute = (options) => Effect29.promise(async () => {
+  const getDirectoryListingRoute = (options) => Effect30.promise(async () => {
     const { currentPath, showHidden = false } = options;
     const rootPath = "/";
     const defaultPath = homedir3();
@@ -3569,7 +3809,7 @@ var FileSystemController = class extends Context24.Tag("FileSystemController")()
 };
 
 // src/server/core/git/presentation/GitController.ts
-import { Context as Context26, Effect as Effect31, Either as Either2, Layer as Layer28 } from "effect";
+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";
@@ -3909,7 +4149,57 @@ var getDiff = async (cwd, fromRefText, toRefText) => {
 
 // src/server/core/git/services/GitService.ts
 import { Command as Command2, FileSystem as FileSystem10, Path as Path13 } from "@effect/platform";
-import { Context as Context25, Data as Data4, Duration, Effect as Effect30, Either, Layer as Layer27 } from "effect";
+import { Context as Context26, Data as Data4, Duration, Effect as Effect32, Either, Layer as Layer28 } from "effect";
+
+// src/server/core/platform/services/EnvService.ts
+import { Context as Context25, Effect as Effect31, Layer as Layer27, Ref as Ref10 } from "effect";
+
+// src/server/core/platform/schema.ts
+import { z as z22 } from "zod";
+var envSchema = z22.object({
+  // Frameworks
+  NODE_ENV: z22.enum(["development", "production", "test"]).optional().default("development"),
+  NEXT_PHASE: z22.string().optional(),
+  PATH: z22.string().optional()
+});
+
+// src/server/core/platform/services/EnvService.ts
+var LayerImpl20 = Effect31.gen(function* () {
+  const envRef = yield* Ref10.make(void 0);
+  const parseEnv = () => {
+    const parsed = envSchema.safeParse(process.env);
+    if (!parsed.success) {
+      console.error(parsed.error);
+      throw new Error(`Invalid environment variables: ${parsed.error.message}`);
+    }
+    return parsed.data;
+  };
+  const getEnv = (key) => {
+    return Effect31.gen(function* () {
+      yield* Ref10.update(envRef, (existingEnv) => {
+        if (existingEnv === void 0) {
+          return parseEnv();
+        }
+        return existingEnv;
+      });
+      const env = yield* Ref10.get(envRef);
+      if (env === void 0) {
+        throw new Error(
+          "Unexpected error: Environment variables are not loaded"
+        );
+      }
+      return env[key];
+    });
+  };
+  return {
+    getEnv
+  };
+});
+var EnvService = class extends Context25.Tag("EnvService")() {
+  static {
+    this.Live = Layer27.effect(this, LayerImpl20);
+  }
+};
 
 // src/server/core/git/functions/parseGitBranchesOutput.ts
 var parseGitBranchesOutput = (output) => {
@@ -3986,14 +4276,14 @@ var GitCommandError = class extends Data4.TaggedError("GitCommandError") {
 };
 var DetachedHeadError = class extends Data4.TaggedError("DetachedHeadError") {
 };
-var LayerImpl20 = Effect30.gen(function* () {
+var LayerImpl21 = Effect32.gen(function* () {
   const fs = yield* FileSystem10.FileSystem;
   const path = yield* Path13.Path;
   const envService = yield* EnvService;
-  const execGitCommand = (args, cwd) => Effect30.gen(function* () {
+  const execGitCommand = (args, cwd) => Effect32.gen(function* () {
     const absoluteCwd = path.resolve(cwd);
     if (!(yield* fs.exists(absoluteCwd))) {
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new NotARepositoryError({ cwd: absoluteCwd })
       );
     }
@@ -4003,9 +4293,9 @@ var LayerImpl20 = Effect30.gen(function* () {
         PATH: yield* envService.getEnv("PATH")
       })
     );
-    const result = yield* Effect30.either(Command2.string(command));
+    const result = yield* Effect32.either(Command2.string(command));
     if (Either.isLeft(result)) {
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: `git ${args.join(" ")}`
@@ -4014,22 +4304,22 @@ var LayerImpl20 = Effect30.gen(function* () {
     }
     return result.right;
   });
-  const getBranches = (cwd) => Effect30.gen(function* () {
+  const getBranches = (cwd) => Effect32.gen(function* () {
     const result = yield* execGitCommand(["branch", "-vv", "--all"], cwd);
     return parseGitBranchesOutput(result);
   });
-  const getCurrentBranch = (cwd) => Effect30.gen(function* () {
+  const getCurrentBranch = (cwd) => Effect32.gen(function* () {
     const currentBranch = yield* execGitCommand(
       ["branch", "--show-current"],
       cwd
-    ).pipe(Effect30.map((result) => result.trim()));
+    ).pipe(Effect32.map((result) => result.trim()));
     if (currentBranch === "") {
-      return yield* Effect30.fail(new DetachedHeadError({ cwd }));
+      return yield* Effect32.fail(new DetachedHeadError({ cwd }));
     }
     return currentBranch;
   });
-  const branchExists = (cwd, branchName) => Effect30.gen(function* () {
-    const result = yield* Effect30.either(
+  const branchExists = (cwd, branchName) => Effect32.gen(function* () {
+    const result = yield* Effect32.either(
       execGitCommand(["branch", "--exists", branchName], cwd)
     );
     if (Either.isLeft(result)) {
@@ -4037,7 +4327,7 @@ var LayerImpl20 = Effect30.gen(function* () {
     }
     return true;
   });
-  const getCommits = (cwd) => Effect30.gen(function* () {
+  const getCommits = (cwd) => Effect32.gen(function* () {
     const result = yield* execGitCommand(
       [
         "log",
@@ -4051,9 +4341,9 @@ var LayerImpl20 = Effect30.gen(function* () {
     );
     return parseGitCommitsOutput(result);
   });
-  const stageFiles = (cwd, files) => Effect30.gen(function* () {
+  const stageFiles = (cwd, files) => Effect32.gen(function* () {
     if (files.length === 0) {
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new GitCommandError({
           cwd,
           command: "git add (no files)"
@@ -4063,10 +4353,10 @@ var LayerImpl20 = Effect30.gen(function* () {
     const result = yield* execGitCommand(["add", ...files], cwd);
     return result;
   });
-  const commit = (cwd, message) => Effect30.gen(function* () {
+  const commit = (cwd, message) => Effect32.gen(function* () {
     const trimmedMessage = message.trim();
     if (trimmedMessage.length === 0) {
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new GitCommandError({
           cwd,
           command: "git commit (empty message)"
@@ -4103,7 +4393,7 @@ var LayerImpl20 = Effect30.gen(function* () {
     );
     return sha.trim();
   });
-  const push = (cwd) => Effect30.gen(function* () {
+  const push = (cwd) => Effect32.gen(function* () {
     const branch = yield* getCurrentBranch(cwd);
     const absoluteCwd = path.resolve(cwd);
     const command = Command2.make("git", "push", "origin", "HEAD").pipe(
@@ -4112,12 +4402,12 @@ var LayerImpl20 = Effect30.gen(function* () {
         PATH: yield* envService.getEnv("PATH")
       })
     );
-    const exitCodeResult = yield* Effect30.either(
-      Command2.exitCode(command).pipe(Effect30.timeout(Duration.seconds(60)))
+    const exitCodeResult = yield* Effect32.either(
+      Command2.exitCode(command).pipe(Effect32.timeout(Duration.seconds(60)))
     );
     if (Either.isLeft(exitCodeResult)) {
       console.log("[GitService.push] Command failed or timeout");
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: "git push origin HEAD (timeout after 60s)"
@@ -4135,10 +4425,10 @@ var LayerImpl20 = Effect30.gen(function* () {
           }),
           Command2.stderr("inherit")
         )
-      ).pipe(Effect30.orElse(() => Effect30.succeed([])));
+      ).pipe(Effect32.orElse(() => Effect32.succeed([])));
       const stderr = Array.from(stderrLines).join("\n");
       console.log("[GitService.push] Failed with stderr:", stderr);
-      return yield* Effect30.fail(
+      return yield* Effect32.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: `git push origin HEAD - ${stderr}`
@@ -4148,20 +4438,20 @@ var LayerImpl20 = Effect30.gen(function* () {
     console.log("[GitService.push] Push succeeded");
     return { branch, output: "success" };
   });
-  const getBranchHash = (cwd, branchName) => Effect30.gen(function* () {
+  const getBranchHash = (cwd, branchName) => Effect32.gen(function* () {
     const result = yield* execGitCommand(["rev-parse", branchName], cwd).pipe(
-      Effect30.map((output) => output.trim().split("\n")[0] ?? null)
+      Effect32.map((output) => output.trim().split("\n")[0] ?? null)
     );
     return result;
   });
-  const getBranchNamesByCommitHash = (cwd, hash) => Effect30.gen(function* () {
+  const getBranchNamesByCommitHash = (cwd, hash) => Effect32.gen(function* () {
     const result = yield* execGitCommand(
       ["branch", "--contains", hash, "--format=%(refname:short)"],
       cwd
     );
     return result.split("\n").map((line) => line.trim()).filter((line) => line !== "");
   });
-  const compareCommitHash = (cwd, targetHash, compareHash) => Effect30.gen(function* () {
+  const compareCommitHash = (cwd, targetHash, compareHash) => Effect32.gen(function* () {
     const aheadResult = yield* execGitCommand(
       ["rev-list", `${targetHash}..${compareHash}`],
       cwd
@@ -4183,7 +4473,7 @@ var LayerImpl20 = Effect30.gen(function* () {
     }
     return "un-related";
   });
-  const getCommitsWithParent = (cwd, options) => Effect30.gen(function* () {
+  const getCommitsWithParent = (cwd, options) => Effect32.gen(function* () {
     const { offset, limit } = options;
     const result = yield* execGitCommand(
       [
@@ -4210,7 +4500,7 @@ var LayerImpl20 = Effect30.gen(function* () {
     }
     return commits;
   });
-  const findBaseBranch = (cwd, targetBranch) => Effect30.gen(function* () {
+  const findBaseBranch = (cwd, targetBranch) => Effect32.gen(function* () {
     let offset = 0;
     const limit = 20;
     while (offset < 100) {
@@ -4244,7 +4534,7 @@ var LayerImpl20 = Effect30.gen(function* () {
     }
     return null;
   });
-  const getCommitsBetweenBranches = (cwd, baseBranch, targetBranch) => Effect30.gen(function* () {
+  const getCommitsBetweenBranches = (cwd, baseBranch, targetBranch) => Effect32.gen(function* () {
     const result = yield* execGitCommand(
       [
         "log",
@@ -4272,17 +4562,17 @@ var LayerImpl20 = Effect30.gen(function* () {
     getCommitsBetweenBranches
   };
 });
-var GitService = class extends Context25.Tag("GitService")() {
+var GitService = class extends Context26.Tag("GitService")() {
   static {
-    this.Live = Layer27.effect(this, LayerImpl20);
+    this.Live = Layer28.effect(this, LayerImpl21);
   }
 };
 
 // src/server/core/git/presentation/GitController.ts
-var LayerImpl21 = Effect31.gen(function* () {
+var LayerImpl22 = Effect33.gen(function* () {
   const gitService = yield* GitService;
   const projectRepository = yield* ProjectRepository;
-  const getGitDiff = (options) => Effect31.gen(function* () {
+  const getGitDiff = (options) => Effect33.gen(function* () {
     const { projectId, fromRef, toRef } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     try {
@@ -4293,7 +4583,7 @@ var LayerImpl21 = Effect31.gen(function* () {
         };
       }
       const projectPath = project.meta.projectPath;
-      const result = yield* Effect31.promise(
+      const result = yield* Effect33.promise(
         () => getDiff(projectPath, fromRef, toRef)
       );
       return {
@@ -4314,7 +4604,7 @@ var LayerImpl21 = Effect31.gen(function* () {
       };
     }
   });
-  const commitFiles = (options) => Effect31.gen(function* () {
+  const commitFiles = (options) => Effect33.gen(function* () {
     const { projectId, files, message } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -4327,7 +4617,7 @@ var LayerImpl21 = Effect31.gen(function* () {
     const projectPath = project.meta.projectPath;
     console.log("[GitController.commitFiles] Project path:", projectPath);
     console.log("[GitController.commitFiles] Staging files...");
-    const stageResult = yield* Effect31.either(
+    const stageResult = yield* Effect33.either(
       gitService.stageFiles(projectPath, files)
     );
     if (Either2.isLeft(stageResult)) {
@@ -4347,7 +4637,7 @@ var LayerImpl21 = Effect31.gen(function* () {
     }
     console.log("[GitController.commitFiles] Stage succeeded");
     console.log("[GitController.commitFiles] Committing...");
-    const commitResult = yield* Effect31.either(
+    const commitResult = yield* Effect33.either(
       gitService.commit(projectPath, message)
     );
     if (Either2.isLeft(commitResult)) {
@@ -4382,7 +4672,7 @@ var LayerImpl21 = Effect31.gen(function* () {
       status: 200
     };
   });
-  const pushCommits = (options) => Effect31.gen(function* () {
+  const pushCommits = (options) => Effect33.gen(function* () {
     const { projectId } = options;
     console.log("[GitController.pushCommits] Request:", { projectId });
     const { project } = yield* projectRepository.getProject(projectId);
@@ -4396,7 +4686,7 @@ var LayerImpl21 = Effect31.gen(function* () {
     const projectPath = project.meta.projectPath;
     console.log("[GitController.pushCommits] Project path:", projectPath);
     console.log("[GitController.pushCommits] Pushing...");
-    const pushResult = yield* Effect31.either(gitService.push(projectPath));
+    const pushResult = yield* Effect33.either(gitService.push(projectPath));
     if (Either2.isLeft(pushResult)) {
       console.log(
         "[GitController.pushCommits] Push failed:",
@@ -4425,7 +4715,7 @@ var LayerImpl21 = Effect31.gen(function* () {
       status: 200
     };
   });
-  const commitAndPush = (options) => Effect31.gen(function* () {
+  const commitAndPush = (options) => Effect33.gen(function* () {
     const { projectId, files, message } = options;
     console.log("[GitController.commitAndPush] Request:", {
       projectId,
@@ -4476,7 +4766,7 @@ var LayerImpl21 = Effect31.gen(function* () {
       status: 200
     };
   });
-  const getCurrentRevisions = (options) => Effect31.gen(function* () {
+  const getCurrentRevisions = (options) => Effect33.gen(function* () {
     const { projectId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -4486,7 +4776,7 @@ var LayerImpl21 = Effect31.gen(function* () {
       };
     }
     const projectPath = project.meta.projectPath;
-    const currentBranchResult = yield* Effect31.either(
+    const currentBranchResult = yield* Effect33.either(
       gitService.getCurrentBranch(projectPath)
     );
     if (Either2.isLeft(currentBranchResult)) {
@@ -4498,10 +4788,10 @@ var LayerImpl21 = Effect31.gen(function* () {
       };
     }
     const currentBranch = currentBranchResult.right;
-    const baseBranchResult = yield* Effect31.either(
+    const baseBranchResult = yield* Effect33.either(
       gitService.findBaseBranch(projectPath, currentBranch)
     );
-    const allBranchesResult = yield* Effect31.either(
+    const allBranchesResult = yield* Effect33.either(
       gitService.getBranches(projectPath)
     );
     if (Either2.isLeft(allBranchesResult)) {
@@ -4526,7 +4816,7 @@ var LayerImpl21 = Effect31.gen(function* () {
     let commits = [];
     if (Either2.isRight(baseBranchResult) && baseBranchResult.right !== null) {
       const baseBranchHash = baseBranchResult.right.hash;
-      const commitsResult = yield* Effect31.either(
+      const commitsResult = yield* Effect33.either(
         gitService.getCommitsBetweenBranches(
           projectPath,
           baseBranchHash,
@@ -4589,20 +4879,20 @@ function getPushErrorMessage(code) {
   };
   return messages[code];
 }
-var GitController = class extends Context26.Tag("GitController")() {
+var GitController = class extends Context27.Tag("GitController")() {
   static {
-    this.Live = Layer28.effect(this, LayerImpl21);
+    this.Live = Layer29.effect(this, LayerImpl22);
   }
 };
 
 // src/server/core/project/presentation/ProjectController.ts
 import { FileSystem as FileSystem11, Path as Path15 } from "@effect/platform";
-import { Context as Context27, Effect as Effect33, Layer as Layer29 } from "effect";
+import { Context as Context28, Effect as Effect35, Layer as Layer30 } from "effect";
 
 // src/server/core/claude-code/functions/computeClaudeProjectFilePath.ts
 import { Path as Path14 } from "@effect/platform";
-import { Effect as Effect32 } from "effect";
-var computeClaudeProjectFilePath = (options) => Effect32.gen(function* () {
+import { Effect as Effect34 } from "effect";
+var computeClaudeProjectFilePath = (options) => Effect34.gen(function* () {
   const path = yield* Path14.Path;
   const { projectPath, claudeProjectsDirPath } = options;
   return path.join(
@@ -4612,7 +4902,7 @@ var computeClaudeProjectFilePath = (options) => Effect32.gen(function* () {
 });
 
 // src/server/core/project/presentation/ProjectController.ts
-var LayerImpl22 = Effect33.gen(function* () {
+var LayerImpl23 = Effect35.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const userConfigService = yield* UserConfigService;
@@ -4620,14 +4910,14 @@ var LayerImpl22 = Effect33.gen(function* () {
   const context = yield* ApplicationContext;
   const fileSystem = yield* FileSystem11.FileSystem;
   const path = yield* Path15.Path;
-  const getProjects = () => Effect33.gen(function* () {
+  const getProjects = () => Effect35.gen(function* () {
     const { projects } = yield* projectRepository.getProjects();
     return {
       status: 200,
       response: { projects }
     };
   });
-  const getProject = (options) => Effect33.gen(function* () {
+  const getProject = (options) => Effect35.gen(function* () {
     const { projectId, cursor } = options;
     const userConfig = yield* userConfigService.getUserConfig();
     const { project } = yield* projectRepository.getProject(projectId);
@@ -4681,7 +4971,7 @@ var LayerImpl22 = Effect33.gen(function* () {
       }
     };
   });
-  const getProjectLatestSession = (options) => Effect33.gen(function* () {
+  const getProjectLatestSession = (options) => Effect35.gen(function* () {
     const { projectId } = options;
     const { sessions } = yield* sessionRepository.getSessions(projectId, {
       maxCount: 1
@@ -4693,11 +4983,11 @@ var LayerImpl22 = Effect33.gen(function* () {
       }
     };
   });
-  const createProject = (options) => Effect33.gen(function* () {
+  const createProject = (options) => Effect35.gen(function* () {
     const { projectPath } = options;
     const claudeProjectFilePath = yield* computeClaudeProjectFilePath({
       projectPath,
-      claudeProjectsDirPath: context.claudeCodePaths.claudeProjectsDirPath
+      claudeProjectsDirPath: (yield* context.claudeCodePaths).claudeProjectsDirPath
     });
     const projectId = encodeProjectId(claudeProjectFilePath);
     const userConfig = yield* userConfigService.getUserConfig();
@@ -4730,16 +5020,16 @@ var LayerImpl22 = Effect33.gen(function* () {
     createProject
   };
 });
-var ProjectController = class extends Context27.Tag("ProjectController")() {
+var ProjectController = class extends Context28.Tag("ProjectController")() {
   static {
-    this.Live = Layer29.effect(this, LayerImpl22);
+    this.Live = Layer30.effect(this, LayerImpl23);
   }
 };
 
 // src/server/core/scheduler/config.ts
 import { homedir as homedir4 } from "node:os";
 import { FileSystem as FileSystem12, Path as Path16 } from "@effect/platform";
-import { Context as Context28, Data as Data5, Effect as Effect34, Layer as Layer30 } from "effect";
+import { Context as Context29, Data as Data5, Effect as Effect36, Layer as Layer31 } from "effect";
 
 // src/server/core/scheduler/schema.ts
 import { z as z23 } from "zod";
@@ -4800,29 +5090,29 @@ var ConfigParseError = class extends Data5.TaggedError("ConfigParseError") {
 };
 var CONFIG_DIR = "scheduler";
 var CONFIG_FILE = "schedules.json";
-var SchedulerConfigBaseDir = class extends Context28.Tag(
+var SchedulerConfigBaseDir = class extends Context29.Tag(
   "SchedulerConfigBaseDir"
 )() {
   static {
-    this.Live = Layer30.succeed(this, `${homedir4()}/.claude-code-viewer`);
+    this.Live = Layer31.succeed(this, `${homedir4()}/.claude-code-viewer`);
   }
 };
-var getConfigPath = Effect34.gen(function* () {
+var getConfigPath = Effect36.gen(function* () {
   const path = yield* Path16.Path;
   const baseDir = yield* SchedulerConfigBaseDir;
   return path.join(baseDir, CONFIG_DIR, CONFIG_FILE);
 });
-var readConfig = Effect34.gen(function* () {
+var readConfig = Effect36.gen(function* () {
   const fs = yield* FileSystem12.FileSystem;
   const configPath = yield* getConfigPath;
   const exists = yield* fs.exists(configPath);
   if (!exists) {
-    return yield* Effect34.fail(
+    return yield* Effect36.fail(
       new ConfigFileNotFoundError({ path: configPath })
     );
   }
   const content = yield* fs.readFileString(configPath);
-  const jsonResult = yield* Effect34.try({
+  const jsonResult = yield* Effect36.try({
     try: () => JSON.parse(content),
     catch: (error) => new ConfigParseError({
       path: configPath,
@@ -4831,7 +5121,7 @@ var readConfig = Effect34.gen(function* () {
   });
   const parsed = schedulerConfigSchema.safeParse(jsonResult);
   if (!parsed.success) {
-    return yield* Effect34.fail(
+    return yield* Effect36.fail(
       new ConfigParseError({
         path: configPath,
         cause: parsed.error
@@ -4840,7 +5130,7 @@ var readConfig = Effect34.gen(function* () {
   }
   return parsed.data;
 });
-var writeConfig = (config) => Effect34.gen(function* () {
+var writeConfig = (config) => Effect36.gen(function* () {
   const fs = yield* FileSystem12.FileSystem;
   const path = yield* Path16.Path;
   const configPath = yield* getConfigPath;
@@ -4849,15 +5139,15 @@ var writeConfig = (config) => Effect34.gen(function* () {
   const content = JSON.stringify(config, null, 2);
   yield* fs.writeFileString(configPath, content);
 });
-var initializeConfig = Effect34.gen(function* () {
+var initializeConfig = Effect36.gen(function* () {
   const result = yield* readConfig.pipe(
-    Effect34.catchTags({
-      ConfigFileNotFoundError: () => Effect34.gen(function* () {
+    Effect36.catchTags({
+      ConfigFileNotFoundError: () => Effect36.gen(function* () {
         const initialConfig = { jobs: [] };
         yield* writeConfig(initialConfig);
         return initialConfig;
       }),
-      ConfigParseError: () => Effect34.gen(function* () {
+      ConfigParseError: () => Effect36.gen(function* () {
         const initialConfig = { jobs: [] };
         yield* writeConfig(initialConfig);
         return initialConfig;
@@ -4869,21 +5159,21 @@ var initializeConfig = Effect34.gen(function* () {
 
 // src/server/core/scheduler/domain/Scheduler.ts
 import {
-  Context as Context29,
+  Context as Context30,
   Cron,
   Data as Data6,
   Duration as Duration2,
-  Effect as Effect36,
+  Effect as Effect38,
   Fiber,
-  Layer as Layer31,
-  Ref as Ref10,
+  Layer as Layer32,
+  Ref as Ref11,
   Schedule
 } from "effect";
 import { ulid as ulid4 } from "ulid";
 
 // src/server/core/scheduler/domain/Job.ts
-import { Effect as Effect35 } from "effect";
-var executeJob = (job) => Effect35.gen(function* () {
+import { Effect as Effect37 } from "effect";
+var executeJob = (job) => Effect37.gen(function* () {
   const lifeCycleService = yield* ClaudeCodeLifeCycleService;
   const projectRepository = yield* ProjectRepository;
   const userConfigService = yield* UserConfigService;
@@ -4891,7 +5181,7 @@ var executeJob = (job) => Effect35.gen(function* () {
   const { project } = yield* projectRepository.getProject(message.projectId);
   const userConfig = yield* userConfigService.getUserConfig();
   if (project.meta.projectPath === null) {
-    return yield* Effect35.fail(
+    return yield* Effect37.fail(
       new Error(`Project path not found for projectId: ${message.projectId}`)
     );
   }
@@ -4925,15 +5215,15 @@ var InvalidCronExpressionError = class extends Data6.TaggedError(
   "InvalidCronExpressionError"
 ) {
 };
-var LayerImpl23 = Effect36.gen(function* () {
-  const fibersRef = yield* Ref10.make(/* @__PURE__ */ new Map());
-  const runningJobsRef = yield* Ref10.make(/* @__PURE__ */ new Set());
-  const startJob = (job) => Effect36.gen(function* () {
+var LayerImpl24 = Effect38.gen(function* () {
+  const fibersRef = yield* Ref11.make(/* @__PURE__ */ new Map());
+  const runningJobsRef = yield* Ref11.make(/* @__PURE__ */ new Set());
+  const startJob = (job) => Effect38.gen(function* () {
     const now = /* @__PURE__ */ new Date();
     if (job.schedule.type === "cron") {
       const cronResult = Cron.parse(job.schedule.expression);
       if (cronResult._tag === "Left") {
-        return yield* Effect36.fail(
+        return yield* Effect38.fail(
           new InvalidCronExpressionError({
             expression: job.schedule.expression,
             cause: cronResult.left
@@ -4941,13 +5231,13 @@ var LayerImpl23 = Effect36.gen(function* () {
         );
       }
       const cronSchedule = Schedule.cron(cronResult.right);
-      const fiber = yield* Effect36.gen(function* () {
+      const fiber = yield* Effect38.gen(function* () {
         const nextTime = Cron.next(cronResult.right, /* @__PURE__ */ new Date());
         const nextDelay = Math.max(0, nextTime.getTime() - Date.now());
-        yield* Effect36.sleep(Duration2.millis(nextDelay));
-        yield* Effect36.repeat(runJobWithConcurrencyControl(job), cronSchedule);
-      }).pipe(Effect36.forkDaemon);
-      yield* Ref10.update(
+        yield* Effect38.sleep(Duration2.millis(nextDelay));
+        yield* Effect38.repeat(runJobWithConcurrencyControl(job), cronSchedule);
+      }).pipe(Effect38.forkDaemon);
+      yield* Ref11.update(
         fibersRef,
         (fibers) => new Map(fibers).set(job.id, fiber)
       );
@@ -4957,61 +5247,61 @@ var LayerImpl23 = Effect36.gen(function* () {
       }
       const delay = calculateReservedDelay(job, now);
       const delayDuration = Duration2.millis(delay);
-      const fiber = yield* Effect36.delay(
+      const fiber = yield* Effect38.delay(
         runJobWithConcurrencyControl(job),
         delayDuration
-      ).pipe(Effect36.forkDaemon);
-      yield* Ref10.update(
+      ).pipe(Effect38.forkDaemon);
+      yield* Ref11.update(
         fibersRef,
         (fibers) => new Map(fibers).set(job.id, fiber)
       );
     }
   });
-  const runJobWithConcurrencyControl = (job) => Effect36.gen(function* () {
+  const runJobWithConcurrencyControl = (job) => Effect38.gen(function* () {
     if (job.schedule.type === "cron" && job.schedule.concurrencyPolicy === "skip") {
-      const runningJobs = yield* Ref10.get(runningJobsRef);
+      const runningJobs = yield* Ref11.get(runningJobsRef);
       if (runningJobs.has(job.id)) {
         return;
       }
     }
-    yield* Ref10.update(runningJobsRef, (jobs) => new Set(jobs).add(job.id));
+    yield* Ref11.update(runningJobsRef, (jobs) => new Set(jobs).add(job.id));
     if (job.schedule.type === "reserved") {
       const result2 = yield* executeJob(job).pipe(
-        Effect36.matchEffect({
-          onSuccess: () => Effect36.void,
-          onFailure: () => Effect36.void
+        Effect38.matchEffect({
+          onSuccess: () => Effect38.void,
+          onFailure: () => Effect38.void
         })
       );
-      yield* Ref10.update(runningJobsRef, (jobs) => {
+      yield* Ref11.update(runningJobsRef, (jobs) => {
         const newJobs = new Set(jobs);
         newJobs.delete(job.id);
         return newJobs;
       });
       yield* deleteJobFromConfig(job.id).pipe(
-        Effect36.catchAll((error) => {
+        Effect38.catchAll((error) => {
           console.error(
             `[Scheduler] Failed to delete reserved job ${job.id}:`,
             error
           );
-          return Effect36.void;
+          return Effect38.void;
         })
       );
       return result2;
     }
     const result = yield* executeJob(job).pipe(
-      Effect36.matchEffect({
+      Effect38.matchEffect({
         onSuccess: () => updateJobStatus(job.id, "success", (/* @__PURE__ */ new Date()).toISOString()),
         onFailure: () => updateJobStatus(job.id, "failed", (/* @__PURE__ */ new Date()).toISOString())
       })
     );
-    yield* Ref10.update(runningJobsRef, (jobs) => {
+    yield* Ref11.update(runningJobsRef, (jobs) => {
       const newJobs = new Set(jobs);
       newJobs.delete(job.id);
       return newJobs;
     });
     return result;
   });
-  const updateJobStatus = (jobId, status, runAt) => Effect36.gen(function* () {
+  const updateJobStatus = (jobId, status, runAt) => Effect38.gen(function* () {
     const config = yield* readConfig;
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
@@ -5027,19 +5317,19 @@ var LayerImpl23 = Effect36.gen(function* () {
     };
     yield* writeConfig(updatedConfig);
   });
-  const stopJob = (jobId) => Effect36.gen(function* () {
-    const fibers = yield* Ref10.get(fibersRef);
+  const stopJob = (jobId) => Effect38.gen(function* () {
+    const fibers = yield* Ref11.get(fibersRef);
     const fiber = fibers.get(jobId);
     if (fiber !== void 0) {
       yield* Fiber.interrupt(fiber);
-      yield* Ref10.update(fibersRef, (fibers2) => {
+      yield* Ref11.update(fibersRef, (fibers2) => {
         const newFibers = new Map(fibers2);
         newFibers.delete(jobId);
         return newFibers;
       });
     }
   });
-  const startScheduler = Effect36.gen(function* () {
+  const startScheduler = Effect38.gen(function* () {
     yield* initializeConfig;
     const config = yield* readConfig;
     for (const job of config.jobs) {
@@ -5048,27 +5338,27 @@ var LayerImpl23 = Effect36.gen(function* () {
       }
     }
   });
-  const stopScheduler = Effect36.gen(function* () {
-    const fibers = yield* Ref10.get(fibersRef);
+  const stopScheduler = Effect38.gen(function* () {
+    const fibers = yield* Ref11.get(fibersRef);
     for (const fiber of fibers.values()) {
       yield* Fiber.interrupt(fiber);
     }
-    yield* Ref10.set(fibersRef, /* @__PURE__ */ new Map());
+    yield* Ref11.set(fibersRef, /* @__PURE__ */ new Map());
   });
-  const getJobs = () => Effect36.gen(function* () {
+  const getJobs = () => Effect38.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect36.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] })))
+      Effect38.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] })))
       })
     );
     return config.jobs;
   });
-  const addJob = (newJob) => Effect36.gen(function* () {
+  const addJob = (newJob) => Effect38.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect36.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] })))
+      Effect38.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] })))
       })
     );
     const job = {
@@ -5087,16 +5377,16 @@ var LayerImpl23 = Effect36.gen(function* () {
     }
     return job;
   });
-  const updateJob = (jobId, updates) => Effect36.gen(function* () {
+  const updateJob = (jobId, updates) => Effect38.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect36.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] })))
+      Effect38.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect36.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect38.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     yield* stopJob(jobId);
     const updatedJob = {
@@ -5112,32 +5402,32 @@ var LayerImpl23 = Effect36.gen(function* () {
     }
     return updatedJob;
   });
-  const deleteJobFromConfig = (jobId) => Effect36.gen(function* () {
+  const deleteJobFromConfig = (jobId) => Effect38.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect36.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] })))
+      Effect38.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect36.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect38.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     const updatedConfig = {
       jobs: config.jobs.filter((j) => j.id !== jobId)
     };
     yield* writeConfig(updatedConfig);
   });
-  const deleteJob = (jobId) => Effect36.gen(function* () {
+  const deleteJob = (jobId) => Effect38.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect36.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect36.map(() => ({ jobs: [] })))
+      Effect38.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect38.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect36.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect38.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     yield* stopJob(jobId);
     yield* deleteJobFromConfig(jobId);
@@ -5151,24 +5441,24 @@ var LayerImpl23 = Effect36.gen(function* () {
     deleteJob
   };
 });
-var SchedulerService = class extends Context29.Tag("SchedulerService")() {
+var SchedulerService = class extends Context30.Tag("SchedulerService")() {
   static {
-    this.Live = Layer31.effect(this, LayerImpl23);
+    this.Live = Layer32.effect(this, LayerImpl24);
   }
 };
 
 // src/server/core/scheduler/presentation/SchedulerController.ts
-import { Context as Context30, Effect as Effect37, Layer as Layer32 } from "effect";
-var LayerImpl24 = Effect37.gen(function* () {
+import { Context as Context31, Effect as Effect39, Layer as Layer33 } from "effect";
+var LayerImpl25 = Effect39.gen(function* () {
   const schedulerService = yield* SchedulerService;
-  const getJobs = () => Effect37.gen(function* () {
+  const getJobs = () => Effect39.gen(function* () {
     const jobs = yield* schedulerService.getJobs();
     return {
       response: jobs,
       status: 200
     };
   });
-  const addJob = (options) => Effect37.gen(function* () {
+  const addJob = (options) => Effect39.gen(function* () {
     const { job } = options;
     const result = yield* schedulerService.addJob(job);
     return {
@@ -5176,12 +5466,12 @@ var LayerImpl24 = Effect37.gen(function* () {
       status: 201
     };
   });
-  const updateJob = (options) => Effect37.gen(function* () {
+  const updateJob = (options) => Effect39.gen(function* () {
     const { id, job } = options;
     const result = yield* schedulerService.updateJob(id, job).pipe(
-      Effect37.catchTag(
+      Effect39.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect37.succeed(null)
+        () => Effect39.succeed(null)
       )
     );
     if (result === null) {
@@ -5195,14 +5485,14 @@ var LayerImpl24 = Effect37.gen(function* () {
       status: 200
     };
   });
-  const deleteJob = (options) => Effect37.gen(function* () {
+  const deleteJob = (options) => Effect39.gen(function* () {
     const { id } = options;
     const result = yield* schedulerService.deleteJob(id).pipe(
-      Effect37.catchTag(
+      Effect39.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect37.succeed(false)
+        () => Effect39.succeed(false)
       ),
-      Effect37.map(() => true)
+      Effect39.map(() => true)
     );
     if (!result) {
       return {
@@ -5222,18 +5512,18 @@ var LayerImpl24 = Effect37.gen(function* () {
     deleteJob
   };
 });
-var SchedulerController = class extends Context30.Tag("SchedulerController")() {
+var SchedulerController = class extends Context31.Tag("SchedulerController")() {
   static {
-    this.Live = Layer32.effect(this, LayerImpl24);
+    this.Live = Layer33.effect(this, LayerImpl25);
   }
 };
 
 // src/server/core/search/presentation/SearchController.ts
-import { Context as Context32, Effect as Effect39, Layer as Layer34 } from "effect";
+import { Context as Context33, Effect as Effect41, Layer as Layer35 } from "effect";
 
 // src/server/core/search/services/SearchService.ts
 import { FileSystem as FileSystem13, Path as Path17 } from "@effect/platform";
-import { Context as Context31, Effect as Effect38, Layer as Layer33, Ref as Ref11 } from "effect";
+import { Context as Context32, Effect as Effect40, Layer as Layer34, Ref as Ref12 } from "effect";
 import MiniSearch from "minisearch";
 
 // src/server/core/search/functions/extractSearchableText.ts
@@ -5279,13 +5569,13 @@ var createMiniSearchIndex = () => new MiniSearch({
     boost: { text: 1 }
   }
 });
-var LayerImpl25 = Effect38.gen(function* () {
+var LayerImpl26 = Effect40.gen(function* () {
   const fs = yield* FileSystem13.FileSystem;
   const path = yield* Path17.Path;
   const context = yield* ApplicationContext;
-  const indexCacheRef = yield* Ref11.make(null);
-  const buildIndex = () => Effect38.gen(function* () {
-    const { claudeProjectsDirPath } = context.claudeCodePaths;
+  const indexCacheRef = yield* Ref12.make(null);
+  const buildIndex = () => Effect40.gen(function* () {
+    const { claudeProjectsDirPath } = yield* context.claudeCodePaths;
     const dirExists = yield* fs.exists(claudeProjectsDirPath);
     if (!dirExists) {
       return { index: createMiniSearchIndex(), documents: /* @__PURE__ */ new Map() };
@@ -5293,22 +5583,22 @@ var LayerImpl25 = Effect38.gen(function* () {
     const projectEntries = yield* fs.readDirectory(claudeProjectsDirPath);
     const miniSearch = createMiniSearchIndex();
     const documentEffects = projectEntries.map(
-      (projectEntry) => Effect38.gen(function* () {
+      (projectEntry) => Effect40.gen(function* () {
         const projectPath = path.resolve(claudeProjectsDirPath, projectEntry);
-        const stat = yield* fs.stat(projectPath).pipe(Effect38.catchAll(() => Effect38.succeed(null)));
+        const stat = yield* fs.stat(projectPath).pipe(Effect40.catchAll(() => Effect40.succeed(null)));
         if (stat?.type !== "Directory") {
           return [];
         }
         const projectId = encodeProjectId(projectPath);
         const projectName = path.basename(projectPath);
-        const sessionEntries = yield* fs.readDirectory(projectPath).pipe(Effect38.catchAll(() => Effect38.succeed([])));
+        const sessionEntries = yield* fs.readDirectory(projectPath).pipe(Effect40.catchAll(() => Effect40.succeed([])));
         const sessionFiles = sessionEntries.filter(isRegularSessionFile);
-        const sessionDocuments = yield* Effect38.all(
+        const sessionDocuments = yield* Effect40.all(
           sessionFiles.map(
-            (sessionFile) => Effect38.gen(function* () {
+            (sessionFile) => Effect40.gen(function* () {
               const sessionPath = path.resolve(projectPath, sessionFile);
               const sessionId = encodeSessionId(sessionPath);
-              const content = yield* fs.readFileString(sessionPath).pipe(Effect38.catchAll(() => Effect38.succeed("")));
+              const content = yield* fs.readFileString(sessionPath).pipe(Effect40.catchAll(() => Effect40.succeed("")));
               if (!content) return [];
               const conversations = parseJsonl(content);
               const documents = [];
@@ -5343,7 +5633,7 @@ var LayerImpl25 = Effect38.gen(function* () {
         return sessionDocuments.flat();
       })
     );
-    const allDocuments = yield* Effect38.all(documentEffects, {
+    const allDocuments = yield* Effect40.all(documentEffects, {
       concurrency: 10
     });
     const flatDocuments = allDocuments.flat();
@@ -5354,18 +5644,18 @@ var LayerImpl25 = Effect38.gen(function* () {
     }
     return { index: miniSearch, documents: documentsMap };
   });
-  const getIndex = () => Effect38.gen(function* () {
-    const cached = yield* Ref11.get(indexCacheRef);
+  const getIndex = () => Effect40.gen(function* () {
+    const cached = yield* Ref12.get(indexCacheRef);
     const now = Date.now();
     if (cached && now - cached.builtAt < INDEX_TTL_MS) {
       return { index: cached.index, documents: cached.documents };
     }
     const { index, documents } = yield* buildIndex();
-    yield* Ref11.set(indexCacheRef, { index, documents, builtAt: now });
+    yield* Ref12.set(indexCacheRef, { index, documents, builtAt: now });
     return { index, documents };
   });
-  const search = (query2, limit = 20, projectId) => Effect38.gen(function* () {
-    const { claudeProjectsDirPath } = context.claudeCodePaths;
+  const search = (query2, limit = 20, projectId) => Effect40.gen(function* () {
+    const { claudeProjectsDirPath } = yield* context.claudeCodePaths;
     const dirExists = yield* fs.exists(claudeProjectsDirPath);
     if (!dirExists) {
       return { results: [] };
@@ -5405,22 +5695,22 @@ var LayerImpl25 = Effect38.gen(function* () {
     }
     return { results };
   });
-  const invalidateIndex = () => Ref11.set(indexCacheRef, null);
+  const invalidateIndex = () => Ref12.set(indexCacheRef, null);
   return {
     search,
     invalidateIndex
   };
 });
-var SearchService = class extends Context31.Tag("SearchService")() {
+var SearchService = class extends Context32.Tag("SearchService")() {
   static {
-    this.Live = Layer33.effect(this, LayerImpl25);
+    this.Live = Layer34.effect(this, LayerImpl26);
   }
 };
 
 // src/server/core/search/presentation/SearchController.ts
-var LayerImpl26 = Effect39.gen(function* () {
+var LayerImpl27 = Effect41.gen(function* () {
   const searchService = yield* SearchService;
-  const search = (options) => Effect39.gen(function* () {
+  const search = (options) => Effect41.gen(function* () {
     const { query: query2, limit, projectId } = options;
     if (query2.trim().length < 2) {
       return {
@@ -5444,17 +5734,17 @@ var LayerImpl26 = Effect39.gen(function* () {
     search
   };
 });
-var SearchController = class extends Context32.Tag("SearchController")() {
+var SearchController = class extends Context33.Tag("SearchController")() {
   static {
-    this.Live = Layer34.effect(this, LayerImpl26);
+    this.Live = Layer35.effect(this, LayerImpl27);
   }
 };
 
 // src/server/core/session/presentation/SessionController.ts
-import { Context as Context33, Effect as Effect41, Layer as Layer35 } from "effect";
+import { Context as Context34, Effect as Effect43, Layer as Layer36 } from "effect";
 
 // src/server/core/session/services/ExportService.ts
-import { Effect as Effect40 } from "effect";
+import { Effect as Effect42 } from "effect";
 var escapeHtml = (text) => {
   const map = {
     "&": "&amp;",
@@ -5607,7 +5897,18 @@ var renderAssistantEntry = (entry) => {
     </div>
   `;
 };
+var getSystemEntryContent = (entry) => {
+  if ("content" in entry && typeof entry.content === "string") {
+    return entry.content;
+  }
+  if ("subtype" in entry && entry.subtype === "stop_hook_summary") {
+    const hookNames = entry.hookInfos.map((h) => h.command).join(", ");
+    return `Stop hook executed: ${hookNames}`;
+  }
+  return "System message";
+};
 var renderSystemEntry = (entry) => {
+  const content = getSystemEntryContent(entry);
   return `
     <div class="conversation-entry system-entry">
       <div class="entry-header">
@@ -5615,7 +5916,7 @@ var renderSystemEntry = (entry) => {
         <span class="entry-timestamp">${formatTimestamp(entry.timestamp)}</span>
       </div>
       <div class="entry-content">
-        <div class="system-message">${escapeHtml(entry.content)}</div>
+        <div class="system-message">${escapeHtml(content)}</div>
       </div>
     </div>
   `;
@@ -5713,7 +6014,7 @@ var renderGroupedAssistantEntries = (entries) => {
     </div>
   `;
 };
-var generateSessionHtml = (session, projectId) => Effect40.gen(function* () {
+var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
   const grouped = groupConsecutiveAssistantMessages(session.conversations);
   const conversationsHtml = grouped.map((group) => {
     if (group.type === "grouped") {
@@ -6233,9 +6534,9 @@ var generateSessionHtml = (session, projectId) => Effect40.gen(function* () {
 });
 
 // src/server/core/session/presentation/SessionController.ts
-var LayerImpl27 = Effect41.gen(function* () {
+var LayerImpl28 = Effect43.gen(function* () {
   const sessionRepository = yield* SessionRepository;
-  const getSession = (options) => Effect41.gen(function* () {
+  const getSession = (options) => Effect43.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -6246,7 +6547,7 @@ var LayerImpl27 = Effect41.gen(function* () {
       response: { session }
     };
   });
-  const exportSessionHtml = (options) => Effect41.gen(function* () {
+  const exportSessionHtml = (options) => Effect43.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -6269,9 +6570,9 @@ var LayerImpl27 = Effect41.gen(function* () {
     exportSessionHtml
   };
 });
-var SessionController = class extends Context33.Tag("SessionController")() {
+var SessionController = class extends Context34.Tag("SessionController")() {
   static {
-    this.Live = Layer35.effect(this, LayerImpl27);
+    this.Live = Layer36.effect(this, LayerImpl28);
   }
 };
 
@@ -6280,12 +6581,12 @@ import { Hono } from "hono";
 var honoApp = new Hono();
 
 // src/server/hono/initialize.ts
-import { Context as Context34, Effect as Effect42, Layer as Layer36, Ref as Ref12, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context34.Tag("InitializeService")() {
+import { Context as Context35, Effect as Effect44, Layer as Layer37, Ref as Ref13, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context35.Tag("InitializeService")() {
   static {
-    this.Live = Layer36.effect(
+    this.Live = Layer37.effect(
       this,
-      Effect42.gen(function* () {
+      Effect44.gen(function* () {
         const eventBus = yield* EventBus;
         const fileWatcher = yield* FileWatcherService;
         const projectRepository = yield* ProjectRepository;
@@ -6293,22 +6594,22 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
         const projectMetaService = yield* ProjectMetaService;
         const sessionMetaService = yield* SessionMetaService;
         const virtualConversationDatabase = yield* VirtualConversationDatabase;
-        const listenersRef = yield* Ref12.make({});
+        const listenersRef = yield* Ref13.make({});
         const startInitialization = () => {
-          return Effect42.gen(function* () {
+          return Effect44.gen(function* () {
             yield* fileWatcher.startWatching();
-            const daemon = Effect42.repeat(
+            const daemon = Effect44.repeat(
               eventBus.emit("heartbeat", {}),
               Schedule2.fixed("10 seconds")
             );
             console.log("start heartbeat");
-            yield* Effect42.forkDaemon(daemon);
+            yield* Effect44.forkDaemon(daemon);
             console.log("after starting heartbeat fork");
             const onSessionChanged = (event) => {
-              Effect42.runFork(
+              Effect44.runFork(
                 projectMetaService.invalidateProject(event.projectId)
               );
-              Effect42.runFork(
+              Effect44.runFork(
                 sessionMetaService.invalidateSession(
                   event.projectId,
                   event.sessionId
@@ -6317,7 +6618,7 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
             };
             const onSessionProcessChanged = (event) => {
               if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect42.runFork(
+                Effect44.runFork(
                   virtualConversationDatabase.deleteVirtualConversations(
                     event.changed.sessionId
                   )
@@ -6325,18 +6626,18 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
                 return;
               }
             };
-            yield* Ref12.set(listenersRef, {
+            yield* Ref13.set(listenersRef, {
               sessionChanged: onSessionChanged,
               sessionProcessChanged: onSessionProcessChanged
             });
             yield* eventBus.on("sessionChanged", onSessionChanged);
             yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect42.gen(function* () {
+            yield* Effect44.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* Effect42.all(
+              const results = yield* Effect44.all(
                 projects.map(
                   (project) => sessionRepository.getSessions(project.id)
                 ),
@@ -6348,13 +6649,13 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
               );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect42.catchAll(() => Effect42.void),
-              Effect42.withSpan("initialize-cache")
+              Effect44.catchAll(() => Effect44.void),
+              Effect44.withSpan("initialize-cache")
             );
-          }).pipe(Effect42.withSpan("start-initialization"));
+          }).pipe(Effect44.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect42.gen(function* () {
-          const listeners = yield* Ref12.get(listenersRef);
+        const stopCleanup = () => Effect44.gen(function* () {
+          const listeners = yield* Ref13.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
           }
@@ -6364,7 +6665,7 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
               listeners.sessionProcessChanged
             );
           }
-          yield* Ref12.set(listenersRef, {});
+          yield* Ref13.set(listenersRef, {});
           yield* fileWatcher.stop();
         });
         return {
@@ -6377,7 +6678,7 @@ var InitializeService = class extends Context34.Tag("InitializeService")() {
 };
 
 // src/server/hono/middleware/auth.middleware.ts
-import { Context as Context35, Effect as Effect43, Layer as Layer37 } from "effect";
+import { Context as Context36, Effect as Effect45, Layer as Layer38 } from "effect";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 var generateSessionToken = (password) => {
@@ -6392,180 +6693,50 @@ var PUBLIC_API_ROUTES = [
   // Allow config access for theme/locale loading
   "/api/version"
 ];
-var LayerImpl28 = Effect43.gen(function* () {
-  const envService = yield* EnvService;
-  const anthPassword = yield* envService.getEnv(
-    "CLAUDE_CODE_VIEWER_AUTH_PASSWORD"
-  ) ?? void 0;
-  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();
+var LayerImpl29 = Effect45.gen(function* () {
+  const ccvOptionsService = yield* CcvOptionsService;
+  return Effect45.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();
+    });
+    return {
+      authEnabled,
+      anthPassword,
+      validSessionToken,
+      authMiddleware
+    };
   });
-  return {
-    authEnabled,
-    anthPassword,
-    validSessionToken,
-    authMiddleware
-  };
 });
-var AuthMiddleware = class extends Context35.Tag("AuthMiddleware")() {
+var AuthMiddleware = class extends Context36.Tag("AuthMiddleware")() {
   static {
-    this.Live = Layer37.effect(this, LayerImpl28);
+    this.Live = Layer38.effect(this, LayerImpl29);
   }
 };
 
 // src/server/hono/route.ts
 import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect45, Runtime as Runtime3 } from "effect";
+import { Effect as Effect47, Runtime as Runtime3 } from "effect";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
 import { z as z28 } from "zod";
 
-// package.json
-var package_default = {
-  name: "@kimuson/claude-code-viewer",
-  version: "0.4.14",
-  type: "module",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "https://github.com/d-kimuson/claude-code-viewer.git"
-  },
-  homepage: "https://github.com/d-kimuson/claude-code-viewer",
-  files: [
-    "dist"
-  ],
-  engines: {
-    node: ">=20.19.0"
-  },
-  bin: {
-    "claude-code-viewer": "./dist/main.js"
-  },
-  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",
-    start: "node dist/index.js",
-    build: "./scripts/build.sh",
-    "build:frontend": "vite build",
-    "build:backend": "esbuild src/server/main.ts --format=esm --bundle --packages=external --sourcemap --platform=node --outfile=dist/main.js",
-    lint: "run-s 'lint:*'",
-    "lint:biome-format": "biome format .",
-    "lint:biome-lint": "biome check .",
-    fix: "run-s 'fix:*'",
-    "fix:biome-format": "biome format --write .",
-    "fix:biome-lint": "biome check --write --unsafe .",
-    typecheck: "tsc --noEmit",
-    test: "vitest --run",
-    "test:watch": "vitest",
-    e2e: "./scripts/e2e/exec_e2e.sh",
-    "e2e:start-server": "./scripts/e2e/start_server.sh",
-    "e2e:capture-snapshots": "./scripts/e2e/capture_snapshots.sh",
-    "lingui:extract": "lingui extract --clean && node ./scripts/lingui-sort.js",
-    "lingui:compile": "lingui compile --typescript",
-    prepare: "lefthook install"
-  },
-  dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.1.30",
-    "@anthropic-ai/claude-code": "2.0.24",
-    "@anthropic-ai/sdk": "0.67.0",
-    "@effect/cluster": "0.55.0",
-    "@effect/experimental": "0.57.11",
-    "@effect/platform": "0.93.6",
-    "@effect/platform-node": "0.103.0",
-    "@effect/rpc": "0.72.2",
-    "@effect/sql": "0.48.6",
-    "@effect/workflow": "0.15.1",
-    "@hono/node-server": "1.19.5",
-    "@hono/zod-validator": "0.7.4",
-    "@lingui/core": "5.5.1",
-    "@lingui/react": "5.5.1",
-    "@radix-ui/react-avatar": "1.1.10",
-    "@radix-ui/react-checkbox": "1.3.3",
-    "@radix-ui/react-collapsible": "1.1.12",
-    "@radix-ui/react-dialog": "1.1.15",
-    "@radix-ui/react-hover-card": "1.1.15",
-    "@radix-ui/react-popover": "1.1.15",
-    "@radix-ui/react-select": "2.2.6",
-    "@radix-ui/react-slot": "1.2.3",
-    "@radix-ui/react-tabs": "1.1.13",
-    "@radix-ui/react-tooltip": "1.2.8",
-    "@tailwindcss/vite": "4.1.16",
-    "@tanstack/react-devtools": "0.7.8",
-    "@tanstack/react-query": "5.90.5",
-    "@tanstack/react-router": "1.133.32",
-    "@tanstack/react-router-devtools": "1.133.32",
-    "class-variance-authority": "0.7.1",
-    clsx: "2.1.1",
-    "date-fns": "4.1.0",
-    effect: "3.19.9",
-    "es-toolkit": "1.41.0",
-    hono: "4.10.3",
-    jotai: "2.15.0",
-    "lucide-react": "0.548.0",
-    minisearch: "7.2.0",
-    "parse-git-diff": "0.0.19",
-    prexit: "2.3.0",
-    react: "19.2.0",
-    "react-dom": "19.2.0",
-    "react-error-boundary": "6.0.0",
-    "react-helmet-async": "2.0.5",
-    "react-markdown": "10.1.0",
-    "react-syntax-highlighter": "15.6.6",
-    "remark-gfm": "4.0.1",
-    sonner: "2.0.7",
-    "tailwind-merge": "3.3.1",
-    ulid: "3.0.1",
-    zod: "4.1.13"
-  },
-  devDependencies: {
-    "@biomejs/biome": "2.3.1",
-    "@effect/language-service": "0.60.0",
-    "@lingui/cli": "5.5.1",
-    "@lingui/conf": "5.5.1",
-    "@lingui/format-json": "5.5.1",
-    "@lingui/loader": "5.5.1",
-    "@lingui/vite-plugin": "5.5.1",
-    "@tailwindcss/postcss": "4.1.16",
-    "@tanstack/router-plugin": "1.133.32",
-    "@tsconfig/strictest": "2.0.6",
-    "@types/node": "24.9.1",
-    "@types/react": "19.2.2",
-    "@types/react-dom": "19.2.2",
-    "@types/react-syntax-highlighter": "15.5.13",
-    "@vitejs/plugin-react-swc": "4.2.0",
-    dotenv: "17.2.3",
-    esbuild: "0.25.11",
-    lefthook: "2.0.8",
-    "npm-run-all2": "8.0.4",
-    playwright: "1.56.1",
-    "release-it": "19.0.5",
-    "release-it-pnpm": "4.6.6",
-    tailwindcss: "4.1.16",
-    tsx: "4.20.6",
-    "tw-animate-css": "1.4.0",
-    typescript: "5.9.3",
-    vite: "7.1.12",
-    vitest: "4.0.3"
-  },
-  packageManager: "pnpm@10.18.3+sha512.bbd16e6d7286fd7e01f6b3c0b3c932cda2965c06a908328f74663f10a9aea51f1129eea615134bf992831b009eabe167ecb7008b597f40ff9bc75946aadfb08d"
-};
-
 // src/server/core/claude-code/schema.ts
 import { z as z24 } from "zod";
 var mediaTypeSchema = z24.enum([
@@ -6713,9 +6884,9 @@ var userConfigSchema = z27.object({
 var defaultUserConfig = userConfigSchema.parse({});
 
 // src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect44 } from "effect";
+import { Effect as Effect46 } from "effect";
 var effectToResponse = async (ctx, effect) => {
-  const result = await Effect44.runPromise(effect);
+  const result = await Effect46.runPromise(effect);
   const result2 = ctx.json(result.response, result.status);
   return result2;
 };
@@ -6758,7 +6929,13 @@ var configMiddleware = createMiddleware2(
 );
 
 // src/server/hono/route.ts
-var routes = (app) => Effect45.gen(function* () {
+var routes = (app, options) => Effect47.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;
@@ -6771,12 +6948,9 @@ var routes = (app) => Effect45.gen(function* () {
   const schedulerController = yield* SchedulerController;
   const featureFlagController = yield* FeatureFlagController;
   const searchController = yield* SearchController;
-  const envService = yield* EnvService;
-  const userConfigService = yield* UserConfigService;
-  const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
-  const initializeService = yield* InitializeService;
-  const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* AuthMiddleware;
-  const runtime = yield* Effect45.runtime();
+  const authMiddlewareService = yield* AuthMiddleware;
+  const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* authMiddlewareService;
+  const runtime = yield* Effect47.runtime();
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
     prexit(async () => {
@@ -6784,7 +6958,7 @@ var routes = (app) => Effect45.gen(function* () {
     });
   }
   return app.use(configMiddleware).use(authMiddleware).use(async (c, next) => {
-    await Effect45.runPromise(
+    await Effect47.runPromise(
       userConfigService.setUserConfig({
         ...c.get("userConfig")
       })
@@ -6853,7 +7027,7 @@ var routes = (app) => Effect45.gen(function* () {
         projectController.getProject({
           ...c.req.param(),
           ...c.req.valid("query")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6870,7 +7044,7 @@ var routes = (app) => Effect45.gen(function* () {
         c,
         projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6879,13 +7053,13 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect45.provide(runtime))
+      sessionController.getSession({ ...c.req.param() }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get(
@@ -6893,7 +7067,7 @@ var routes = (app) => Effect45.gen(function* () {
     async (c) => {
       const response = await effectToResponse(
         c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect45.provide(runtime))
+        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6904,7 +7078,7 @@ var routes = (app) => Effect45.gen(function* () {
       agentSessionController.getAgentSession({
         projectId,
         agentId
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/git/current-revisions", async (c) => {
@@ -6912,7 +7086,7 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       gitController.getCurrentRevisions({
         ...c.req.param()
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).post(
@@ -6930,7 +7104,7 @@ var routes = (app) => Effect45.gen(function* () {
         gitController.getGitDiff({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6943,7 +7117,7 @@ var routes = (app) => Effect45.gen(function* () {
         gitController.commitFiles({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6956,7 +7130,7 @@ var routes = (app) => Effect45.gen(function* () {
         gitController.pushCommits({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6969,7 +7143,7 @@ var routes = (app) => Effect45.gen(function* () {
         gitController.commitAndPush({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -6978,7 +7152,7 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       claudeCodeController.getClaudeCommands({
         ...c.req.param()
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/mcp/list", async (c) => {
@@ -6986,19 +7160,19 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       claudeCodeController.getMcpListRoute({
         ...c.req.param()
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/cc/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect45.provide(runtime))
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/cc/features", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect45.provide(runtime))
+      claudeCodeController.getAvailableFeatures().pipe(Effect47.provide(runtime))
     );
     return response;
   }).get("/api/cc/session-processes", async (c) => {
@@ -7042,7 +7216,7 @@ var routes = (app) => Effect45.gen(function* () {
         claudeCodeSessionProcessController.continueSessionProcess({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -7051,7 +7225,7 @@ var routes = (app) => Effect45.gen(function* () {
     zValidator("json", z28.object({ projectId: z28.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
-      void Effect45.runFork(
+      void Effect47.runFork(
         claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
       return c.json({ message: "Task aborted" });
@@ -7079,7 +7253,7 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       async (rawStream) => {
         await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect45.provide(TypeSafeSSE.make(rawStream)))
+          sseController.handleSSE(rawStream).pipe(Effect47.provide(TypeSafeSSE.make(rawStream)))
         );
       },
       async (err) => {
@@ -7089,7 +7263,7 @@ var routes = (app) => Effect45.gen(function* () {
   }).get("/api/scheduler/jobs", async (c) => {
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect45.provide(runtime))
+      schedulerController.getJobs().pipe(Effect47.provide(runtime))
     );
     return response;
   }).post(
@@ -7100,7 +7274,7 @@ var routes = (app) => Effect45.gen(function* () {
         c,
         schedulerController.addJob({
           job: c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -7113,7 +7287,7 @@ var routes = (app) => Effect45.gen(function* () {
         schedulerController.updateJob({
           id: c.req.param("id"),
           job: c.req.valid("json")
-        }).pipe(Effect45.provide(runtime))
+        }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
@@ -7122,7 +7296,7 @@ var routes = (app) => Effect45.gen(function* () {
       c,
       schedulerController.deleteJob({
         id: c.req.param("id")
-      }).pipe(Effect45.provide(runtime))
+      }).pipe(Effect47.provide(runtime))
     );
     return response;
   }).get(
@@ -7175,14 +7349,14 @@ var routes = (app) => Effect45.gen(function* () {
       const { q, limit, projectId } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        searchController.search({ query: q, limit, projectId }).pipe(Effect45.provide(runtime))
+        searchController.search({ query: q, limit, projectId }).pipe(Effect47.provide(runtime))
       );
       return response;
     }
   ).get("/api/flags", async (c) => {
     const response = await effectToResponse(
       c,
-      featureFlagController.getFlags().pipe(Effect45.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect47.provide(runtime))
     );
     return response;
   });
@@ -7190,90 +7364,114 @@ var routes = (app) => Effect45.gen(function* () {
 
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer38 } from "effect";
-var platformLayer = Layer38.mergeAll(
+import { Layer as Layer39 } from "effect";
+var platformLayer = Layer39.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
-  EnvService.Live
-).pipe(Layer38.provide(EnvService.Live), Layer38.provide(NodeContext.layer));
-
-// src/server/main.ts
-var isDevelopment = process.env.NODE_ENV === "development";
-if (!isDevelopment) {
-  const staticPath = resolve6(import.meta.dirname, "static");
-  console.log("Serving static files from ", staticPath);
-  honoApp.use(
-    "/assets/*",
-    serveStatic({
-      root: staticPath
-    })
-  );
-  honoApp.use("*", async (c, next) => {
-    if (c.req.path.startsWith("/api")) {
-      return next();
-    }
-    const html = await readFile2(resolve6(staticPath, "index.html"), "utf-8");
-    return c.html(html);
-  });
-}
-var program = routes(honoApp).pipe(
-  /** Presentation */
-  Effect46.provide(ProjectController.Live),
-  Effect46.provide(SessionController.Live),
-  Effect46.provide(AgentSessionController.Live),
-  Effect46.provide(GitController.Live),
-  Effect46.provide(ClaudeCodeController.Live),
-  Effect46.provide(ClaudeCodeSessionProcessController.Live),
-  Effect46.provide(ClaudeCodePermissionController.Live),
-  Effect46.provide(FileSystemController.Live),
-  Effect46.provide(SSEController.Live),
-  Effect46.provide(SchedulerController.Live),
-  Effect46.provide(FeatureFlagController.Live),
-  Effect46.provide(SearchController.Live)
+  EnvService.Live,
+  CcvOptionsService.Live
 ).pipe(
-  /** Application */
-  Effect46.provide(InitializeService.Live),
-  Effect46.provide(FileWatcherService.Live),
-  Effect46.provide(AuthMiddleware.Live)
-).pipe(
-  /** Domain */
-  Effect46.provide(ClaudeCodeLifeCycleService.Live),
-  Effect46.provide(ClaudeCodePermissionService.Live),
-  Effect46.provide(ClaudeCodeSessionProcessService.Live),
-  Effect46.provide(ClaudeCodeService.Live),
-  Effect46.provide(GitService.Live),
-  Effect46.provide(SchedulerService.Live),
-  Effect46.provide(SchedulerConfigBaseDir.Live),
-  Effect46.provide(SearchService.Live)
-).pipe(
-  /** Infrastructure */
-  Effect46.provide(ProjectRepository.Live),
-  Effect46.provide(SessionRepository.Live),
-  Effect46.provide(ProjectMetaService.Live),
-  Effect46.provide(SessionMetaService.Live),
-  Effect46.provide(VirtualConversationDatabase.Live),
-  Effect46.provide(AgentSessionLayer)
-).pipe(
-  /** Platform */
-  Effect46.provide(platformLayer),
-  Effect46.provide(NodeContext2.layer)
-);
-await Effect46.runPromise(program);
-var port = isDevelopment ? (
-  // biome-ignore lint/style/noProcessEnv: allow only here
-  process.env.DEV_BE_PORT ?? "3401"
-) : (
-  // biome-ignore lint/style/noProcessEnv: allow only here
-  process.env.PORT ?? "3000"
+  Layer39.provide(EnvService.Live),
+  Layer39.provide(CcvOptionsService.Live),
+  Layer39.provide(NodeContext.layer)
 );
-serve(
-  {
-    fetch: honoApp.fetch,
-    port: parseInt(port, 10)
-  },
-  (info) => {
-    console.log(`Server is running on http://localhost:${info.port}`);
+
+// src/server/startServer.ts
+var startServer = async (options) => {
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (!isDevelopment) {
+    const staticPath = resolve6(import.meta.dirname, "static");
+    console.log("Serving static files from ", staticPath);
+    honoApp.use(
+      "/assets/*",
+      serveStatic({
+        root: staticPath
+      })
+    );
+    honoApp.use("*", async (c, next) => {
+      if (c.req.path.startsWith("/api")) {
+        return next();
+      }
+      const html = await readFile2(resolve6(staticPath, "index.html"), "utf-8");
+      return c.html(html);
+    });
   }
-);
+  const program2 = routes(honoApp, options).pipe(
+    /** Presentation */
+    Effect48.provide(ProjectController.Live),
+    Effect48.provide(SessionController.Live),
+    Effect48.provide(AgentSessionController.Live),
+    Effect48.provide(GitController.Live),
+    Effect48.provide(ClaudeCodeController.Live),
+    Effect48.provide(ClaudeCodeSessionProcessController.Live),
+    Effect48.provide(ClaudeCodePermissionController.Live),
+    Effect48.provide(FileSystemController.Live),
+    Effect48.provide(SSEController.Live),
+    Effect48.provide(SchedulerController.Live),
+    Effect48.provide(FeatureFlagController.Live),
+    Effect48.provide(SearchController.Live)
+  ).pipe(
+    /** Application */
+    Effect48.provide(InitializeService.Live),
+    Effect48.provide(FileWatcherService.Live),
+    Effect48.provide(AuthMiddleware.Live)
+  ).pipe(
+    /** Domain */
+    Effect48.provide(ClaudeCodeLifeCycleService.Live),
+    Effect48.provide(ClaudeCodePermissionService.Live),
+    Effect48.provide(ClaudeCodeSessionProcessService.Live),
+    Effect48.provide(ClaudeCodeService.Live),
+    Effect48.provide(GitService.Live),
+    Effect48.provide(SchedulerService.Live),
+    Effect48.provide(SchedulerConfigBaseDir.Live),
+    Effect48.provide(SearchService.Live)
+  ).pipe(
+    /** Infrastructure */
+    Effect48.provide(ProjectRepository.Live),
+    Effect48.provide(SessionRepository.Live),
+    Effect48.provide(ProjectMetaService.Live),
+    Effect48.provide(SessionMetaService.Live),
+    Effect48.provide(VirtualConversationDatabase.Live),
+    Effect48.provide(AgentSessionLayer)
+  ).pipe(
+    /** Platform */
+    Effect48.provide(platformLayer),
+    Effect48.provide(NodeContext2.layer)
+  );
+  await Effect48.runPromise(program2);
+  const port = isDevelopment ? (
+    // biome-ignore lint/style/noProcessEnv: allow only here
+    process.env.DEV_BE_PORT ?? "3401"
+  ) : (
+    // biome-ignore lint/style/noProcessEnv: allow only here
+    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}`);
+    }
+  );
+};
+
+// 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 Effect49.runPromise(checkDeprecatedEnvs);
+  await startServer(options);
+});
+var main = async () => {
+  program.parse(process.argv);
+};
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
 //# sourceMappingURL=main.js.map