@kimuson/claude-code-viewer 0.5.8 → 0.5.9

package/dist/main.js

@@ -2,12 +2,12 @@
 
 // src/server/main.ts
 import { Command as Command3 } from "commander";
-import { Effect as Effect51 } from "effect";
+import { Effect as Effect53 } from "effect";
 
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.5.8",
+  version: "0.5.9",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -51,7 +51,7 @@ var package_default = {
     prepare: "lefthook install"
   },
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.2.19",
+    "@anthropic-ai/claude-agent-sdk": "0.2.20",
     "@anthropic-ai/claude-code": "2.0.24",
     "@anthropic-ai/sdk": "0.71.2",
     "@effect/cluster": "0.56.1",
@@ -219,7 +219,7 @@ 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 Effect50 } from "effect";
+import { Effect as Effect52, Layer as Layer43 } from "effect";
 
 // src/server/core/agent-session/index.ts
 import { Layer as Layer3 } from "effect";
@@ -8042,17 +8042,355 @@ var SessionController = class extends Context35.Tag("SessionController")() {
   }
 };
 
+// src/server/core/tasks/presentation/TasksController.ts
+import { Context as Context37, Effect as Effect47, Layer as Layer39 } from "effect";
+
+// src/server/core/tasks/services/TasksService.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join3 } from "node:path";
+import { FileSystem as FileSystem17, Path as Path19 } from "@effect/platform";
+import { Context as Context36, Effect as Effect46, Layer as Layer38, Option as Option4 } from "effect";
+
+// src/server/core/tasks/schema.ts
+import { z as z26 } from "zod";
+var TaskStatusSchema = z26.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed"
+]);
+var TaskSchema = z26.object({
+  id: z26.string(),
+  subject: z26.string(),
+  description: z26.string().optional(),
+  status: TaskStatusSchema,
+  owner: z26.string().optional(),
+  blocks: z26.array(z26.string()).optional(),
+  blockedBy: z26.array(z26.string()).optional(),
+  metadata: z26.record(z26.string(), z26.any()).optional(),
+  activeForm: z26.string().optional()
+});
+var TaskCreateSchema = z26.object({
+  subject: z26.string(),
+  description: z26.string().optional(),
+  activeForm: z26.string().optional(),
+  metadata: z26.record(z26.string(), z26.any()).optional()
+});
+var TaskUpdateSchema = z26.object({
+  taskId: z26.string(),
+  status: TaskStatusSchema.optional(),
+  subject: z26.string().optional(),
+  description: z26.string().optional(),
+  activeForm: z26.string().optional(),
+  owner: z26.string().optional(),
+  addBlockedBy: z26.array(z26.string()).optional(),
+  addBlocks: z26.array(z26.string()).optional(),
+  metadata: z26.record(z26.string(), z26.any()).optional()
+});
+
+// src/server/core/tasks/services/TasksService.ts
+var TASKS_DIR_NAME = "tasks";
+var PROJECTS_DIR_NAME = "projects";
+var CLAUDE_DIR_NAME = ".claude";
+var TasksService = class extends Context36.Tag("TasksService")() {
+  static {
+    this.Live = Layer38.effect(
+      this,
+      Effect46.gen(function* () {
+        const fs = yield* FileSystem17.FileSystem;
+        const path = yield* Path19.Path;
+        const getClaudeDir = () => Effect46.succeed(join3(homedir5(), CLAUDE_DIR_NAME));
+        const normalizeProjectPath = (projectPath) => {
+          const normalized = projectPath.replaceAll(path.sep, "-");
+          return normalized.startsWith("-") ? normalized : `-${normalized}`;
+        };
+        const resolveProjectUuid = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          if (specificSessionId) {
+            const sessionTasksDir = path.join(
+              claudeDir,
+              TASKS_DIR_NAME,
+              specificSessionId
+            );
+            if (yield* fs.exists(sessionTasksDir)) {
+              return Option4.some(specificSessionId);
+            }
+            return Option4.none();
+          }
+          const isMetadataPath = projectPath.includes(join3(CLAUDE_DIR_NAME, PROJECTS_DIR_NAME)) && projectPath.split(path.sep).pop()?.startsWith("-");
+          let projectMetaDir;
+          if (isMetadataPath && (yield* fs.exists(projectPath))) {
+            projectMetaDir = projectPath;
+          } else {
+            const identifier = normalizeProjectPath(projectPath);
+            projectMetaDir = path.join(
+              claudeDir,
+              PROJECTS_DIR_NAME,
+              identifier
+            );
+          }
+          const exists = yield* fs.exists(projectMetaDir);
+          if (!exists) {
+            return Option4.none();
+          }
+          const files = yield* fs.readDirectory(projectMetaDir);
+          const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+          const candidates = files.filter((f) => uuidPattern.test(f));
+          if (candidates.length === 0) {
+            return Option4.none();
+          }
+          const candidateInfo = yield* Effect46.all(
+            candidates.map(
+              (file) => Effect46.gen(function* () {
+                const fullPath = path.join(projectMetaDir, file);
+                const stat = yield* fs.stat(fullPath);
+                const match = file.match(uuidPattern);
+                const uuid = match ? match[0] : file;
+                const tasksPath = path.join(claudeDir, TASKS_DIR_NAME, uuid);
+                const hasTasks = yield* fs.exists(tasksPath);
+                return {
+                  file,
+                  uuid,
+                  mtime: Option4.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date(0)),
+                  hasTasks
+                };
+              })
+            ),
+            { concurrency: "unbounded" }
+          );
+          const sorted = candidateInfo.sort((a, b) => {
+            if (a.hasTasks && !b.hasTasks) return -1;
+            if (!a.hasTasks && b.hasTasks) return 1;
+            return b.mtime.getTime() - a.mtime.getTime();
+          });
+          const best = sorted[0];
+          if (!best) {
+            return Option4.none();
+          }
+          return Option4.some(best.uuid);
+        });
+        const resolveProjectUuidOrFail = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const uuidOption = yield* resolveProjectUuid(
+            projectPath,
+            specificSessionId
+          );
+          if (Option4.isNone(uuidOption)) {
+            if (specificSessionId) {
+              return yield* Effect46.fail(
+                new Error(
+                  `Requested session ${specificSessionId} has no tasks directory`
+                )
+              );
+            }
+            const claudeDir = yield* getClaudeDir();
+            const identifier = normalizeProjectPath(projectPath);
+            const projectMetaDir = path.join(
+              claudeDir,
+              PROJECTS_DIR_NAME,
+              identifier
+            );
+            return yield* Effect46.fail(
+              new Error(
+                `Project metadata directory not found or no UUID: ${projectMetaDir}`
+              )
+            );
+          }
+          return uuidOption.value;
+        });
+        const getTasksDir = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          const uuidOption = yield* resolveProjectUuid(
+            projectPath,
+            specificSessionId
+          );
+          return Option4.map(
+            uuidOption,
+            (uuid) => path.join(claudeDir, TASKS_DIR_NAME, uuid)
+          );
+        });
+        const getTasksDirOrFail = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          const uuid = yield* resolveProjectUuidOrFail(
+            projectPath,
+            specificSessionId
+          );
+          return path.join(claudeDir, TASKS_DIR_NAME, uuid);
+        });
+        const listTasks = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const tasksDirOption = yield* getTasksDir(
+            projectPath,
+            specificSessionId
+          );
+          if (Option4.isNone(tasksDirOption)) {
+            return [];
+          }
+          const tasksDir = tasksDirOption.value;
+          const exists = yield* fs.exists(tasksDir);
+          if (!exists) {
+            return [];
+          }
+          const files = yield* fs.readDirectory(tasksDir);
+          const tasks = [];
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            const content = yield* fs.readFileString(path.join(tasksDir, file));
+            try {
+              const task = JSON.parse(content);
+              const parsed = TaskSchema.safeParse(task);
+              if (parsed.success) {
+                tasks.push(parsed.data);
+              } else {
+                console.warn(`Invalid task file ${file}:`, parsed.error);
+                const fallbackTask = {
+                  id: typeof task === "object" && task !== null && "id" in task && typeof task.id === "string" ? task.id : file.replace(".json", ""),
+                  subject: typeof task === "object" && task !== null && "subject" in task && typeof task.subject === "string" ? task.subject : typeof task === "object" && task !== null && "title" in task && typeof task.title === "string" ? task.title : "Invalid Task Schema",
+                  description: `Validation Error: ${JSON.stringify(parsed.error.format())}. Raw: ${JSON.stringify(task)}`,
+                  status: typeof task === "object" && task !== null && "status" in task && typeof task.status === "string" && (task.status === "pending" || task.status === "in_progress" || task.status === "completed" || task.status === "failed") ? task.status : "failed",
+                  blocks: [],
+                  blockedBy: []
+                };
+                tasks.push(fallbackTask);
+              }
+            } catch (e) {
+              console.error(`Failed to parse task file ${file}`, e);
+              const fallbackTask = {
+                id: file.replace(".json", ""),
+                subject: "Corrupted Task File",
+                description: String(e),
+                status: "failed",
+                blocks: [],
+                blockedBy: []
+              };
+              tasks.push(fallbackTask);
+            }
+          }
+          return tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+        });
+        const getTask = (projectPath, taskId, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const taskFile = path.join(tasksDir, `${taskId}.json`);
+          const exists = yield* fs.exists(taskFile);
+          if (!exists) {
+            return yield* Effect46.fail(new Error(`Task ${taskId} not found`));
+          }
+          const content = yield* fs.readFileString(taskFile);
+          const task = JSON.parse(content);
+          return yield* Effect46.try(() => TaskSchema.parse(task));
+        });
+        const createTask = (projectPath, taskDef, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const dirExists = yield* fs.exists(tasksDir);
+          if (!dirExists) {
+            yield* fs.makeDirectory(tasksDir, { recursive: true });
+          }
+          const files = yield* fs.readDirectory(tasksDir);
+          let maxId = 0;
+          for (const file of files) {
+            if (file.endsWith(".json")) {
+              const idPart = file.replace(".json", "");
+              const idNum = parseInt(idPart, 10);
+              if (!Number.isNaN(idNum) && idNum > maxId) {
+                maxId = idNum;
+              }
+            }
+          }
+          const newId = (maxId + 1).toString();
+          const newTask = {
+            id: newId,
+            status: "pending",
+            blocks: [],
+            blockedBy: [],
+            ...taskDef
+          };
+          const filePath = path.join(tasksDir, `${newId}.json`);
+          yield* fs.writeFileString(filePath, JSON.stringify(newTask, null, 2));
+          return newTask;
+        });
+        const updateTask = (projectPath, update, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const filePath = path.join(tasksDir, `${update.taskId}.json`);
+          const exists = yield* fs.exists(filePath);
+          if (!exists) {
+            return yield* Effect46.fail(
+              new Error(`Task ${update.taskId} not found`)
+            );
+          }
+          const content = yield* fs.readFileString(filePath);
+          const currentTask = TaskSchema.parse(JSON.parse(content));
+          const updatedTask = {
+            ...currentTask,
+            // User cannot update status via Viewer, it is managed by Claude Agent
+            status: currentTask.status,
+            subject: update.subject ?? currentTask.subject,
+            description: update.description ?? currentTask.description,
+            activeForm: update.activeForm ?? currentTask.activeForm,
+            owner: update.owner ?? currentTask.owner,
+            blockedBy: update.addBlockedBy ? [...currentTask.blockedBy || [], ...update.addBlockedBy] : currentTask.blockedBy,
+            blocks: update.addBlocks ? [...currentTask.blocks || [], ...update.addBlocks] : currentTask.blocks,
+            metadata: update.metadata ? { ...currentTask.metadata, ...update.metadata } : currentTask.metadata
+          };
+          if (updatedTask.metadata) {
+            for (const key in updatedTask.metadata) {
+              if (updatedTask.metadata[key] === null) {
+                delete updatedTask.metadata[key];
+              }
+            }
+          }
+          yield* fs.writeFileString(
+            filePath,
+            JSON.stringify(updatedTask, null, 2)
+          );
+          return updatedTask;
+        });
+        return {
+          listTasks,
+          getTask,
+          createTask,
+          updateTask
+        };
+      })
+    );
+  }
+};
+
+// src/server/core/tasks/presentation/TasksController.ts
+var make = Effect47.gen(function* () {
+  const service = yield* TasksService;
+  const listTasks = (projectPath, specificSessionId) => service.listTasks(projectPath, specificSessionId);
+  const createTask = (projectPath, task, specificSessionId) => service.createTask(projectPath, task, specificSessionId);
+  const updateTask = (projectPath, task, specificSessionId) => service.updateTask(projectPath, task, specificSessionId);
+  return {
+    listTasks,
+    createTask,
+    updateTask
+  };
+});
+var TasksController = class extends Context37.Tag("TasksController")() {
+  static {
+    this.Live = Layer39.effect(this, make);
+  }
+};
+
 // src/server/hono/app.ts
 import { Hono } from "hono";
 var honoApp = new Hono();
 
 // src/server/hono/initialize.ts
-import { Context as Context36, Effect as Effect46, Layer as Layer38, Ref as Ref14, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context36.Tag("InitializeService")() {
+import { Context as Context38, Effect as Effect48, Layer as Layer40, Ref as Ref14, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context38.Tag("InitializeService")() {
   static {
-    this.Live = Layer38.effect(
+    this.Live = Layer40.effect(
       this,
-      Effect46.gen(function* () {
+      Effect48.gen(function* () {
         const eventBus = yield* EventBus;
         const fileWatcher = yield* FileWatcherService;
         const projectRepository = yield* ProjectRepository;
@@ -8063,21 +8401,21 @@ var InitializeService = class extends Context36.Tag("InitializeService")() {
         const rateLimitAutoScheduleService = yield* RateLimitAutoScheduleService;
         const listenersRef = yield* Ref14.make({});
         const startInitialization = () => {
-          return Effect46.gen(function* () {
+          return Effect48.gen(function* () {
             yield* fileWatcher.startWatching();
             yield* rateLimitAutoScheduleService.start();
-            const daemon = Effect46.repeat(
+            const daemon = Effect48.repeat(
               eventBus.emit("heartbeat", {}),
               Schedule2.fixed("10 seconds")
             );
             console.log("start heartbeat");
-            yield* Effect46.forkDaemon(daemon);
+            yield* Effect48.forkDaemon(daemon);
             console.log("after starting heartbeat fork");
             const onSessionChanged = (event) => {
-              Effect46.runFork(
+              Effect48.runFork(
                 projectMetaService.invalidateProject(event.projectId)
               );
-              Effect46.runFork(
+              Effect48.runFork(
                 sessionMetaService.invalidateSession(
                   event.projectId,
                   event.sessionId
@@ -8086,7 +8424,7 @@ var InitializeService = class extends Context36.Tag("InitializeService")() {
             };
             const onSessionProcessChanged = (event) => {
               if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect46.runFork(
+                Effect48.runFork(
                   virtualConversationDatabase.deleteVirtualConversations(
                     event.changed.sessionId
                   )
@@ -8100,12 +8438,12 @@ var InitializeService = class extends Context36.Tag("InitializeService")() {
             });
             yield* eventBus.on("sessionChanged", onSessionChanged);
             yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect46.gen(function* () {
+            yield* Effect48.gen(function* () {
               console.log("Initializing projects cache");
               const { projects } = yield* projectRepository.getProjects();
               console.log(`${projects.length} projects cache initialized`);
               console.log("Initializing sessions cache");
-              const results = yield* Effect46.all(
+              const results = yield* Effect48.all(
                 projects.map(
                   (project) => sessionRepository.getSessions(project.id)
                 ),
@@ -8117,12 +8455,12 @@ var InitializeService = class extends Context36.Tag("InitializeService")() {
               );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect46.catchAll(() => Effect46.void),
-              Effect46.withSpan("initialize-cache")
+              Effect48.catchAll(() => Effect48.void),
+              Effect48.withSpan("initialize-cache")
             );
-          }).pipe(Effect46.withSpan("start-initialization"));
+          }).pipe(Effect48.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect46.gen(function* () {
+        const stopCleanup = () => Effect48.gen(function* () {
           const listeners = yield* Ref14.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
@@ -8147,7 +8485,7 @@ var InitializeService = class extends Context36.Tag("InitializeService")() {
 };
 
 // src/server/hono/middleware/auth.middleware.ts
-import { Context as Context37, Effect as Effect47, Layer as Layer39 } from "effect";
+import { Context as Context39, Effect as Effect49, Layer as Layer41 } from "effect";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 var generateSessionToken = (password) => {
@@ -8162,9 +8500,9 @@ var PUBLIC_API_ROUTES = [
   // Allow config access for theme/locale loading
   "/api/version"
 ];
-var LayerImpl30 = Effect47.gen(function* () {
+var LayerImpl30 = Effect49.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
-  return Effect47.gen(function* () {
+  return Effect49.gen(function* () {
     const anthPassword = yield* ccvOptionsService.getCcvOptions("password");
     const authEnabled = anthPassword !== void 0;
     const validSessionToken = generateSessionToken(anthPassword);
@@ -8192,77 +8530,77 @@ var LayerImpl30 = Effect47.gen(function* () {
     };
   });
 });
-var AuthMiddleware = class extends Context37.Tag("AuthMiddleware")() {
+var AuthMiddleware = class extends Context39.Tag("AuthMiddleware")() {
   static {
-    this.Live = Layer39.effect(this, LayerImpl30);
+    this.Live = Layer41.effect(this, LayerImpl30);
   }
 };
 
 // src/server/hono/route.ts
 import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect49, Runtime as Runtime3 } from "effect";
+import { Effect as Effect51, Runtime as Runtime3 } from "effect";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 
 // src/server/core/claude-code/schema.ts
-import { z as z26 } from "zod";
-var mediaTypeSchema = z26.enum([
+import { z as z27 } from "zod";
+var mediaTypeSchema = z27.enum([
   "image/png",
   "image/jpeg",
   "image/gif",
   "image/webp"
 ]);
-var imageBlockSchema = z26.object({
-  type: z26.literal("image"),
-  source: z26.object({
-    type: z26.literal("base64"),
+var imageBlockSchema = z27.object({
+  type: z27.literal("image"),
+  source: z27.object({
+    type: z27.literal("base64"),
     media_type: mediaTypeSchema,
-    data: z26.string()
+    data: z27.string()
   })
 });
-var documentBlockSchema = z26.object({
-  type: z26.literal("document"),
-  source: z26.union([
-    z26.object({
-      type: z26.literal("text"),
-      media_type: z26.enum(["text/plain"]),
-      data: z26.string()
+var documentBlockSchema = z27.object({
+  type: z27.literal("document"),
+  source: z27.union([
+    z27.object({
+      type: z27.literal("text"),
+      media_type: z27.enum(["text/plain"]),
+      data: z27.string()
     }),
-    z26.object({
-      type: z26.literal("base64"),
-      media_type: z26.enum(["application/pdf"]),
-      data: z26.string()
+    z27.object({
+      type: z27.literal("base64"),
+      media_type: z27.enum(["application/pdf"]),
+      data: z27.string()
     })
   ])
 });
-var userMessageInputSchema = z26.object({
-  text: z26.string().min(1),
-  images: z26.array(imageBlockSchema).optional(),
-  documents: z26.array(documentBlockSchema).optional()
+var userMessageInputSchema = z27.object({
+  text: z27.string().min(1),
+  images: z27.array(imageBlockSchema).optional(),
+  documents: z27.array(documentBlockSchema).optional()
 });
 
 // src/server/core/git/schema.ts
-import { z as z27 } from "zod";
-var CommitRequestSchema = z27.object({
-  projectId: z27.string().min(1),
-  files: z27.array(z27.string().min(1)).min(1),
-  message: z27.string().trim().min(1)
+import { z as z28 } from "zod";
+var CommitRequestSchema = z28.object({
+  projectId: z28.string().min(1),
+  files: z28.array(z28.string().min(1)).min(1),
+  message: z28.string().trim().min(1)
 });
-var PushRequestSchema = z27.object({
-  projectId: z27.string().min(1)
+var PushRequestSchema = z28.object({
+  projectId: z28.string().min(1)
 });
-var CommitResultSuccessSchema = z27.object({
-  success: z27.literal(true),
-  commitSha: z27.string().length(40),
-  filesCommitted: z27.number().int().positive(),
-  message: z27.string()
+var CommitResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  commitSha: z28.string().length(40),
+  filesCommitted: z28.number().int().positive(),
+  message: z28.string()
 });
-var CommitResultErrorSchema = z27.object({
-  success: z27.literal(false),
-  error: z27.string(),
-  errorCode: z27.enum([
+var CommitResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  error: z28.string(),
+  errorCode: z28.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -8270,22 +8608,22 @@ var CommitResultErrorSchema = z27.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z27.string().optional()
+  details: z28.string().optional()
 });
-var CommitResultSchema = z27.discriminatedUnion("success", [
+var CommitResultSchema = z28.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z27.object({
-  success: z27.literal(true),
-  remote: z27.string(),
-  branch: z27.string(),
-  objectsPushed: z27.number().int().optional()
+var PushResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  remote: z28.string(),
+  branch: z28.string(),
+  objectsPushed: z28.number().int().optional()
 });
-var PushResultErrorSchema = z27.object({
-  success: z27.literal(false),
-  error: z27.string(),
-  errorCode: z27.enum([
+var PushResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  error: z28.string(),
+  errorCode: z28.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -8295,26 +8633,26 @@ var PushResultErrorSchema = z27.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z27.string().optional()
+  details: z28.string().optional()
 });
-var PushResultSchema = z27.discriminatedUnion("success", [
+var PushResultSchema = z28.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z27.object({
-  success: z27.literal(true),
-  commitSha: z27.string().length(40),
-  filesCommitted: z27.number().int().positive(),
-  message: z27.string(),
-  remote: z27.string(),
-  branch: z27.string()
+var CommitAndPushResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  commitSha: z28.string().length(40),
+  filesCommitted: z28.number().int().positive(),
+  message: z28.string(),
+  remote: z28.string(),
+  branch: z28.string()
 });
-var CommitAndPushResultErrorSchema = z27.object({
-  success: z27.literal(false),
-  commitSucceeded: z27.boolean(),
-  commitSha: z27.string().length(40).optional(),
-  error: z27.string(),
-  errorCode: z27.enum([
+var CommitAndPushResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  commitSucceeded: z28.boolean(),
+  commitSha: z28.string().length(40).optional(),
+  error: z28.string(),
+  errorCode: z28.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -8327,37 +8665,37 @@ var CommitAndPushResultErrorSchema = z27.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z27.string().optional()
+  details: z28.string().optional()
 });
-var CommitAndPushResultSchema = z27.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z28.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
 
 // src/server/lib/config/config.ts
-import z29 from "zod";
+import z30 from "zod";
 
 // src/lib/i18n/schema.ts
-import z28 from "zod";
-var localeSchema = z28.enum(["ja", "en", "zh_CN"]);
+import z29 from "zod";
+var localeSchema = z29.enum(["ja", "en", "zh_CN"]);
 
 // src/server/lib/config/config.ts
-var userConfigSchema = z29.object({
-  hideNoUserMessageSession: z29.boolean().optional().default(true),
-  unifySameTitleSession: z29.boolean().optional().default(false),
-  enterKeyBehavior: z29.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
-  permissionMode: z29.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
+var userConfigSchema = z30.object({
+  hideNoUserMessageSession: z30.boolean().optional().default(true),
+  unifySameTitleSession: z30.boolean().optional().default(false),
+  enterKeyBehavior: z30.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+  permissionMode: z30.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
   locale: localeSchema.optional().default("en"),
-  theme: z29.enum(["light", "dark", "system"]).optional().default("system"),
-  searchHotkey: z29.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
-  autoScheduleContinueOnRateLimit: z29.boolean().optional().default(false)
+  theme: z30.enum(["light", "dark", "system"]).optional().default("system"),
+  searchHotkey: z30.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
+  autoScheduleContinueOnRateLimit: z30.boolean().optional().default(false)
 });
 var defaultUserConfig = userConfigSchema.parse({});
 
 // src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect48 } from "effect";
+import { Effect as Effect50 } from "effect";
 var effectToResponse = async (ctx, effect) => {
-  const result = await Effect48.runPromise(effect);
+  const result = await Effect50.runPromise(effect);
   const result2 = ctx.json(result.response, result.status);
   return result2;
 };
@@ -8400,7 +8738,7 @@ var configMiddleware = createMiddleware2(
 );
 
 // src/server/hono/route.ts
-var routes = (app, options) => Effect49.gen(function* () {
+var routes = (app, options) => Effect51.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
   yield* ccvOptionsService.loadCliOptions(options);
   const envService = yield* EnvService;
@@ -8419,9 +8757,10 @@ var routes = (app, options) => Effect49.gen(function* () {
   const schedulerController = yield* SchedulerController;
   const featureFlagController = yield* FeatureFlagController;
   const searchController = yield* SearchController;
+  const tasksController = yield* TasksController;
   const authMiddlewareService = yield* AuthMiddleware;
   const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* authMiddlewareService;
-  const runtime = yield* Effect49.runtime();
+  const runtime = yield* Effect51.runtime();
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
     prexit(async () => {
@@ -8429,7 +8768,7 @@ var routes = (app, options) => Effect49.gen(function* () {
     });
   }
   return app.use(configMiddleware).use(authMiddleware).use(async (c, next) => {
-    await Effect49.runPromise(
+    await Effect51.runPromise(
       userConfigService.setUserConfig({
         ...c.get("userConfig")
       })
@@ -8437,7 +8776,7 @@ var routes = (app, options) => Effect49.gen(function* () {
     await next();
   }).post(
     "/api/auth/login",
-    zValidator("json", z30.object({ password: z30.string() })),
+    zValidator("json", z31.object({ password: z31.string() })),
     async (c) => {
       const { password } = c.req.valid("json");
       if (!authEnabled) {
@@ -8491,14 +8830,14 @@ var routes = (app, options) => Effect49.gen(function* () {
     return response;
   }).get(
     "/api/projects/:projectId",
-    zValidator("query", z30.object({ cursor: z30.string().optional() })),
+    zValidator("query", z31.object({ cursor: z31.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
         projectController.getProject({
           ...c.req.param(),
           ...c.req.valid("query")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8506,8 +8845,8 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/projects",
     zValidator(
       "json",
-      z30.object({
-        projectPath: z30.string().min(1, "Project path is required")
+      z31.object({
+        projectPath: z31.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -8515,7 +8854,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         c,
         projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8524,13 +8863,13 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect49.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect49.provide(runtime))
+      sessionController.getSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
@@ -8538,19 +8877,19 @@ var routes = (app, options) => Effect49.gen(function* () {
     async (c) => {
       const response = await effectToResponse(
         c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect49.provide(runtime))
+        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).delete("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.deleteSession({ ...c.req.param() }).pipe(Effect49.provide(runtime))
+      sessionController.deleteSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
     "/api/projects/:projectId/agent-sessions/:agentId",
-    zValidator("query", z30.object({ sessionId: z30.string().optional() })),
+    zValidator("query", z31.object({ sessionId: z31.string().optional() })),
     async (c) => {
       const { projectId, agentId } = c.req.param();
       const { sessionId } = c.req.valid("query");
@@ -8560,7 +8899,7 @@ var routes = (app, options) => Effect49.gen(function* () {
           projectId,
           agentId,
           sessionId
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8569,16 +8908,16 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       gitController.getCurrentRevisions({
         ...c.req.param()
-      }).pipe(Effect49.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).post(
     "/api/projects/:projectId/git/diff",
     zValidator(
       "json",
-      z30.object({
-        fromRef: z30.string().min(1, "fromRef is required"),
-        toRef: z30.string().min(1, "toRef is required")
+      z31.object({
+        fromRef: z31.string().min(1, "fromRef is required"),
+        toRef: z31.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -8587,7 +8926,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         gitController.getGitDiff({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8600,7 +8939,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         gitController.commitFiles({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8613,7 +8952,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         gitController.pushCommits({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8626,7 +8965,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         gitController.commitAndPush({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8635,7 +8974,7 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       claudeCodeController.getClaudeCommands({
         ...c.req.param()
-      }).pipe(Effect49.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/mcp/list", async (c) => {
@@ -8643,19 +8982,19 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       claudeCodeController.getMcpListRoute({
         ...c.req.param()
-      }).pipe(Effect49.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect49.provide(runtime))
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/features", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect49.provide(runtime))
+      claudeCodeController.getAvailableFeatures().pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/session-processes", async (c) => {
@@ -8668,10 +9007,10 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/cc/session-processes",
     zValidator(
       "json",
-      z30.object({
-        projectId: z30.string(),
+      z31.object({
+        projectId: z31.string(),
         input: userMessageInputSchema,
-        baseSessionId: z30.string().optional()
+        baseSessionId: z31.string().optional()
       })
     ),
     async (c) => {
@@ -8687,10 +9026,10 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/cc/session-processes/:sessionProcessId/continue",
     zValidator(
       "json",
-      z30.object({
-        projectId: z30.string(),
+      z31.object({
+        projectId: z31.string(),
         input: userMessageInputSchema,
-        baseSessionId: z30.string()
+        baseSessionId: z31.string()
       })
     ),
     async (c) => {
@@ -8699,16 +9038,16 @@ var routes = (app, options) => Effect49.gen(function* () {
         claudeCodeSessionProcessController.continueSessionProcess({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).post(
     "/api/cc/session-processes/:sessionProcessId/abort",
-    zValidator("json", z30.object({ projectId: z30.string() })),
+    zValidator("json", z31.object({ projectId: z31.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
-      void Effect49.runFork(
+      void Effect51.runFork(
         claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
       return c.json({ message: "Task aborted" });
@@ -8717,9 +9056,9 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/cc/permission-response",
     zValidator(
       "json",
-      z30.object({
-        permissionRequestId: z30.string(),
-        decision: z30.enum(["allow", "deny"])
+      z31.object({
+        permissionRequestId: z31.string(),
+        decision: z31.enum(["allow", "deny"])
       })
     ),
     async (c) => {
@@ -8736,7 +9075,7 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       async (rawStream) => {
         await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect49.provide(TypeSafeSSE.make(rawStream)))
+          sseController.handleSSE(rawStream).pipe(Effect51.provide(TypeSafeSSE.make(rawStream)))
         );
       },
       async (err) => {
@@ -8746,7 +9085,7 @@ var routes = (app, options) => Effect49.gen(function* () {
   }).get("/api/scheduler/jobs", async (c) => {
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect49.provide(runtime))
+      schedulerController.getJobs().pipe(Effect51.provide(runtime))
     );
     return response;
   }).post(
@@ -8757,7 +9096,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         c,
         schedulerController.addJob({
           job: c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8770,7 +9109,7 @@ var routes = (app, options) => Effect49.gen(function* () {
         schedulerController.updateJob({
           id: c.req.param("id"),
           job: c.req.valid("json")
-        }).pipe(Effect49.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -8779,16 +9118,16 @@ var routes = (app, options) => Effect49.gen(function* () {
       c,
       schedulerController.deleteJob({
         id: c.req.param("id")
-      }).pipe(Effect49.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
     "/api/fs/file-completion",
     zValidator(
       "query",
-      z30.object({
-        projectId: z30.string(),
-        basePath: z30.string().optional().default("/api/")
+      z31.object({
+        projectId: z31.string(),
+        basePath: z31.string().optional().default("/api/")
       })
     ),
     async (c) => {
@@ -8804,9 +9143,9 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/fs/directory-browser",
     zValidator(
       "query",
-      z30.object({
-        currentPath: z30.string().optional(),
-        showHidden: z30.string().optional().transform((val) => val === "true")
+      z31.object({
+        currentPath: z31.string().optional(),
+        showHidden: z31.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {
@@ -8822,42 +9161,119 @@ var routes = (app, options) => Effect49.gen(function* () {
     "/api/search",
     zValidator(
       "query",
-      z30.object({
-        q: z30.string().min(2),
-        limit: z30.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
-        projectId: z30.string().optional()
+      z31.object({
+        q: z31.string().min(2),
+        limit: z31.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z31.string().optional()
       })
     ),
     async (c) => {
       const { q, limit, projectId } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        searchController.search({ query: q, limit, projectId }).pipe(Effect49.provide(runtime))
+        searchController.search({ query: q, limit, projectId }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).get("/api/flags", async (c) => {
     const response = await effectToResponse(
       c,
-      featureFlagController.getFlags().pipe(Effect49.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect51.provide(runtime))
     );
     return response;
-  });
+  }).get(
+    "/api/tasks",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    async (c) => {
+      const { projectId, sessionId } = c.req.valid("query");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.listTasks(projectPath, sessionId).pipe(
+          Effect51.map((tasks) => ({
+            status: 200,
+            response: tasks
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  ).post(
+    "/api/tasks",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    zValidator("json", TaskCreateSchema),
+    async (c) => {
+      const { projectId, sessionId } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.createTask(projectPath, body, sessionId).pipe(
+          Effect51.map((task) => ({
+            status: 200,
+            response: task
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  ).patch(
+    "/api/tasks/:id",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    zValidator("json", TaskUpdateSchema.omit({ taskId: true })),
+    async (c) => {
+      const { id } = c.req.param();
+      const { projectId, sessionId } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.updateTask(projectPath, { ...body, taskId: id }, sessionId).pipe(
+          Effect51.map((task) => ({
+            status: 200,
+            response: task
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  );
 });
 
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer40 } from "effect";
-var platformLayer = Layer40.mergeAll(
+import { Layer as Layer42 } from "effect";
+var platformLayer = Layer42.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
   EnvService.Live,
   CcvOptionsService.Live
 ).pipe(
-  Layer40.provide(EnvService.Live),
-  Layer40.provide(CcvOptionsService.Live),
-  Layer40.provide(NodeContext.layer)
+  Layer42.provide(EnvService.Live),
+  Layer42.provide(CcvOptionsService.Live),
+  Layer42.provide(NodeContext.layer)
 );
 
 // src/server/startServer.ts
@@ -8880,50 +9296,8 @@ var startServer = async (options) => {
       return c.html(html);
     });
   }
-  const program2 = routes(honoApp, options).pipe(
-    /** Presentation */
-    Effect50.provide(ProjectController.Live),
-    Effect50.provide(SessionController.Live),
-    Effect50.provide(AgentSessionController.Live),
-    Effect50.provide(GitController.Live),
-    Effect50.provide(ClaudeCodeController.Live),
-    Effect50.provide(ClaudeCodeSessionProcessController.Live),
-    Effect50.provide(ClaudeCodePermissionController.Live),
-    Effect50.provide(FileSystemController.Live),
-    Effect50.provide(SSEController.Live),
-    Effect50.provide(SchedulerController.Live),
-    Effect50.provide(FeatureFlagController.Live),
-    Effect50.provide(SearchController.Live)
-  ).pipe(
-    /** Application */
-    Effect50.provide(InitializeService.Live),
-    Effect50.provide(FileWatcherService.Live),
-    Effect50.provide(RateLimitAutoScheduleService.Live),
-    Effect50.provide(AuthMiddleware.Live)
-  ).pipe(
-    /** Domain */
-    Effect50.provide(ClaudeCodeLifeCycleService.Live),
-    Effect50.provide(ClaudeCodePermissionService.Live),
-    Effect50.provide(ClaudeCodeSessionProcessService.Live),
-    Effect50.provide(ClaudeCodeService.Live),
-    Effect50.provide(GitService.Live),
-    Effect50.provide(SchedulerService.Live),
-    Effect50.provide(SchedulerConfigBaseDir.Live),
-    Effect50.provide(SearchService.Live)
-  ).pipe(
-    /** Infrastructure */
-    Effect50.provide(ProjectRepository.Live),
-    Effect50.provide(SessionRepository.Live),
-    Effect50.provide(ProjectMetaService.Live),
-    Effect50.provide(SessionMetaService.Live),
-    Effect50.provide(VirtualConversationDatabase.Live),
-    Effect50.provide(AgentSessionLayer)
-  ).pipe(
-    /** Platform */
-    Effect50.provide(platformLayer),
-    Effect50.provide(NodeContext2.layer)
-  );
-  await Effect50.runPromise(program2);
+  const program2 = routes(honoApp, options).pipe(Effect52.provide(MainLayer));
+  await Effect52.runPromise(program2);
   const port = isDevelopment ? (
     // biome-ignore lint/style/noProcessEnv: allow only here
     process.env.DEV_BE_PORT ?? "3401"
@@ -8943,12 +9317,65 @@ var startServer = async (options) => {
     }
   );
 };
+var PlatformLayer = Layer43.mergeAll(platformLayer, NodeContext2.layer);
+var InfraBasics = Layer43.mergeAll(
+  VirtualConversationDatabase.Live,
+  ProjectMetaService.Live,
+  SessionMetaService.Live
+);
+var InfraRepos = Layer43.mergeAll(
+  ProjectRepository.Live,
+  SessionRepository.Live
+).pipe(Layer43.provideMerge(InfraBasics));
+var InfraLayer = AgentSessionLayer.pipe(Layer43.provideMerge(InfraRepos));
+var DomainBase = Layer43.mergeAll(
+  ClaudeCodePermissionService.Live,
+  ClaudeCodeSessionProcessService.Live,
+  ClaudeCodeService.Live,
+  GitService.Live,
+  SchedulerService.Live,
+  SchedulerConfigBaseDir.Live,
+  SearchService.Live,
+  TasksService.Live
+);
+var DomainLayer = ClaudeCodeLifeCycleService.Live.pipe(
+  Layer43.provideMerge(DomainBase)
+);
+var AppServices = Layer43.mergeAll(
+  FileWatcherService.Live,
+  RateLimitAutoScheduleService.Live,
+  AuthMiddleware.Live
+);
+var ApplicationLayer = InitializeService.Live.pipe(
+  Layer43.provideMerge(AppServices)
+);
+var PresentationLayer = Layer43.mergeAll(
+  ProjectController.Live,
+  SessionController.Live,
+  AgentSessionController.Live,
+  GitController.Live,
+  ClaudeCodeController.Live,
+  ClaudeCodeSessionProcessController.Live,
+  ClaudeCodePermissionController.Live,
+  FileSystemController.Live,
+  SSEController.Live,
+  SchedulerController.Live,
+  FeatureFlagController.Live,
+  SearchController.Live,
+  TasksController.Live
+);
+var MainLayer = PresentationLayer.pipe(
+  Layer43.provideMerge(ApplicationLayer),
+  Layer43.provideMerge(DomainLayer),
+  Layer43.provideMerge(InfraLayer),
+  Layer43.provideMerge(PlatformLayer)
+);
 
 // src/server/main.ts
 var program = new Command3();
 program.name(package_default.name).version(package_default.version).description(package_default.description);
 program.option("-p, --port <port>", "port to listen on").option("-h, --hostname <hostname>", "hostname to listen on").option("-P, --password <password>", "password to authenticate").option("-e, --executable <executable>", "path to claude code executable").option("--claude-dir <claude-dir>", "path to claude directory").action(async (options) => {
-  await Effect51.runPromise(checkDeprecatedEnvs);
+  await Effect53.runPromise(checkDeprecatedEnvs);
   await startServer(options);
 });
 var main = async () => {