@kimuson/claude-code-viewer 0.4.6 → 0.4.7

package/dist/main.js

@@ -6,33 +6,380 @@ 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 Effect39 } from "effect";
+import { Effect as Effect42 } 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";
+
+// src/lib/conversation-schema/index.ts
+import { z as z16 } from "zod";
+
+// src/lib/conversation-schema/entry/AssistantEntrySchema.ts
+import { z as z8 } from "zod";
+
+// src/lib/conversation-schema/message/AssistantMessageSchema.ts
+import { z as z6 } from "zod";
+
+// src/lib/conversation-schema/content/TextContentSchema.ts
+import { z } from "zod";
+var TextContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+
+// src/lib/conversation-schema/content/ThinkingContentSchema.ts
+import { z as z2 } from "zod";
+var ThinkingContentSchema = z2.object({
+  type: z2.literal("thinking"),
+  thinking: z2.string(),
+  signature: z2.string().optional()
+});
+
+// src/lib/conversation-schema/content/ToolResultContentSchema.ts
+import { z as z4 } from "zod";
+
+// src/lib/conversation-schema/content/ImageContentSchema.ts
+import { z as z3 } from "zod";
+var ImageContentSchema = z3.object({
+  type: z3.literal("image"),
+  source: z3.object({
+    type: z3.literal("base64"),
+    data: z3.string(),
+    media_type: z3.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
+  })
+});
+
+// src/lib/conversation-schema/content/ToolResultContentSchema.ts
+var ToolResultContentSchema = z4.object({
+  type: z4.literal("tool_result"),
+  tool_use_id: z4.string(),
+  content: z4.union([
+    z4.string(),
+    z4.array(z4.union([TextContentSchema, ImageContentSchema]))
+  ]),
+  is_error: z4.boolean().optional()
+});
+
+// src/lib/conversation-schema/content/ToolUseContentSchema.ts
+import { z as z5 } from "zod";
+var ToolUseContentSchema = z5.object({
+  type: z5.literal("tool_use"),
+  id: z5.string(),
+  name: z5.string(),
+  input: z5.record(z5.string(), z5.unknown())
+});
+
+// src/lib/conversation-schema/message/AssistantMessageSchema.ts
+var AssistantMessageContentSchema = z6.union([
+  ThinkingContentSchema,
+  TextContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
+var AssistantMessageSchema = z6.object({
+  id: z6.string(),
+  container: z6.null().optional(),
+  type: z6.literal("message"),
+  role: z6.literal("assistant"),
+  model: z6.string(),
+  content: z6.array(AssistantMessageContentSchema),
+  stop_reason: z6.string().nullable(),
+  stop_sequence: z6.string().nullable(),
+  usage: z6.object({
+    input_tokens: z6.number(),
+    cache_creation_input_tokens: z6.number().optional(),
+    cache_read_input_tokens: z6.number().optional(),
+    cache_creation: z6.object({
+      ephemeral_5m_input_tokens: z6.number(),
+      ephemeral_1h_input_tokens: z6.number()
+    }).optional(),
+    output_tokens: z6.number(),
+    service_tier: z6.string().nullable().optional(),
+    server_tool_use: z6.object({
+      web_search_requests: z6.number()
+    }).optional()
+  })
+});
+
+// src/lib/conversation-schema/entry/BaseEntrySchema.ts
+import { z as z7 } from "zod";
+var BaseEntrySchema = z7.object({
+  // required
+  isSidechain: z7.boolean(),
+  userType: z7.enum(["external"]),
+  cwd: z7.string(),
+  sessionId: z7.string(),
+  version: z7.string(),
+  uuid: z7.uuid(),
+  timestamp: z7.string(),
+  // nullable
+  parentUuid: z7.uuid().nullable(),
+  // optional
+  isMeta: z7.boolean().optional(),
+  toolUseResult: z7.unknown().optional(),
+  // スキーマがツールごとに異なりすぎるし利用もしなそうなので unknown
+  gitBranch: z7.string().optional(),
+  isCompactSummary: z7.boolean().optional()
+});
+
+// src/lib/conversation-schema/entry/AssistantEntrySchema.ts
+var AssistantEntrySchema = BaseEntrySchema.extend({
+  // discriminator
+  type: z8.literal("assistant"),
+  // required
+  message: AssistantMessageSchema,
+  // optional
+  requestId: z8.string().optional(),
+  isApiErrorMessage: z8.boolean().optional()
+});
+
+// src/lib/conversation-schema/entry/FileHIstorySnapshotEntrySchema.ts
+import { z as z9 } from "zod";
+var FileHistorySnapshotEntrySchema = z9.object({
+  // discriminator
+  type: z9.literal("file-history-snapshot"),
+  // required
+  messageId: z9.string(),
+  snapshot: z9.object({
+    messageId: z9.string(),
+    trackedFileBackups: z9.record(z9.string(), z9.unknown()),
+    timestamp: z9.string()
+  }),
+  isSnapshotUpdate: z9.boolean()
+});
+
+// src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
+import { z as z11 } from "zod";
+
+// src/lib/conversation-schema/content/DocumentContentSchema.ts
+import { z as z10 } from "zod";
+var DocumentContentSchema = z10.object({
+  type: z10.literal("document"),
+  source: z10.union([
+    z10.object({
+      media_type: z10.literal("text/plain"),
+      type: z10.literal("text"),
+      data: z10.string()
+    }),
+    z10.object({
+      media_type: z10.enum(["application/pdf"]),
+      type: z10.literal("base64"),
+      data: z10.string()
+    })
+  ])
+});
+
+// src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
+var QueueOperationContentSchema = z11.union([
+  z11.string(),
+  TextContentSchema,
+  ToolResultContentSchema,
+  ImageContentSchema,
+  DocumentContentSchema
+]);
+var QueueOperationEntrySchema = z11.union([
+  z11.object({
+    type: z11.literal("queue-operation"),
+    operation: z11.literal("enqueue"),
+    content: z11.union([
+      z11.string(),
+      z11.array(z11.union([z11.string(), QueueOperationContentSchema]))
+    ]),
+    sessionId: z11.string(),
+    timestamp: z11.iso.datetime()
+  }),
+  z11.object({
+    type: z11.literal("queue-operation"),
+    operation: z11.literal("dequeue"),
+    sessionId: z11.string(),
+    timestamp: z11.iso.datetime()
+  })
+]);
+
+// src/lib/conversation-schema/entry/SummaryEntrySchema.ts
+import { z as z12 } from "zod";
+var SummaryEntrySchema = z12.object({
+  type: z12.literal("summary"),
+  summary: z12.string(),
+  leafUuid: z12.string().uuid()
+});
+
+// src/lib/conversation-schema/entry/SystemEntrySchema.ts
+import { z as z13 } from "zod";
+var SystemEntrySchema = BaseEntrySchema.extend({
+  // discriminator
+  type: z13.literal("system"),
+  // required
+  content: z13.string(),
+  toolUseID: z13.string(),
+  level: z13.enum(["info"])
+});
+
+// src/lib/conversation-schema/entry/UserEntrySchema.ts
+import { z as z15 } from "zod";
+
+// src/lib/conversation-schema/message/UserMessageSchema.ts
+import { z as z14 } from "zod";
+var UserMessageContentSchema = z14.union([
+  z14.string(),
+  TextContentSchema,
+  ToolResultContentSchema,
+  ImageContentSchema,
+  DocumentContentSchema
+]);
+var UserMessageSchema = z14.object({
+  role: z14.literal("user"),
+  content: z14.union([
+    z14.string(),
+    z14.array(z14.union([z14.string(), UserMessageContentSchema]))
+  ])
+});
+
+// src/lib/conversation-schema/entry/UserEntrySchema.ts
+var UserEntrySchema = BaseEntrySchema.extend({
+  // discriminator
+  type: z15.literal("user"),
+  // required
+  message: UserMessageSchema
+});
+
+// src/lib/conversation-schema/index.ts
+var ConversationSchema = z16.union([
+  UserEntrySchema,
+  AssistantEntrySchema,
+  SummaryEntrySchema,
+  SystemEntrySchema,
+  FileHistorySnapshotEntrySchema,
+  QueueOperationEntrySchema
+]);
+
+// src/server/core/claude-code/functions/parseJsonl.ts
+var parseJsonl = (content) => {
+  const lines = content.trim().split("\n").filter((line) => line.trim() !== "");
+  return lines.map((line, index) => {
+    const parsed = ConversationSchema.safeParse(JSON.parse(line));
+    if (!parsed.success) {
+      const errorData = {
+        type: "x-error",
+        line,
+        lineNumber: index + 1
+      };
+      return errorData;
+    }
+    return parsed.data;
+  });
+};
+
+// src/server/core/project/functions/id.ts
+import { dirname } from "node:path";
+var encodeProjectId = (fullPath) => {
+  return Buffer.from(fullPath).toString("base64url");
+};
+var decodeProjectId = (id) => {
+  return Buffer.from(id, "base64url").toString("utf-8");
+};
+var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
+  return encodeProjectId(dirname(sessionFilePath));
+};
+
+// src/server/core/agent-session/infrastructure/AgentSessionRepository.ts
+var LayerImpl = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const getAgentSessionByAgentId = (projectId, agentId) => Effect.gen(function* () {
+    const projectPath = decodeProjectId(projectId);
+    const agentFilePath = path.resolve(projectPath, `agent-${agentId}.jsonl`);
+    const exists = yield* fs.exists(agentFilePath);
+    if (!exists) {
+      return null;
+    }
+    const content = yield* fs.readFileString(agentFilePath);
+    const conversations = parseJsonl(content);
+    return conversations;
+  });
+  return {
+    getAgentSessionByAgentId
+  };
+});
+var AgentSessionRepository = class extends Context.Tag(
+  "AgentSessionRepository"
+)() {
+  static {
+    this.Live = Layer.effect(this, LayerImpl);
+  }
+};
+
+// 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* () {
+  const repository = yield* AgentSessionRepository;
+  const getAgentSession = (params) => Effect2.gen(function* () {
+    const { projectId, agentId } = params;
+    const conversations = yield* repository.getAgentSessionByAgentId(
+      projectId,
+      agentId
+    );
+    if (conversations === null) {
+      return {
+        status: 200,
+        response: {
+          agentSessionId: null,
+          conversations: []
+        }
+      };
+    }
+    return {
+      status: 200,
+      response: {
+        agentSessionId: agentId,
+        conversations
+      }
+    };
+  });
+  return {
+    getAgentSession
+  };
+});
+var AgentSessionController = class extends Context2.Tag(
+  "AgentSessionController"
+)() {
+  static {
+    this.Live = Layer2.effect(this, LayerImpl2);
+  }
+};
+
+// src/server/core/agent-session/index.ts
+var AgentSessionLayer = Layer3.mergeAll(AgentSessionRepository.Live);
 
 // src/server/core/claude-code/presentation/ClaudeCodeController.ts
-import { FileSystem as FileSystem4, Path as Path6 } from "@effect/platform";
-import { Context as Context7, Effect as Effect9, Layer as Layer8 } from "effect";
+import { FileSystem as FileSystem6, Path as Path8 } from "@effect/platform";
+import { Context as Context9, Effect as Effect12, Layer as Layer11 } from "effect";
 
 // src/server/core/platform/services/ApplicationContext.ts
 import { homedir } from "node:os";
-import { Path } from "@effect/platform";
-import { Effect as Effect2, Context as EffectContext, Layer as Layer2 } from "effect";
+import { Path as Path2 } from "@effect/platform";
+import { Effect as Effect4, Context as EffectContext, Layer as Layer5 } from "effect";
 
 // src/server/core/platform/services/EnvService.ts
-import { Context, Effect, Layer, Ref } from "effect";
+import { Context as Context3, Effect as Effect3, Layer as Layer4, Ref } from "effect";
 
 // src/server/core/platform/schema.ts
-import { z } from "zod";
-var envSchema = z.object({
-  NODE_ENV: z.enum(["development", "production", "test"]).optional().default("development"),
-  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: z.string().optional(),
-  GLOBAL_CLAUDE_DIR: z.string().optional(),
-  NEXT_PHASE: z.string().optional(),
-  PORT: z.string().optional().default("3000").transform((val) => parseInt(val, 10)),
-  PATH: z.string().optional()
+import { z as z17 } from "zod";
+var envSchema = z17.object({
+  NODE_ENV: z17.enum(["development", "production", "test"]).optional().default("development"),
+  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: z17.string().optional(),
+  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()
 });
 
 // src/server/core/platform/services/EnvService.ts
-var LayerImpl = Effect.gen(function* () {
+var LayerImpl3 = Effect3.gen(function* () {
   const envRef = yield* Ref.make(void 0);
   const parseEnv = () => {
     const parsed = envSchema.safeParse(process.env);
@@ -43,7 +390,7 @@ var LayerImpl = Effect.gen(function* () {
     return parsed.data;
   };
   const getEnv = (key) => {
-    return Effect.gen(function* () {
+    return Effect3.gen(function* () {
       yield* Ref.update(envRef, (existingEnv) => {
         if (existingEnv === void 0) {
           return parseEnv();
@@ -63,18 +410,18 @@ var LayerImpl = Effect.gen(function* () {
     getEnv
   };
 });
-var EnvService = class extends Context.Tag("EnvService")() {
+var EnvService = class extends Context3.Tag("EnvService")() {
   static {
-    this.Live = Layer.effect(this, LayerImpl);
+    this.Live = Layer4.effect(this, LayerImpl3);
   }
 };
 
 // src/server/core/platform/services/ApplicationContext.ts
-var LayerImpl2 = Effect2.gen(function* () {
-  const path = yield* Path.Path;
+var LayerImpl4 = Effect4.gen(function* () {
+  const path = yield* Path2.Path;
   const envService = yield* EnvService;
   const globalClaudeDirectoryPath = yield* envService.getEnv("GLOBAL_CLAUDE_DIR").pipe(
-    Effect2.map(
+    Effect4.map(
       (envVar) => envVar === void 0 ? path.resolve(homedir(), ".claude") : path.resolve(envVar)
     )
   );
@@ -89,38 +436,26 @@ var LayerImpl2 = Effect2.gen(function* () {
 });
 var ApplicationContext = class extends EffectContext.Tag("ApplicationContext")() {
   static {
-    this.Live = Layer2.effect(this, LayerImpl2);
+    this.Live = Layer5.effect(this, LayerImpl4);
   }
 };
 
 // src/server/core/project/infrastructure/ProjectRepository.ts
-import { FileSystem as FileSystem3, Path as Path4 } from "@effect/platform";
-import { Context as Context5, Effect as Effect6, Layer as Layer6, Option as Option2 } from "effect";
-
-// src/server/core/project/functions/id.ts
-import { dirname } from "node:path";
-var encodeProjectId = (fullPath) => {
-  return Buffer.from(fullPath).toString("base64url");
-};
-var decodeProjectId = (id) => {
-  return Buffer.from(id, "base64url").toString("utf-8");
-};
-var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
-  return encodeProjectId(dirname(sessionFilePath));
-};
+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";
 
 // src/server/core/project/services/ProjectMetaService.ts
-import { FileSystem as FileSystem2, Path as Path3 } from "@effect/platform";
-import { Context as Context4, Effect as Effect5, Layer as Layer5, Option, Ref as Ref3 } from "effect";
+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";
 
 // src/server/lib/storage/FileCacheStorage/index.ts
-import { Context as Context3, Effect as Effect4, Layer as Layer4, Ref as Ref2, Runtime } from "effect";
+import { Context as Context5, Effect as Effect6, Layer as Layer7, Ref as Ref2, Runtime } from "effect";
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
-import { FileSystem, Path as Path2 } from "@effect/platform";
-import { Context as Context2, Effect as Effect3, Layer as Layer3 } from "effect";
-import { z as z2 } from "zod";
+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";
 
 // src/server/lib/config/paths.ts
 import { homedir as homedir2 } from "node:os";
@@ -132,14 +467,14 @@ var claudeCodeViewerCacheDirPath = resolve(
 );
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
-var saveSchema = z2.array(z2.tuple([z2.string(), z2.unknown()]));
-var LayerImpl3 = Effect3.gen(function* () {
-  const path = yield* Path2.Path;
+var saveSchema = z18.array(z18.tuple([z18.string(), z18.unknown()]));
+var LayerImpl5 = Effect5.gen(function* () {
+  const path = yield* Path3.Path;
   const getCacheFilePath = (key) => path.resolve(claudeCodeViewerCacheDirPath, `${key}.json`);
   const load = (key) => {
     const cacheFilePath = getCacheFilePath(key);
-    return Effect3.gen(function* () {
-      const fs = yield* FileSystem.FileSystem;
+    return Effect5.gen(function* () {
+      const fs = yield* FileSystem2.FileSystem;
       if (!(yield* fs.exists(claudeCodeViewerCacheDirPath))) {
         yield* fs.makeDirectory(claudeCodeViewerCacheDirPath, {
           recursive: true
@@ -169,8 +504,8 @@ var LayerImpl3 = Effect3.gen(function* () {
   };
   const save = (key, entries) => {
     const cacheFilePath = getCacheFilePath(key);
-    return Effect3.gen(function* () {
-      const fs = yield* FileSystem.FileSystem;
+    return Effect5.gen(function* () {
+      const fs = yield* FileSystem2.FileSystem;
       yield* fs.writeFileString(cacheFilePath, JSON.stringify(entries));
     });
   };
@@ -179,20 +514,20 @@ var LayerImpl3 = Effect3.gen(function* () {
     save
   };
 });
-var PersistentService = class extends Context2.Tag("PersistentService")() {
+var PersistentService = class extends Context4.Tag("PersistentService")() {
   static {
-    this.Live = Layer3.effect(this, LayerImpl3);
+    this.Live = Layer6.effect(this, LayerImpl5);
   }
 };
 
 // src/server/lib/storage/FileCacheStorage/index.ts
-var FileCacheStorage = () => Context3.GenericTag("FileCacheStorage");
-var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
+var FileCacheStorage = () => Context5.GenericTag("FileCacheStorage");
+var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
   FileCacheStorage(),
-  Effect4.gen(function* () {
+  Effect6.gen(function* () {
     const persistentService = yield* PersistentService;
-    const runtime = yield* Effect4.runtime();
-    const storageRef = yield* Effect4.gen(function* () {
+    const runtime = yield* Effect6.runtime();
+    const storageRef = yield* Effect6.gen(function* () {
       const persistedData = yield* persistentService.load(storageKey);
       const initialMap = /* @__PURE__ */ new Map();
       for (const [key, value] of persistedData) {
@@ -207,11 +542,11 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
       Runtime.runFork(runtime)(persistentService.save(storageKey, entries));
     };
     return {
-      get: (key) => Effect4.gen(function* () {
+      get: (key) => Effect6.gen(function* () {
         const storage = yield* Ref2.get(storageRef);
         return storage.get(key);
       }),
-      set: (key, value) => Effect4.gen(function* () {
+      set: (key, value) => Effect6.gen(function* () {
         const before = yield* Ref2.get(storageRef);
         const beforeString = JSON.stringify(Array.from(before.entries()));
         yield* Ref2.update(storageRef, (map) => {
@@ -224,7 +559,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
           syncToFile(Array.from(after.entries()));
         }
       }),
-      invalidate: (key) => Effect4.gen(function* () {
+      invalidate: (key) => Effect6.gen(function* () {
         const before = yield* Ref2.get(storageRef);
         if (!before.has(key)) {
           return;
@@ -236,7 +571,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
         const after = yield* Ref2.get(storageRef);
         syncToFile(Array.from(after.entries()));
       }),
-      getAll: () => Effect4.gen(function* () {
+      getAll: () => Effect6.gen(function* () {
         const storage = yield* Ref2.get(storageRef);
         return new Map(storage);
       })
@@ -244,273 +579,14 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
   })
 );
 
-// src/lib/conversation-schema/index.ts
-import { z as z18 } from "zod";
-
-// src/lib/conversation-schema/entry/AssistantEntrySchema.ts
-import { z as z10 } from "zod";
-
-// src/lib/conversation-schema/message/AssistantMessageSchema.ts
-import { z as z8 } from "zod";
-
-// src/lib/conversation-schema/content/TextContentSchema.ts
-import { z as z3 } from "zod";
-var TextContentSchema = z3.object({
-  type: z3.literal("text"),
-  text: z3.string()
-});
-
-// src/lib/conversation-schema/content/ThinkingContentSchema.ts
-import { z as z4 } from "zod";
-var ThinkingContentSchema = z4.object({
-  type: z4.literal("thinking"),
-  thinking: z4.string(),
-  signature: z4.string().optional()
-});
-
-// src/lib/conversation-schema/content/ToolResultContentSchema.ts
-import { z as z6 } from "zod";
-
-// src/lib/conversation-schema/content/ImageContentSchema.ts
-import { z as z5 } from "zod";
-var ImageContentSchema = z5.object({
-  type: z5.literal("image"),
-  source: z5.object({
-    type: z5.literal("base64"),
-    data: z5.string(),
-    media_type: z5.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
-  })
-});
-
-// src/lib/conversation-schema/content/ToolResultContentSchema.ts
-var ToolResultContentSchema = z6.object({
-  type: z6.literal("tool_result"),
-  tool_use_id: z6.string(),
-  content: z6.union([
-    z6.string(),
-    z6.array(z6.union([TextContentSchema, ImageContentSchema]))
-  ]),
-  is_error: z6.boolean().optional()
-});
-
-// src/lib/conversation-schema/content/ToolUseContentSchema.ts
-import { z as z7 } from "zod";
-var ToolUseContentSchema = z7.object({
-  type: z7.literal("tool_use"),
-  id: z7.string(),
-  name: z7.string(),
-  input: z7.record(z7.string(), z7.unknown())
-});
-
-// src/lib/conversation-schema/message/AssistantMessageSchema.ts
-var AssistantMessageContentSchema = z8.union([
-  ThinkingContentSchema,
-  TextContentSchema,
-  ToolUseContentSchema,
-  ToolResultContentSchema
-]);
-var AssistantMessageSchema = z8.object({
-  id: z8.string(),
-  container: z8.null().optional(),
-  type: z8.literal("message"),
-  role: z8.literal("assistant"),
-  model: z8.string(),
-  content: z8.array(AssistantMessageContentSchema),
-  stop_reason: z8.string().nullable(),
-  stop_sequence: z8.string().nullable(),
-  usage: z8.object({
-    input_tokens: z8.number(),
-    cache_creation_input_tokens: z8.number().optional(),
-    cache_read_input_tokens: z8.number().optional(),
-    cache_creation: z8.object({
-      ephemeral_5m_input_tokens: z8.number(),
-      ephemeral_1h_input_tokens: z8.number()
-    }).optional(),
-    output_tokens: z8.number(),
-    service_tier: z8.string().nullable().optional(),
-    server_tool_use: z8.object({
-      web_search_requests: z8.number()
-    }).optional()
-  })
-});
-
-// src/lib/conversation-schema/entry/BaseEntrySchema.ts
-import { z as z9 } from "zod";
-var BaseEntrySchema = z9.object({
-  // required
-  isSidechain: z9.boolean(),
-  userType: z9.enum(["external"]),
-  cwd: z9.string(),
-  sessionId: z9.string(),
-  version: z9.string(),
-  uuid: z9.uuid(),
-  timestamp: z9.string(),
-  // nullable
-  parentUuid: z9.uuid().nullable(),
-  // optional
-  isMeta: z9.boolean().optional(),
-  toolUseResult: z9.unknown().optional(),
-  // スキーマがツールごとに異なりすぎるし利用もしなそうなので unknown
-  gitBranch: z9.string().optional(),
-  isCompactSummary: z9.boolean().optional()
-});
-
-// src/lib/conversation-schema/entry/AssistantEntrySchema.ts
-var AssistantEntrySchema = BaseEntrySchema.extend({
-  // discriminator
-  type: z10.literal("assistant"),
-  // required
-  message: AssistantMessageSchema,
-  // optional
-  requestId: z10.string().optional(),
-  isApiErrorMessage: z10.boolean().optional()
-});
-
-// src/lib/conversation-schema/entry/FileHIstorySnapshotEntrySchema.ts
-import { z as z11 } from "zod";
-var FileHistorySnapshotEntrySchema = z11.object({
-  // discriminator
-  type: z11.literal("file-history-snapshot"),
-  // required
-  messageId: z11.string(),
-  snapshot: z11.object({
-    messageId: z11.string(),
-    trackedFileBackups: z11.record(z11.string(), z11.unknown()),
-    timestamp: z11.string()
-  }),
-  isSnapshotUpdate: z11.boolean()
-});
-
-// src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-import { z as z13 } from "zod";
-
-// src/lib/conversation-schema/content/DocumentContentSchema.ts
-import { z as z12 } from "zod";
-var DocumentContentSchema = z12.object({
-  type: z12.literal("document"),
-  source: z12.union([
-    z12.object({
-      media_type: z12.literal("text/plain"),
-      type: z12.literal("text"),
-      data: z12.string()
-    }),
-    z12.object({
-      media_type: z12.enum(["application/pdf"]),
-      type: z12.literal("base64"),
-      data: z12.string()
-    })
-  ])
-});
-
-// src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-var QueueOperationContentSchema = z13.union([
-  z13.string(),
-  TextContentSchema,
-  ToolResultContentSchema,
-  ImageContentSchema,
-  DocumentContentSchema
-]);
-var QueueOperationEntrySchema = z13.union([
-  z13.object({
-    type: z13.literal("queue-operation"),
-    operation: z13.literal("enqueue"),
-    content: z13.union([
-      z13.string(),
-      z13.array(z13.union([z13.string(), QueueOperationContentSchema]))
-    ]),
-    sessionId: z13.string(),
-    timestamp: z13.iso.datetime()
-  }),
-  z13.object({
-    type: z13.literal("queue-operation"),
-    operation: z13.literal("dequeue"),
-    sessionId: z13.string(),
-    timestamp: z13.iso.datetime()
-  })
-]);
-
-// src/lib/conversation-schema/entry/SummaryEntrySchema.ts
-import { z as z14 } from "zod";
-var SummaryEntrySchema = z14.object({
-  type: z14.literal("summary"),
-  summary: z14.string(),
-  leafUuid: z14.string().uuid()
-});
-
-// src/lib/conversation-schema/entry/SystemEntrySchema.ts
-import { z as z15 } from "zod";
-var SystemEntrySchema = BaseEntrySchema.extend({
-  // discriminator
-  type: z15.literal("system"),
-  // required
-  content: z15.string(),
-  toolUseID: z15.string(),
-  level: z15.enum(["info"])
-});
-
-// src/lib/conversation-schema/entry/UserEntrySchema.ts
-import { z as z17 } from "zod";
-
-// src/lib/conversation-schema/message/UserMessageSchema.ts
-import { z as z16 } from "zod";
-var UserMessageContentSchema = z16.union([
-  z16.string(),
-  TextContentSchema,
-  ToolResultContentSchema,
-  ImageContentSchema,
-  DocumentContentSchema
-]);
-var UserMessageSchema = z16.object({
-  role: z16.literal("user"),
-  content: z16.union([
-    z16.string(),
-    z16.array(z16.union([z16.string(), UserMessageContentSchema]))
-  ])
-});
-
-// src/lib/conversation-schema/entry/UserEntrySchema.ts
-var UserEntrySchema = BaseEntrySchema.extend({
-  // discriminator
-  type: z17.literal("user"),
-  // required
-  message: UserMessageSchema
-});
-
-// src/lib/conversation-schema/index.ts
-var ConversationSchema = z18.union([
-  UserEntrySchema,
-  AssistantEntrySchema,
-  SummaryEntrySchema,
-  SystemEntrySchema,
-  FileHistorySnapshotEntrySchema,
-  QueueOperationEntrySchema
-]);
-
-// src/server/core/claude-code/functions/parseJsonl.ts
-var parseJsonl = (content) => {
-  const lines = content.trim().split("\n").filter((line) => line.trim() !== "");
-  return lines.map((line, index) => {
-    const parsed = ConversationSchema.safeParse(JSON.parse(line));
-    if (!parsed.success) {
-      const errorData = {
-        type: "x-error",
-        line,
-        lineNumber: index + 1
-      };
-      return errorData;
-    }
-    return parsed.data;
-  });
-};
-
 // src/server/core/project/services/ProjectMetaService.ts
 var ProjectPathSchema = z19.string().nullable();
-var LayerImpl4 = Effect5.gen(function* () {
-  const fs = yield* FileSystem2.FileSystem;
-  const path = yield* Path3.Path;
+var LayerImpl6 = Effect7.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) => Effect5.gen(function* () {
+  const extractProjectPathFromJsonl = (filePath) => Effect7.gen(function* () {
     const cached = yield* projectPathCache.get(filePath);
     if (cached !== void 0) {
       return cached;
@@ -531,7 +607,7 @@ var LayerImpl4 = Effect5.gen(function* () {
     }
     return cwd;
   });
-  const getProjectMeta = (projectId) => Effect5.gen(function* () {
+  const getProjectMeta = (projectId) => Effect7.gen(function* () {
     const metaCache = yield* Ref3.get(projectMetaCacheRef);
     const cached = metaCache.get(projectId);
     if (cached !== void 0) {
@@ -539,9 +615,9 @@ var LayerImpl4 = Effect5.gen(function* () {
     }
     const claudeProjectPath = decodeProjectId(projectId);
     const dirents = yield* fs.readDirectory(claudeProjectPath);
-    const fileEntries = yield* Effect5.all(
+    const fileEntries = yield* Effect7.all(
       dirents.filter((name) => name.endsWith(".jsonl")).map(
-        (name) => Effect5.gen(function* () {
+        (name) => Effect7.gen(function* () {
           const fullPath = path.resolve(claudeProjectPath, name);
           const stat = yield* fs.stat(fullPath);
           const mtime = Option.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date(0));
@@ -575,7 +651,7 @@ var LayerImpl4 = Effect5.gen(function* () {
     });
     return projectMeta;
   });
-  const invalidateProject = (projectId) => Effect5.gen(function* () {
+  const invalidateProject = (projectId) => Effect7.gen(function* () {
     yield* Ref3.update(projectMetaCacheRef, (cache) => {
       cache.delete(projectId);
       return cache;
@@ -586,28 +662,28 @@ var LayerImpl4 = Effect5.gen(function* () {
     invalidateProject
   };
 });
-var ProjectMetaService = class extends Context4.Tag("ProjectMetaService")() {
+var ProjectMetaService = class extends Context6.Tag("ProjectMetaService")() {
   static {
-    this.Live = Layer5.effect(this, LayerImpl4).pipe(
-      Layer5.provide(
+    this.Live = Layer8.effect(this, LayerImpl6).pipe(
+      Layer8.provide(
         makeFileCacheStorageLayer("project-path-cache", ProjectPathSchema)
       ),
-      Layer5.provide(PersistentService.Live)
+      Layer8.provide(PersistentService.Live)
     );
   }
 };
 
 // src/server/core/project/infrastructure/ProjectRepository.ts
-var LayerImpl5 = Effect6.gen(function* () {
-  const fs = yield* FileSystem3.FileSystem;
-  const path = yield* Path4.Path;
+var LayerImpl7 = Effect8.gen(function* () {
+  const fs = yield* FileSystem4.FileSystem;
+  const path = yield* Path5.Path;
   const projectMetaService = yield* ProjectMetaService;
   const context = yield* ApplicationContext;
-  const getProject = (projectId) => Effect6.gen(function* () {
+  const getProject = (projectId) => Effect8.gen(function* () {
     const fullPath = decodeProjectId(projectId);
     const exists = yield* fs.exists(fullPath);
     if (!exists) {
-      return yield* Effect6.fail(new Error("Project not found"));
+      return yield* Effect8.fail(new Error("Project not found"));
     }
     const stat = yield* fs.stat(fullPath);
     const meta = yield* projectMetaService.getProjectMeta(projectId);
@@ -620,7 +696,7 @@ var LayerImpl5 = Effect6.gen(function* () {
       }
     };
   });
-  const getProjects = () => Effect6.gen(function* () {
+  const getProjects = () => Effect8.gen(function* () {
     const dirExists = yield* fs.exists(
       context.claudeCodePaths.claudeProjectsDirPath
     );
@@ -634,14 +710,14 @@ var LayerImpl5 = Effect6.gen(function* () {
       context.claudeCodePaths.claudeProjectsDirPath
     );
     const projectEffects = entries.map(
-      (entry) => Effect6.gen(function* () {
+      (entry) => Effect8.gen(function* () {
         const fullPath = path.resolve(
           context.claudeCodePaths.claudeProjectsDirPath,
           entry
         );
-        const stat = yield* Effect6.tryPromise(
-          () => fs.stat(fullPath).pipe(Effect6.runPromise)
-        ).pipe(Effect6.catchAll(() => Effect6.succeed(null)));
+        const stat = yield* Effect8.tryPromise(
+          () => fs.stat(fullPath).pipe(Effect8.runPromise)
+        ).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
         if (!stat || stat.type !== "Directory") {
           return null;
         }
@@ -655,7 +731,7 @@ var LayerImpl5 = Effect6.gen(function* () {
         };
       })
     );
-    const projectsWithNulls = yield* Effect6.all(projectEffects, {
+    const projectsWithNulls = yield* Effect8.all(projectEffects, {
       concurrency: "unbounded"
     });
     const projects = projectsWithNulls.filter(
@@ -671,12 +747,57 @@ var LayerImpl5 = Effect6.gen(function* () {
     getProjects
   };
 });
-var ProjectRepository = class extends Context5.Tag("ProjectRepository")() {
+var ProjectRepository = class extends Context7.Tag("ProjectRepository")() {
   static {
-    this.Live = Layer6.effect(this, LayerImpl5);
+    this.Live = Layer9.effect(this, LayerImpl7);
   }
 };
 
+// src/server/core/claude-code/functions/scanCommandFiles.ts
+import { FileSystem as FileSystem5, Path as Path6 } from "@effect/platform";
+import { Effect as Effect9 } 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* () {
+  const fs = yield* FileSystem5.FileSystem;
+  const path = yield* Path6.Path;
+  const scanDirectory = (currentPath) => Effect9.gen(function* () {
+    const exists = yield* fs.exists(currentPath);
+    if (!exists) {
+      return [];
+    }
+    const items = yield* fs.readDirectory(currentPath);
+    const results = yield* Effect9.forEach(
+      items,
+      (item) => Effect9.gen(function* () {
+        if (item.startsWith(".")) {
+          return [];
+        }
+        const itemPath = path.join(currentPath, item);
+        const info = yield* fs.stat(itemPath);
+        if (info.type === "Directory") {
+          return yield* scanDirectory(itemPath);
+        }
+        if (info.type === "File" && item.endsWith(".md")) {
+          return [pathToCommandName(itemPath, dirPath)];
+        }
+        return [];
+      }),
+      { concurrency: "unbounded" }
+    );
+    return results.flat();
+  });
+  return yield* scanDirectory(dirPath).pipe(
+    Effect9.match({
+      onSuccess: (items) => items,
+      onFailure: () => []
+    })
+  );
+});
+
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
 import { z as z20 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
@@ -704,7 +825,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 Context6, Data as Data2, Effect as Effect8, Layer as Layer7 } from "effect";
+import { Context as Context8, Data as Data2, Effect as Effect11, Layer as Layer10 } from "effect";
 
 // src/server/core/claude-code/functions/parseMcpListOutput.ts
 var parseMcpListOutput = (output) => {
@@ -732,14 +853,14 @@ import { query as agentSdkQuery } from "@anthropic-ai/claude-agent-sdk";
 import {
   query as claudeCodeQuery
 } from "@anthropic-ai/claude-code";
-import { Command, Path as Path5 } from "@effect/platform";
-import { Data, Effect as Effect7 } from "effect";
+import { Command, Path as Path7 } from "@effect/platform";
+import { Data, Effect as Effect10 } from "effect";
 var ClaudeCodePathNotFoundError = class extends Data.TaggedError(
   "ClaudeCodePathNotFoundError"
 ) {
 };
-var resolveClaudeCodePath = Effect7.gen(function* () {
-  const path = yield* Path5.Path;
+var resolveClaudeCodePath = Effect10.gen(function* () {
+  const path = yield* Path7.Path;
   const envService = yield* EnvService;
   const specifiedExecutablePath = yield* envService.getEnv(
     "CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH"
@@ -756,15 +877,15 @@ var resolveClaudeCodePath = Effect7.gen(function* () {
       Command.runInShell(true)
     )
   ).pipe(
-    Effect7.map((output) => output.trim()),
-    Effect7.map((output) => output === "" ? null : output),
+    Effect10.map((output) => output.trim()),
+    Effect10.map((output) => output === "" ? null : output),
     // 存在しない時、空文字になる模様
-    Effect7.catchAll(() => Effect7.succeed(null))
+    Effect10.catchAll(() => Effect10.succeed(null))
   );
   if (whichClaude !== null) {
     return whichClaude;
   }
-  const projectClaudeCode = yield* Effect7.try(() => {
+  const projectClaudeCode = yield* Effect10.try(() => {
     const parts = __dirname.split("/");
     const packagePath = parts.slice(0, parts.indexOf("claude-code-viewer") + 1).join("/");
     return path.join(
@@ -775,8 +896,8 @@ var resolveClaudeCodePath = Effect7.gen(function* () {
       "cli.js"
     );
   }).pipe(
-    Effect7.catchAll(() => {
-      return Effect7.fail(
+    Effect10.catchAll(() => {
+      return Effect10.fail(
         new ClaudeCodePathNotFoundError({
           message: "Claude Code CLI not found in any location"
         })
@@ -785,7 +906,7 @@ var resolveClaudeCodePath = Effect7.gen(function* () {
   );
   return projectClaudeCode;
 });
-var Config = Effect7.gen(function* () {
+var Config = Effect10.gen(function* () {
   const claudeCodeExecutablePath = yield* resolveClaudeCodePath;
   const claudeCodeVersion = fromCLIString(
     yield* Command.string(Command.make(claudeCodeExecutablePath, "--version"))
@@ -795,7 +916,7 @@ var Config = Effect7.gen(function* () {
     claudeCodeVersion
   };
 });
-var getMcpListOutput = (projectCwd) => Effect7.gen(function* () {
+var getMcpListOutput = (projectCwd) => Effect10.gen(function* () {
   const { claudeCodeExecutablePath } = yield* Config;
   const output = yield* Command.string(
     Command.make(
@@ -825,11 +946,17 @@ var getAvailableFeatures = (claudeCodeVersion) => ({
     minor: 0,
     patch: 125
     // ClaudeCodeAgentSDK is available since v1.0.125
+  }) : false,
+  sidechainSeparation: claudeCodeVersion !== null ? greaterThanOrEqual(claudeCodeVersion, {
+    major: 2,
+    minor: 0,
+    patch: 28
+    // Sidechain conversations stored in agent-*.jsonl since v2.0.28
   }) : false
 });
 var query = (prompt, options) => {
   const { canUseTool, permissionMode, ...baseOptions } = options;
-  return Effect7.gen(function* () {
+  return Effect10.gen(function* () {
     const { claudeCodeExecutablePath, claudeCodeVersion } = yield* Config;
     const availableFeatures = getAvailableFeatures(claudeCodeVersion);
     const options2 = {
@@ -879,23 +1006,23 @@ var ProjectPathNotFoundError = class extends Data2.TaggedError(
   "ProjectPathNotFoundError"
 ) {
 };
-var LayerImpl6 = Effect8.gen(function* () {
+var LayerImpl8 = Effect11.gen(function* () {
   const projectRepository = yield* ProjectRepository;
-  const getClaudeCodeMeta = () => Effect8.gen(function* () {
+  const getClaudeCodeMeta = () => Effect11.gen(function* () {
     const config = yield* Config;
     return config;
   });
-  const getAvailableFeatures2 = () => Effect8.gen(function* () {
+  const getAvailableFeatures2 = () => Effect11.gen(function* () {
     const config = yield* Config;
     const features = getAvailableFeatures(
       config.claudeCodeVersion
     );
     return features;
   });
-  const getMcpList = (projectId) => Effect8.gen(function* () {
+  const getMcpList = (projectId) => Effect11.gen(function* () {
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
-      return yield* Effect8.fail(new ProjectPathNotFoundError({ projectId }));
+      return yield* Effect11.fail(new ProjectPathNotFoundError({ projectId }));
     }
     const output = yield* getMcpListOutput(
       project.meta.projectPath
@@ -908,47 +1035,27 @@ var LayerImpl6 = Effect8.gen(function* () {
     getAvailableFeatures: getAvailableFeatures2
   };
 });
-var ClaudeCodeService = class extends Context6.Tag("ClaudeCodeService")() {
+var ClaudeCodeService = class extends Context8.Tag("ClaudeCodeService")() {
   static {
-    this.Live = Layer7.effect(this, LayerImpl6);
+    this.Live = Layer10.effect(this, LayerImpl8);
   }
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeController.ts
-var LayerImpl7 = Effect9.gen(function* () {
+var LayerImpl9 = Effect12.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeService = yield* ClaudeCodeService;
   const context = yield* ApplicationContext;
-  const fs = yield* FileSystem4.FileSystem;
-  const path = yield* Path6.Path;
-  const getClaudeCommands = (options) => Effect9.gen(function* () {
+  yield* FileSystem6.FileSystem;
+  const path = yield* Path8.Path;
+  const getClaudeCommands = (options) => Effect12.gen(function* () {
     const { projectId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
-    const globalCommands = yield* fs.readDirectory(context.claudeCodePaths.claudeCommandsDirPath).pipe(
-      Effect9.map(
-        (items) => items.filter((item) => item.endsWith(".md")).map((item) => item.replace(/\.md$/, ""))
-      )
-    ).pipe(
-      Effect9.match({
-        onSuccess: (items) => items,
-        onFailure: () => {
-          return [];
-        }
-      })
+    const globalCommands = yield* scanCommandFilesRecursively(
+      context.claudeCodePaths.claudeCommandsDirPath
     );
-    const projectCommands = project.meta.projectPath === null ? [] : yield* fs.readDirectory(
+    const projectCommands = project.meta.projectPath === null ? [] : yield* scanCommandFilesRecursively(
       path.resolve(project.meta.projectPath, ".claude", "commands")
-    ).pipe(
-      Effect9.map(
-        (items) => items.filter((item) => item.endsWith(".md")).map((item) => item.replace(/\.md$/, ""))
-      )
-    ).pipe(
-      Effect9.match({
-        onSuccess: (items) => items,
-        onFailure: () => {
-          return [];
-        }
-      })
     );
     return {
       response: {
@@ -959,7 +1066,7 @@ var LayerImpl7 = Effect9.gen(function* () {
       status: 200
     };
   });
-  const getMcpListRoute = (options) => Effect9.gen(function* () {
+  const getMcpListRoute = (options) => Effect12.gen(function* () {
     const { projectId } = options;
     const servers = yield* claudeCodeService.getMcpList(projectId);
     return {
@@ -967,7 +1074,7 @@ var LayerImpl7 = Effect9.gen(function* () {
       status: 200
     };
   });
-  const getClaudeCodeMeta = () => Effect9.gen(function* () {
+  const getClaudeCodeMeta = () => Effect12.gen(function* () {
     const config = yield* claudeCodeService.getClaudeCodeMeta();
     return {
       response: {
@@ -977,7 +1084,7 @@ var LayerImpl7 = Effect9.gen(function* () {
       status: 200
     };
   });
-  const getAvailableFeatures2 = () => Effect9.gen(function* () {
+  const getAvailableFeatures2 = () => Effect12.gen(function* () {
     const features = yield* claudeCodeService.getAvailableFeatures();
     const featuresList = Object.entries(features).flatMap(([key, value]) => {
       return [
@@ -999,22 +1106,22 @@ var LayerImpl7 = Effect9.gen(function* () {
     getAvailableFeatures: getAvailableFeatures2
   };
 });
-var ClaudeCodeController = class extends Context7.Tag("ClaudeCodeController")() {
+var ClaudeCodeController = class extends Context9.Tag("ClaudeCodeController")() {
   static {
-    this.Live = Layer8.effect(this, LayerImpl7);
+    this.Live = Layer11.effect(this, LayerImpl9);
   }
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodePermissionController.ts
-import { Context as Context10, Effect as Effect12, Layer as Layer11 } from "effect";
+import { Context as Context12, Effect as Effect15, Layer as Layer14 } from "effect";
 
 // src/server/core/claude-code/services/ClaudeCodePermissionService.ts
-import { Context as Context9, Effect as Effect11, Layer as Layer10, Ref as Ref4 } from "effect";
+import { Context as Context11, Effect as Effect14, Layer as Layer13, Ref as Ref4 } from "effect";
 import { ulid } from "ulid";
 
 // src/server/core/events/services/EventBus.ts
-import { Context as Context8, Effect as Effect10, Layer as Layer9 } from "effect";
-var layerImpl = Effect10.gen(function* () {
+import { Context as Context10, Effect as Effect13, Layer as Layer12 } from "effect";
+var layerImpl = Effect13.gen(function* () {
   const listenersMap = /* @__PURE__ */ new Map();
   const getListeners = (event) => {
     if (!listenersMap.has(event)) {
@@ -1022,7 +1129,7 @@ var layerImpl = Effect10.gen(function* () {
     }
     return listenersMap.get(event);
   };
-  const emit = (event, data) => Effect10.gen(function* () {
+  const emit = (event, data) => Effect13.gen(function* () {
     const listeners = getListeners(event);
     void Promise.allSettled(
       Array.from(listeners).map(async (listener) => {
@@ -1030,11 +1137,11 @@ var layerImpl = Effect10.gen(function* () {
       })
     );
   });
-  const on = (event, listener) => Effect10.sync(() => {
+  const on = (event, listener) => Effect13.sync(() => {
     const listeners = getListeners(event);
     listeners.add(listener);
   });
-  const off = (event, listener) => Effect10.sync(() => {
+  const off = (event, listener) => Effect13.sync(() => {
     const listeners = getListeners(event);
     listeners.delete(listener);
   });
@@ -1044,18 +1151,18 @@ var layerImpl = Effect10.gen(function* () {
     off
   };
 });
-var EventBus = class extends Context8.Tag("EventBus")() {
+var EventBus = class extends Context10.Tag("EventBus")() {
   static {
-    this.Live = Layer9.effect(this, layerImpl);
+    this.Live = Layer12.effect(this, layerImpl);
   }
 };
 
 // src/server/core/claude-code/services/ClaudeCodePermissionService.ts
-var LayerImpl8 = Effect11.gen(function* () {
+var LayerImpl10 = Effect14.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) => Effect11.gen(function* () {
+  const waitPermissionResponse = (request, options) => Effect14.gen(function* () {
     yield* Ref4.update(pendingPermissionRequestsRef, (requests) => {
       requests.set(request.id, request);
       return requests;
@@ -1071,14 +1178,14 @@ var LayerImpl8 = Effect11.gen(function* () {
       if (response !== null) {
         break;
       }
-      yield* Effect11.sleep(1e3);
+      yield* Effect14.sleep(1e3);
       passedMs += 1e3;
     }
     return response;
   });
   const createCanUseToolRelatedOptions = (options) => {
     const { taskId, userConfig, sessionId } = options;
-    return Effect11.gen(function* () {
+    return Effect14.gen(function* () {
       const claudeCodeConfig = yield* Config;
       if (!getAvailableFeatures(claudeCodeConfig.claudeCodeVersion).canUseTool) {
         return {
@@ -1107,7 +1214,7 @@ var LayerImpl8 = Effect11.gen(function* () {
           toolInput,
           timestamp: Date.now()
         };
-        const response = await Effect11.runPromise(
+        const response = await Effect14.runPromise(
           waitPermissionResponse(permissionRequest, { timeoutMs: 6e4 })
         );
         if (response === null) {
@@ -1134,7 +1241,7 @@ var LayerImpl8 = Effect11.gen(function* () {
       };
     });
   };
-  const respondToPermissionRequest = (response) => Effect11.gen(function* () {
+  const respondToPermissionRequest = (response) => Effect14.gen(function* () {
     yield* Ref4.update(permissionResponsesRef, (responses) => {
       responses.set(response.permissionRequestId, response);
       return responses;
@@ -1149,20 +1256,20 @@ var LayerImpl8 = Effect11.gen(function* () {
     respondToPermissionRequest
   };
 });
-var ClaudeCodePermissionService = class extends Context9.Tag(
+var ClaudeCodePermissionService = class extends Context11.Tag(
   "ClaudeCodePermissionService"
 )() {
   static {
-    this.Live = Layer10.effect(this, LayerImpl8);
+    this.Live = Layer13.effect(this, LayerImpl10);
   }
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodePermissionController.ts
-var LayerImpl9 = Effect12.gen(function* () {
+var LayerImpl11 = Effect15.gen(function* () {
   const claudeCodePermissionService = yield* ClaudeCodePermissionService;
-  const permissionResponse = (options) => Effect12.sync(() => {
+  const permissionResponse = (options) => Effect15.sync(() => {
     const { permissionResponse: permissionResponse2 } = options;
-    Effect12.runFork(
+    Effect15.runFork(
       claudeCodePermissionService.respondToPermissionRequest(
         permissionResponse2
       )
@@ -1178,19 +1285,19 @@ var LayerImpl9 = Effect12.gen(function* () {
     permissionResponse
   };
 });
-var ClaudeCodePermissionController = class extends Context10.Tag(
+var ClaudeCodePermissionController = class extends Context12.Tag(
   "ClaudeCodePermissionController"
 )() {
   static {
-    this.Live = Layer11.effect(this, LayerImpl9);
+    this.Live = Layer14.effect(this, LayerImpl11);
   }
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeSessionProcessController.ts
-import { Context as Context17, Effect as Effect20, Layer as Layer18 } from "effect";
+import { Context as Context19, Effect as Effect23, Layer as Layer21 } from "effect";
 
 // src/server/core/platform/services/UserConfigService.ts
-import { Context as Context11, Effect as Effect13, Layer as Layer12, Ref as Ref5 } from "effect";
+import { Context as Context13, Effect as Effect16, Layer as Layer15, Ref as Ref5 } from "effect";
 
 // src/lib/i18n/localeDetection.ts
 var DEFAULT_LOCALE = "en";
@@ -1242,7 +1349,7 @@ var detectLocaleFromAcceptLanguage = (header) => {
 };
 
 // src/server/core/platform/services/UserConfigService.ts
-var LayerImpl10 = Effect13.gen(function* () {
+var LayerImpl12 = Effect16.gen(function* () {
   const configRef = yield* Ref5.make({
     hideNoUserMessageSession: true,
     unifySameTitleSession: false,
@@ -1251,10 +1358,10 @@ var LayerImpl10 = Effect13.gen(function* () {
     locale: DEFAULT_LOCALE,
     theme: "system"
   });
-  const setUserConfig = (newConfig) => Effect13.gen(function* () {
+  const setUserConfig = (newConfig) => Effect16.gen(function* () {
     yield* Ref5.update(configRef, () => newConfig);
   });
-  const getUserConfig = () => Effect13.gen(function* () {
+  const getUserConfig = () => Effect16.gen(function* () {
     const config = yield* Ref5.get(configRef);
     return config;
   });
@@ -1263,14 +1370,14 @@ var LayerImpl10 = Effect13.gen(function* () {
     setUserConfig
   };
 });
-var UserConfigService = class extends Context11.Tag("UserConfigService")() {
+var UserConfigService = class extends Context13.Tag("UserConfigService")() {
   static {
-    this.Live = Layer12.effect(this, LayerImpl10);
+    this.Live = Layer15.effect(this, LayerImpl12);
   }
 };
 
 // src/server/core/claude-code/services/ClaudeCodeLifeCycleService.ts
-import { Context as Context16, Effect as Effect19, Layer as Layer17, Runtime as Runtime2 } from "effect";
+import { Context as Context18, Effect as Effect22, Layer as Layer20, Runtime as Runtime2 } from "effect";
 import { ulid as ulid2 } from "ulid";
 
 // src/lib/controllablePromise.ts
@@ -1300,8 +1407,8 @@ var controllablePromise = () => {
 };
 
 // src/server/core/session/infrastructure/SessionRepository.ts
-import { FileSystem as FileSystem6, Path as Path7 } from "@effect/platform";
-import { Context as Context14, Effect as Effect16, Layer as Layer15, Option as Option3 } from "effect";
+import { FileSystem as FileSystem8, Path as Path9 } from "@effect/platform";
+import { Context as Context16, Effect as Effect19, Layer as Layer18, Option as Option3 } from "effect";
 
 // src/server/core/claude-code/functions/parseUserMessage.ts
 import { z as z21 } from "zod";
@@ -1377,29 +1484,32 @@ var decodeSessionId = (projectId, sessionId) => {
   return resolve2(projectPath, `${sessionId}.jsonl`);
 };
 
+// src/server/core/session/functions/isRegularSessionFile.ts
+var isRegularSessionFile = (filename) => filename.endsWith(".jsonl") && !filename.startsWith("agent-");
+
 // src/server/core/session/infrastructure/VirtualConversationDatabase.ts
-import { Context as Context12, Effect as Effect14, Layer as Layer13, Ref as Ref6 } from "effect";
-var VirtualConversationDatabase = class extends Context12.Tag(
+import { Context as Context14, Effect as Effect17, Layer as Layer16, Ref as Ref6 } from "effect";
+var VirtualConversationDatabase = class extends Context14.Tag(
   "VirtualConversationDatabase"
 )() {
   static {
-    this.Live = Layer13.effect(
+    this.Live = Layer16.effect(
       this,
-      Effect14.gen(function* () {
+      Effect17.gen(function* () {
         const storageRef = yield* Ref6.make([]);
-        const getProjectVirtualConversations = (projectId) => Effect14.gen(function* () {
+        const getProjectVirtualConversations = (projectId) => Effect17.gen(function* () {
           const conversations = yield* Ref6.get(storageRef);
           return conversations.filter(
             (conversation) => conversation.projectId === projectId
           );
         });
-        const getSessionVirtualConversation = (sessionId) => Effect14.gen(function* () {
+        const getSessionVirtualConversation = (sessionId) => Effect17.gen(function* () {
           const conversations = yield* Ref6.get(storageRef);
           return conversations.find(
             (conversation) => conversation.sessionId === sessionId
           ) ?? null;
         });
-        const createVirtualConversation2 = (projectId, sessionId, createConversations) => Effect14.gen(function* () {
+        const createVirtualConversation2 = (projectId, sessionId, createConversations) => Effect17.gen(function* () {
           yield* Ref6.update(storageRef, (conversations) => {
             const existingRecord = conversations.find(
               (record) => record.projectId === projectId && record.sessionId === sessionId
@@ -1418,7 +1528,7 @@ var VirtualConversationDatabase = class extends Context12.Tag(
             return conversations;
           });
         });
-        const deleteVirtualConversations = (sessionId) => Effect14.gen(function* () {
+        const deleteVirtualConversations = (sessionId) => Effect17.gen(function* () {
           yield* Ref6.update(storageRef, (conversations) => {
             return conversations.filter((c) => c.sessionId !== sessionId);
           });
@@ -1435,8 +1545,8 @@ var VirtualConversationDatabase = class extends Context12.Tag(
 };
 
 // src/server/core/session/services/SessionMetaService.ts
-import { FileSystem as FileSystem5 } from "@effect/platform";
-import { Context as Context13, Effect as Effect15, Layer as Layer14, Ref as Ref7 } from "effect";
+import { FileSystem as FileSystem7 } from "@effect/platform";
+import { Context as Context15, Effect as Effect18, Layer as Layer17, Ref as Ref7 } from "effect";
 
 // src/server/core/session/constants/pricing.ts
 var MODEL_PRICING = {
@@ -1582,17 +1692,17 @@ var extractFirstUserMessage = (conversation) => {
 
 // src/server/core/session/services/SessionMetaService.ts
 var parsedUserMessageOrNullSchema = parsedUserMessageSchema.nullable();
-var SessionMetaService = class extends Context13.Tag("SessionMetaService")() {
+var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
   static {
-    this.Live = Layer14.effect(
+    this.Live = Layer17.effect(
       this,
-      Effect15.gen(function* () {
-        const fs = yield* FileSystem5.FileSystem;
+      Effect18.gen(function* () {
+        const fs = yield* FileSystem7.FileSystem;
         const firstUserMessageCache = yield* FileCacheStorage();
         const sessionMetaCacheRef = yield* Ref7.make(
           /* @__PURE__ */ new Map()
         );
-        const getFirstUserMessage = (jsonlFilePath, lines) => Effect15.gen(function* () {
+        const getFirstUserMessage = (jsonlFilePath, lines) => Effect18.gen(function* () {
           const cached = yield* firstUserMessageCache.get(jsonlFilePath);
           if (cached !== void 0) {
             return cached;
@@ -1677,7 +1787,7 @@ var SessionMetaService = class extends Context13.Tag("SessionMetaService")() {
             modelName: lastModelName
           };
         };
-        const getSessionMeta = (projectId, sessionId) => Effect15.gen(function* () {
+        const getSessionMeta = (projectId, sessionId) => Effect18.gen(function* () {
           const metaCache = yield* Ref7.get(sessionMetaCacheRef);
           const cached = metaCache.get(sessionId);
           if (cached !== void 0) {
@@ -1706,7 +1816,7 @@ var SessionMetaService = class extends Context13.Tag("SessionMetaService")() {
           });
           return sessionMeta;
         });
-        const invalidateSession = (_projectId, sessionId) => Effect15.gen(function* () {
+        const invalidateSession = (_projectId, sessionId) => Effect18.gen(function* () {
           yield* Ref7.update(sessionMetaCacheRef, (cache) => {
             cache.delete(sessionId);
             return cache;
@@ -1718,30 +1828,30 @@ var SessionMetaService = class extends Context13.Tag("SessionMetaService")() {
         };
       })
     ).pipe(
-      Layer14.provide(
+      Layer17.provide(
         makeFileCacheStorageLayer(
           "first-user-message-cache",
           parsedUserMessageOrNullSchema
         )
       ),
-      Layer14.provide(PersistentService.Live)
+      Layer17.provide(PersistentService.Live)
     );
   }
 };
 
 // src/server/core/session/infrastructure/SessionRepository.ts
-var LayerImpl11 = Effect16.gen(function* () {
-  const fs = yield* FileSystem6.FileSystem;
-  const path = yield* Path7.Path;
+var LayerImpl13 = Effect19.gen(function* () {
+  const fs = yield* FileSystem8.FileSystem;
+  const path = yield* Path9.Path;
   const sessionMetaService = yield* SessionMetaService;
   const virtualConversationDatabase = yield* VirtualConversationDatabase;
-  const getSession = (projectId, sessionId) => Effect16.gen(function* () {
+  const getSession = (projectId, sessionId) => Effect19.gen(function* () {
     const sessionPath = decodeSessionId(projectId, sessionId);
     const virtualConversation = yield* virtualConversationDatabase.getSessionVirtualConversation(
       sessionId
     );
     const exists = yield* fs.exists(sessionPath);
-    const sessionDetail = yield* exists ? Effect16.gen(function* () {
+    const sessionDetail = yield* exists ? Effect19.gen(function* () {
       const content = yield* fs.readFileString(sessionPath);
       const allLines = content.split("\n").filter((line) => line.trim());
       const conversations = parseJsonl(allLines.join("\n"));
@@ -1779,7 +1889,7 @@ var LayerImpl11 = Effect16.gen(function* () {
       return sessionDetail2;
     }) : (() => {
       if (virtualConversation === null) {
-        return Effect16.succeed(null);
+        return Effect19.succeed(null);
       }
       const lastConversation = virtualConversation.conversations.filter(
         (conversation) => conversation.type === "user" || conversation.type === "assistant" || conversation.type === "system"
@@ -1809,13 +1919,13 @@ var LayerImpl11 = Effect16.gen(function* () {
         conversations: virtualConversation.conversations,
         lastModifiedAt: lastConversation !== void 0 ? new Date(lastConversation.timestamp) : /* @__PURE__ */ new Date()
       };
-      return Effect16.succeed(virtualSession);
+      return Effect19.succeed(virtualSession);
     })();
     return {
       session: sessionDetail
     };
   });
-  const getSessions = (projectId, options) => Effect16.gen(function* () {
+  const getSessions = (projectId, options) => Effect19.gen(function* () {
     const { maxCount = 20, cursor } = options ?? {};
     const claudeProjectPath = decodeProjectId(projectId);
     const dirExists = yield* fs.exists(claudeProjectPath);
@@ -1823,8 +1933,8 @@ var LayerImpl11 = Effect16.gen(function* () {
       console.warn(`Project directory not found at ${claudeProjectPath}`);
       return { sessions: [] };
     }
-    const dirents = yield* Effect16.tryPromise({
-      try: () => fs.readDirectory(claudeProjectPath).pipe(Effect16.runPromise),
+    const dirents = yield* Effect19.tryPromise({
+      try: () => fs.readDirectory(claudeProjectPath).pipe(Effect19.runPromise),
       catch: (error) => {
         console.warn(
           `Failed to read sessions for project ${projectId}:`,
@@ -1832,14 +1942,14 @@ var LayerImpl11 = Effect16.gen(function* () {
         );
         return new Error("Failed to read directory");
       }
-    }).pipe(Effect16.catchAll(() => Effect16.succeed([])));
-    const sessionEffects = dirents.filter((entry) => entry.endsWith(".jsonl")).map(
-      (entry) => Effect16.gen(function* () {
+    }).pipe(Effect19.catchAll(() => Effect19.succeed([])));
+    const sessionEffects = dirents.filter(isRegularSessionFile).map(
+      (entry) => Effect19.gen(function* () {
         const fullPath = path.resolve(claudeProjectPath, entry);
         const sessionId = encodeSessionId(fullPath);
-        const stat = yield* Effect16.tryPromise(
-          () => fs.stat(fullPath).pipe(Effect16.runPromise)
-        ).pipe(Effect16.catchAll(() => Effect16.succeed(null)));
+        const stat = yield* Effect19.tryPromise(
+          () => fs.stat(fullPath).pipe(Effect19.runPromise)
+        ).pipe(Effect19.catchAll(() => Effect19.succeed(null)));
         if (!stat) {
           return null;
         }
@@ -1850,7 +1960,7 @@ var LayerImpl11 = Effect16.gen(function* () {
         };
       })
     );
-    const sessionsWithNulls = yield* Effect16.all(sessionEffects, {
+    const sessionsWithNulls = yield* Effect19.all(sessionEffects, {
       concurrency: "unbounded"
     });
     const sessions = sessionsWithNulls.filter((s) => s !== null).sort(
@@ -1865,9 +1975,9 @@ var LayerImpl11 = Effect16.gen(function* () {
         index + 1,
         Math.min(index + 1 + maxCount, sessions.length)
       );
-      const sessionsWithMeta2 = yield* Effect16.all(
+      const sessionsWithMeta2 = yield* Effect19.all(
         sessionsToReturn2.map(
-          (item) => Effect16.gen(function* () {
+          (item) => Effect19.gen(function* () {
             const meta = yield* sessionMetaService.getSessionMeta(
               projectId,
               item.id
@@ -1930,9 +2040,9 @@ var LayerImpl11 = Effect16.gen(function* () {
       0,
       Math.min(maxCount, sessions.length)
     );
-    const sessionsWithMeta = yield* Effect16.all(
+    const sessionsWithMeta = yield* Effect19.all(
       sessionsToReturn.map(
-        (item) => Effect16.gen(function* () {
+        (item) => Effect19.gen(function* () {
           const meta = yield* sessionMetaService.getSessionMeta(
             projectId,
             item.id
@@ -1954,9 +2064,9 @@ var LayerImpl11 = Effect16.gen(function* () {
     getSessions
   };
 });
-var SessionRepository = class extends Context14.Tag("SessionRepository")() {
+var SessionRepository = class extends Context16.Tag("SessionRepository")() {
   static {
-    this.Live = Layer15.effect(this, LayerImpl11);
+    this.Live = Layer18.effect(this, LayerImpl13);
   }
 };
 
@@ -2056,7 +2166,7 @@ var fallbackSdkMessage = (message) => {
 };
 
 // src/server/core/claude-code/models/CCSessionProcess.ts
-import { Effect as Effect17 } from "effect";
+import { Effect as Effect20 } from "effect";
 var isPublic = (process2) => {
   return process2.type === "initialized" || process2.type === "file_created" || process2.type === "paused";
 };
@@ -2067,7 +2177,7 @@ var getAliveTasks = (process2) => {
 };
 var createVirtualConversation = (process2, ctx) => {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return Effect17.gen(function* () {
+  return Effect20.gen(function* () {
     const config = yield* Config;
     const virtualConversation = {
       type: "user",
@@ -2089,7 +2199,7 @@ var createVirtualConversation = (process2, ctx) => {
 };
 
 // src/server/core/claude-code/services/ClaudeCodeSessionProcessService.ts
-import { Context as Context15, Data as Data3, Effect as Effect18, Layer as Layer16, Ref as Ref8 } from "effect";
+import { Context as Context17, Data as Data3, Effect as Effect21, Layer as Layer19, Ref as Ref8 } from "effect";
 var SessionProcessNotFoundError = class extends Data3.TaggedError(
   "SessionProcessNotFoundError"
 ) {
@@ -2108,12 +2218,12 @@ var IllegalStateChangeError = class extends Data3.TaggedError(
 };
 var TaskNotFoundError = class extends Data3.TaggedError("TaskNotFoundError") {
 };
-var LayerImpl12 = Effect18.gen(function* () {
+var LayerImpl14 = Effect21.gen(function* () {
   const processesRef = yield* Ref8.make([]);
   const eventBus = yield* EventBus;
   const startSessionProcess = (options) => {
     const { sessionDef, taskDef } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const task = {
         def: taskDef,
         status: "pending"
@@ -2136,10 +2246,10 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const continueSessionProcess = (options) => {
     const { sessionProcessId } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const process2 = yield* getSessionProcess(sessionProcessId);
       if (process2.type !== "paused") {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new SessionProcessNotPausedError({
             sessionProcessId
           })
@@ -2147,7 +2257,7 @@ var LayerImpl12 = Effect18.gen(function* () {
       }
       const [firstAliveTask] = getAliveTasks(process2);
       if (firstAliveTask !== void 0) {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new SessionProcessAlreadyAliveError({
             sessionProcessId,
             aliveTaskId: firstAliveTask.def.taskId,
@@ -2177,13 +2287,13 @@ var LayerImpl12 = Effect18.gen(function* () {
     });
   };
   const getSessionProcess = (sessionProcessId) => {
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const result = processes.find(
         (p) => p.def.sessionProcessId === sessionProcessId
       );
       if (result === void 0) {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new SessionProcessNotFoundError({ sessionProcessId })
         );
       }
@@ -2191,13 +2301,13 @@ var LayerImpl12 = Effect18.gen(function* () {
     });
   };
   const getSessionProcesses = () => {
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       return processes;
     });
   };
   const getTask = (taskId) => {
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const result = processes.flatMap((p) => {
         const found = p.tasks.find((t) => t.def.taskId === taskId);
@@ -2212,14 +2322,14 @@ var LayerImpl12 = Effect18.gen(function* () {
         ];
       }).at(0);
       if (result === void 0) {
-        return yield* Effect18.fail(new TaskNotFoundError({ taskId }));
+        return yield* Effect21.fail(new TaskNotFoundError({ taskId }));
       }
       return result;
     });
   };
   const dangerouslyChangeProcessState = (options) => {
     const { sessionProcessId, nextState } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const processes = yield* Ref8.get(processesRef);
       const targetProcess = processes.find(
         (p) => p.def.sessionProcessId === sessionProcessId
@@ -2248,7 +2358,7 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const changeTaskState = (options) => {
     const { sessionProcessId, taskId, nextTask } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const { task } = yield* getTask(taskId);
       yield* Ref8.update(processesRef, (processes) => {
         return processes.map(
@@ -2269,10 +2379,10 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const toNotInitializedState = (options) => {
     const { sessionProcessId, rawUserMessage } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "pending") {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "not_initialized"
@@ -2305,10 +2415,10 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const toInitializedState = (options) => {
     const { sessionProcessId, initContext } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "not_initialized") {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "initialized"
@@ -2334,10 +2444,10 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const toFileCreatedState = (options) => {
     const { sessionProcessId } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "initialized") {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "file_created"
@@ -2363,10 +2473,10 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const toPausedState = (options) => {
     const { sessionProcessId, resultMessage } = options;
-    return Effect18.gen(function* () {
+    return Effect21.gen(function* () {
       const currentProcess = yield* getSessionProcess(sessionProcessId);
       if (currentProcess.type !== "file_created") {
-        return yield* Effect18.fail(
+        return yield* Effect21.fail(
           new IllegalStateChangeError({
             from: currentProcess.type,
             to: "paused"
@@ -2400,7 +2510,7 @@ var LayerImpl12 = Effect18.gen(function* () {
   };
   const toCompletedState = (options) => {
     const { sessionProcessId, error } = options;
-    return Effect18.gen(function* () {
+    return Effect21.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 ? {
@@ -2453,25 +2563,25 @@ var LayerImpl12 = Effect18.gen(function* () {
     changeTaskState
   };
 });
-var ClaudeCodeSessionProcessService = class extends Context15.Tag(
+var ClaudeCodeSessionProcessService = class extends Context17.Tag(
   "ClaudeCodeSessionProcessService"
 )() {
   static {
-    this.Live = Layer16.effect(this, LayerImpl12);
+    this.Live = Layer19.effect(this, LayerImpl14);
   }
 };
 
 // src/server/core/claude-code/services/ClaudeCodeLifeCycleService.ts
-var LayerImpl13 = Effect19.gen(function* () {
+var LayerImpl15 = Effect22.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* Effect19.runtime();
+  const runtime = yield* Effect22.runtime();
   const continueTask = (options) => {
     const { sessionProcessId, baseSessionId, input } = options;
-    return Effect19.gen(function* () {
+    return Effect22.gen(function* () {
       const { sessionProcess, task } = yield* sessionProcessService.continueSessionProcess({
         sessionProcessId,
         taskDef: {
@@ -2499,7 +2609,7 @@ var LayerImpl13 = Effect19.gen(function* () {
   };
   const startTask = (options) => {
     const { baseSession, input, userConfig } = options;
-    return Effect19.gen(function* () {
+    return Effect22.gen(function* () {
       const {
         generateMessages,
         setNextMessage,
@@ -2527,7 +2637,7 @@ var LayerImpl13 = Effect19.gen(function* () {
       const sessionFileCreatedPromise = controllablePromise();
       setMessageGeneratorHooks({
         onNewUserMessageResolved: async (input2) => {
-          Effect19.runFork(
+          Effect22.runFork(
             sessionProcessService.toNotInitializedState({
               sessionProcessId: sessionProcess.def.sessionProcessId,
               rawUserMessage: input2.text
@@ -2535,7 +2645,7 @@ var LayerImpl13 = Effect19.gen(function* () {
           );
         }
       });
-      const handleMessage = (message) => Effect19.gen(function* () {
+      const handleMessage = (message) => Effect22.gen(function* () {
         const processState = yield* sessionProcessService.getSessionProcess(
           sessionProcess.def.sessionProcessId
         );
@@ -2543,7 +2653,7 @@ var LayerImpl13 = Effect19.gen(function* () {
           return "break";
         }
         if (processState.type === "paused") {
-          yield* Effect19.die(
+          yield* Effect22.die(
             new Error("Illegal state: paused is not expected")
           );
         }
@@ -2615,7 +2725,7 @@ var LayerImpl13 = Effect19.gen(function* () {
       });
       const handleSessionProcessDaemon = async () => {
         const messageIter = await Runtime2.runPromise(runtime)(
-          Effect19.gen(function* () {
+          Effect22.gen(function* () {
             const permissionOptions = yield* permissionService.createCanUseToolRelatedOptions({
               taskId: task.def.taskId,
               userConfig,
@@ -2636,7 +2746,7 @@ var LayerImpl13 = Effect19.gen(function* () {
             const result = await Runtime2.runPromise(runtime)(
               handleMessage(fallbackMessage)
             ).catch((error) => {
-              Effect19.runFork(
+              Effect22.runFork(
                 sessionProcessService.changeTaskState({
                   sessionProcessId: sessionProcess.def.sessionProcessId,
                   taskId: task.def.taskId,
@@ -2667,7 +2777,7 @@ var LayerImpl13 = Effect19.gen(function* () {
           if (sessionFileCreatedPromise.status === "pending") {
             sessionFileCreatedPromise.reject(error);
           }
-          await Effect19.runPromise(
+          await Effect22.runPromise(
             sessionProcessService.changeTaskState({
               sessionProcessId: sessionProcess.def.sessionProcessId,
               taskId: task.def.taskId,
@@ -2690,8 +2800,8 @@ var LayerImpl13 = Effect19.gen(function* () {
         }
         throw error;
       }).finally(() => {
-        Effect19.runFork(
-          Effect19.gen(function* () {
+        Effect22.runFork(
+          Effect22.gen(function* () {
             const currentProcess = yield* sessionProcessService.getSessionProcess(
               sessionProcess.def.sessionProcessId
             );
@@ -2707,16 +2817,16 @@ var LayerImpl13 = Effect19.gen(function* () {
         daemonPromise,
         awaitSessionInitialized: async () => await sessionInitializedPromise.promise,
         awaitSessionFileCreated: async () => await sessionFileCreatedPromise.promise,
-        yieldSessionInitialized: () => Effect19.promise(() => sessionInitializedPromise.promise),
-        yieldSessionFileCreated: () => Effect19.promise(() => sessionFileCreatedPromise.promise)
+        yieldSessionInitialized: () => Effect22.promise(() => sessionInitializedPromise.promise),
+        yieldSessionFileCreated: () => Effect22.promise(() => sessionFileCreatedPromise.promise)
       };
     });
   };
-  const getPublicSessionProcesses = () => Effect19.gen(function* () {
+  const getPublicSessionProcesses = () => Effect22.gen(function* () {
     const processes = yield* sessionProcessService.getSessionProcesses();
     return processes.filter((process2) => isPublic(process2));
   });
-  const abortTask = (sessionProcessId) => Effect19.gen(function* () {
+  const abortTask = (sessionProcessId) => Effect22.gen(function* () {
     const currentProcess = yield* sessionProcessService.getSessionProcess(sessionProcessId);
     currentProcess.def.abortController.abort();
     yield* sessionProcessService.toCompletedState({
@@ -2724,7 +2834,7 @@ var LayerImpl13 = Effect19.gen(function* () {
       error: new Error("Task aborted")
     });
   });
-  const abortAllTasks = () => Effect19.gen(function* () {
+  const abortAllTasks = () => Effect22.gen(function* () {
     const processes = yield* sessionProcessService.getSessionProcesses();
     for (const process2 of processes) {
       yield* sessionProcessService.toCompletedState({
@@ -2741,20 +2851,20 @@ var LayerImpl13 = Effect19.gen(function* () {
     getPublicSessionProcesses
   };
 });
-var ClaudeCodeLifeCycleService = class extends Context16.Tag(
+var ClaudeCodeLifeCycleService = class extends Context18.Tag(
   "ClaudeCodeLifeCycleService"
 )() {
   static {
-    this.Live = Layer17.effect(this, LayerImpl13);
+    this.Live = Layer20.effect(this, LayerImpl15);
   }
 };
 
 // src/server/core/claude-code/presentation/ClaudeCodeSessionProcessController.ts
-var LayerImpl14 = Effect20.gen(function* () {
+var LayerImpl16 = Effect23.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const userConfigService = yield* UserConfigService;
-  const getSessionProcesses = () => Effect20.gen(function* () {
+  const getSessionProcesses = () => Effect23.gen(function* () {
     const publicSessionProcesses = yield* claudeCodeLifeCycleService.getPublicSessionProcesses();
     return {
       response: {
@@ -2770,7 +2880,7 @@ var LayerImpl14 = Effect20.gen(function* () {
       status: 200
     };
   });
-  const createSessionProcess = (options) => Effect20.gen(function* () {
+  const createSessionProcess = (options) => Effect23.gen(function* () {
     const { projectId, input, baseSessionId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     const userConfig = yield* userConfigService.getUserConfig();
@@ -2801,7 +2911,7 @@ var LayerImpl14 = Effect20.gen(function* () {
       }
     };
   });
-  const continueSessionProcess = (options) => Effect20.gen(function* () {
+  const continueSessionProcess = (options) => Effect23.gen(function* () {
     const { projectId, input, baseSessionId, sessionProcessId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -2832,16 +2942,16 @@ var LayerImpl14 = Effect20.gen(function* () {
     continueSessionProcess
   };
 });
-var ClaudeCodeSessionProcessController = class extends Context17.Tag(
+var ClaudeCodeSessionProcessController = class extends Context19.Tag(
   "ClaudeCodeSessionProcessController"
 )() {
   static {
-    this.Live = Layer18.effect(this, LayerImpl14);
+    this.Live = Layer21.effect(this, LayerImpl16);
   }
 };
 
 // src/server/core/events/presentation/SSEController.ts
-import { Context as Context19, Effect as Effect22, Layer as Layer20 } from "effect";
+import { Context as Context21, Effect as Effect25, Layer as Layer23 } from "effect";
 
 // src/server/core/events/functions/adaptInternalEventToSSE.ts
 var adaptInternalEventToSSE = (rawStream, options) => {
@@ -2868,12 +2978,12 @@ var adaptInternalEventToSSE = (rawStream, options) => {
 };
 
 // src/server/core/events/functions/typeSafeSSE.ts
-import { Context as Context18, Effect as Effect21, Layer as Layer19 } from "effect";
+import { Context as Context20, Effect as Effect24, Layer as Layer22 } from "effect";
 import { ulid as ulid3 } from "ulid";
-var TypeSafeSSE = class extends Context18.Tag("TypeSafeSSE")() {
+var TypeSafeSSE = class extends Context20.Tag("TypeSafeSSE")() {
   static {
-    this.make = (stream) => Layer19.succeed(this, {
-      writeSSE: (event, data) => Effect21.tryPromise({
+    this.make = (stream) => Layer22.succeed(this, {
+      writeSSE: (event, data) => Effect24.tryPromise({
         try: async () => {
           const id = ulid3();
           await stream.writeSSE({
@@ -2898,44 +3008,52 @@ var TypeSafeSSE = class extends Context18.Tag("TypeSafeSSE")() {
 };
 
 // src/server/core/events/presentation/SSEController.ts
-var LayerImpl15 = Effect22.gen(function* () {
+var LayerImpl17 = Effect25.gen(function* () {
   const eventBus = yield* EventBus;
-  const handleSSE = (rawStream) => Effect22.gen(function* () {
+  const handleSSE = (rawStream) => Effect25.gen(function* () {
     const typeSafeSSE = yield* TypeSafeSSE;
     yield* typeSafeSSE.writeSSE("connect", {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
     const onHeartbeat = () => {
-      Effect22.runFork(
+      Effect25.runFork(
         typeSafeSSE.writeSSE("heartbeat", {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
     };
     const onSessionListChanged = (event) => {
-      Effect22.runFork(
+      Effect25.runFork(
         typeSafeSSE.writeSSE("sessionListChanged", {
           projectId: event.projectId
         })
       );
     };
     const onSessionChanged = (event) => {
-      Effect22.runFork(
+      Effect25.runFork(
         typeSafeSSE.writeSSE("sessionChanged", {
           projectId: event.projectId,
           sessionId: event.sessionId
         })
       );
     };
+    const onAgentSessionChanged = (event) => {
+      Effect25.runFork(
+        typeSafeSSE.writeSSE("agentSessionChanged", {
+          projectId: event.projectId,
+          agentSessionId: event.agentSessionId
+        })
+      );
+    };
     const onSessionProcessChanged = (event) => {
-      Effect22.runFork(
+      Effect25.runFork(
         typeSafeSSE.writeSSE("sessionProcessChanged", {
           processes: event.processes
         })
       );
     };
     const onPermissionRequested = (event) => {
-      Effect22.runFork(
+      Effect25.runFork(
         typeSafeSSE.writeSSE("permissionRequested", {
           permissionRequest: event.permissionRequest
         })
@@ -2943,16 +3061,18 @@ var LayerImpl15 = Effect22.gen(function* () {
     };
     yield* eventBus.on("sessionListChanged", onSessionListChanged);
     yield* eventBus.on("sessionChanged", onSessionChanged);
+    yield* eventBus.on("agentSessionChanged", onAgentSessionChanged);
     yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
     yield* eventBus.on("heartbeat", onHeartbeat);
     yield* eventBus.on("permissionRequested", onPermissionRequested);
     const { connectionPromise } = adaptInternalEventToSSE(rawStream, {
       timeout: 5 * 60 * 1e3,
       cleanUp: async () => {
-        await Effect22.runPromise(
-          Effect22.gen(function* () {
+        await Effect25.runPromise(
+          Effect25.gen(function* () {
             yield* eventBus.off("sessionListChanged", onSessionListChanged);
             yield* eventBus.off("sessionChanged", onSessionChanged);
+            yield* eventBus.off("agentSessionChanged", onAgentSessionChanged);
             yield* eventBus.off(
               "sessionProcessChanged",
               onSessionProcessChanged
@@ -2963,34 +3083,64 @@ var LayerImpl15 = Effect22.gen(function* () {
         );
       }
     });
-    yield* Effect22.promise(() => connectionPromise);
+    yield* Effect25.promise(() => connectionPromise);
   });
   return {
     handleSSE
   };
 });
-var SSEController = class extends Context19.Tag("SSEController")() {
+var SSEController = class extends Context21.Tag("SSEController")() {
   static {
-    this.Live = Layer20.effect(this, LayerImpl15);
+    this.Live = Layer23.effect(this, LayerImpl17);
   }
 };
 
 // src/server/core/events/services/fileWatcher.ts
 import { watch } from "node:fs";
-import { Path as Path8 } from "@effect/platform";
-import { Context as Context20, Effect as Effect23, Layer as Layer21, Ref as Ref9 } from "effect";
+import { Path as Path10 } from "@effect/platform";
+import { Context as Context22, Effect as Effect26, Layer as Layer24, Ref as Ref9 } from "effect";
+
+// src/server/core/events/functions/parseSessionFilePath.ts
 import z22 from "zod";
-var fileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl/;
-var fileRegExpGroupSchema = z22.object({
+var sessionFileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl$/;
+var agentFileRegExp = /(?<projectId>.*?)\/agent-(?<agentSessionId>.*?)\.jsonl$/;
+var sessionFileGroupSchema = z22.object({
   projectId: z22.string(),
   sessionId: z22.string()
 });
-var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
+var agentFileGroupSchema = z22.object({
+  projectId: z22.string(),
+  agentSessionId: z22.string()
+});
+var parseSessionFilePath = (filePath) => {
+  const agentMatch = filePath.match(agentFileRegExp);
+  const agentGroups = agentFileGroupSchema.safeParse(agentMatch?.groups);
+  if (agentGroups.success) {
+    return {
+      type: "agent",
+      projectId: agentGroups.data.projectId,
+      agentSessionId: agentGroups.data.agentSessionId
+    };
+  }
+  const sessionMatch = filePath.match(sessionFileRegExp);
+  const sessionGroups = sessionFileGroupSchema.safeParse(sessionMatch?.groups);
+  if (sessionGroups.success) {
+    return {
+      type: "session",
+      projectId: sessionGroups.data.projectId,
+      sessionId: sessionGroups.data.sessionId
+    };
+  }
+  return null;
+};
+
+// src/server/core/events/services/fileWatcher.ts
+var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
   static {
-    this.Live = Layer21.effect(
+    this.Live = Layer24.effect(
       this,
-      Effect23.gen(function* () {
-        const path = yield* Path8.Path;
+      Effect26.gen(function* () {
+        const path = yield* Path10.Path;
         const eventBus = yield* EventBus;
         const context = yield* ApplicationContext;
         const isWatchingRef = yield* Ref9.make(false);
@@ -2999,11 +3149,11 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
           /* @__PURE__ */ new Map()
         );
         const debounceTimersRef = yield* Ref9.make(/* @__PURE__ */ new Map());
-        const startWatching = () => Effect23.gen(function* () {
+        const startWatching = () => Effect26.gen(function* () {
           const isWatching = yield* Ref9.get(isWatchingRef);
           if (isWatching) return;
           yield* Ref9.set(isWatchingRef, true);
-          yield* Effect23.tryPromise({
+          yield* Effect26.tryPromise({
             try: async () => {
               console.log(
                 "Starting file watcher on:",
@@ -3014,38 +3164,44 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
                 { persistent: false, recursive: true },
                 (_eventType, filename) => {
                   if (!filename) return;
-                  const groups = fileRegExpGroupSchema.safeParse(
-                    filename.match(fileRegExp)?.groups
-                  );
-                  if (!groups.success) return;
-                  const { sessionId } = groups.data;
+                  const fileMatch = parseSessionFilePath(filename);
+                  if (fileMatch === null) return;
                   const fullPath = path.join(
                     context.claudeCodePaths.claudeProjectsDirPath,
                     filename
                   );
                   const encodedProjectId = encodeProjectIdFromSessionFilePath(fullPath);
-                  const debounceKey = `${encodedProjectId}/${sessionId}`;
-                  Effect23.runPromise(
-                    Effect23.gen(function* () {
+                  const debounceKey = fileMatch.type === "agent" ? `${encodedProjectId}/agent-${fileMatch.agentSessionId}` : `${encodedProjectId}/${fileMatch.sessionId}`;
+                  Effect26.runPromise(
+                    Effect26.gen(function* () {
                       const timers = yield* Ref9.get(debounceTimersRef);
                       const existingTimer = timers.get(debounceKey);
                       if (existingTimer) {
                         clearTimeout(existingTimer);
                       }
                       const newTimer = setTimeout(() => {
-                        Effect23.runFork(
-                          eventBus.emit("sessionChanged", {
-                            projectId: encodedProjectId,
-                            sessionId
-                          })
-                        );
-                        Effect23.runFork(
-                          eventBus.emit("sessionListChanged", {
-                            projectId: encodedProjectId
-                          })
-                        );
-                        Effect23.runPromise(
-                          Effect23.gen(function* () {
+                        if (fileMatch.type === "agent") {
+                          Effect26.runFork(
+                            eventBus.emit("agentSessionChanged", {
+                              projectId: encodedProjectId,
+                              agentSessionId: fileMatch.agentSessionId
+                            })
+                          );
+                        } else {
+                          Effect26.runFork(
+                            eventBus.emit("sessionChanged", {
+                              projectId: encodedProjectId,
+                              sessionId: fileMatch.sessionId
+                            })
+                          );
+                          Effect26.runFork(
+                            eventBus.emit("sessionListChanged", {
+                              projectId: encodedProjectId
+                            })
+                          );
+                        }
+                        Effect26.runPromise(
+                          Effect26.gen(function* () {
                             const currentTimers = yield* Ref9.get(debounceTimersRef);
                             currentTimers.delete(debounceKey);
                             yield* Ref9.set(debounceTimersRef, currentTimers);
@@ -3058,7 +3214,7 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
                   );
                 }
               );
-              await Effect23.runPromise(Ref9.set(watcherRef, watcher));
+              await Effect26.runPromise(Ref9.set(watcherRef, watcher));
               console.log("File watcher initialization completed");
             },
             catch: (error) => {
@@ -3069,10 +3225,10 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
             }
           }).pipe(
             // エラーが発生しても続行する
-            Effect23.catchAll(() => Effect23.void)
+            Effect26.catchAll(() => Effect26.void)
           );
         });
-        const stop = () => Effect23.gen(function* () {
+        const stop = () => Effect26.gen(function* () {
           const timers = yield* Ref9.get(debounceTimersRef);
           for (const [, timer] of timers) {
             clearTimeout(timer);
@@ -3080,12 +3236,12 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
           yield* Ref9.set(debounceTimersRef, /* @__PURE__ */ new Map());
           const watcher = yield* Ref9.get(watcherRef);
           if (watcher) {
-            yield* Effect23.sync(() => watcher.close());
+            yield* Effect26.sync(() => watcher.close());
             yield* Ref9.set(watcherRef, null);
           }
           const projectWatchers = yield* Ref9.get(projectWatchersRef);
           for (const [, projectWatcher] of projectWatchers) {
-            yield* Effect23.sync(() => projectWatcher.close());
+            yield* Effect26.sync(() => projectWatcher.close());
           }
           yield* Ref9.set(projectWatchersRef, /* @__PURE__ */ new Map());
           yield* Ref9.set(isWatchingRef, false);
@@ -3100,10 +3256,10 @@ var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
 };
 
 // src/server/core/feature-flag/presentation/FeatureFlagController.ts
-import { Context as Context21, Effect as Effect24, Layer as Layer22 } from "effect";
-var LayerImpl16 = Effect24.gen(function* () {
+import { Context as Context23, Effect as Effect27, Layer as Layer25 } from "effect";
+var LayerImpl18 = Effect27.gen(function* () {
   const claudeCodeService = yield* ClaudeCodeService;
-  const getFlags = () => Effect24.gen(function* () {
+  const getFlags = () => Effect27.gen(function* () {
     const claudeCodeFeatures = yield* claudeCodeService.getAvailableFeatures();
     return {
       response: {
@@ -3115,6 +3271,10 @@ var LayerImpl16 = Effect24.gen(function* () {
           {
             name: "agent-sdk",
             enabled: claudeCodeFeatures.agentSdk
+          },
+          {
+            name: "sidechain-separation",
+            enabled: claudeCodeFeatures.sidechainSeparation
           }
         ]
       },
@@ -3125,15 +3285,15 @@ var LayerImpl16 = Effect24.gen(function* () {
     getFlags
   };
 });
-var FeatureFlagController = class extends Context21.Tag("FeatureFlagController")() {
+var FeatureFlagController = class extends Context23.Tag("FeatureFlagController")() {
   static {
-    this.Live = Layer22.effect(this, LayerImpl16);
+    this.Live = Layer25.effect(this, LayerImpl18);
   }
 };
 
 // src/server/core/file-system/presentation/FileSystemController.ts
 import { homedir as homedir3 } from "node:os";
-import { Context as Context22, Effect as Effect25, Layer as Layer23 } from "effect";
+import { Context as Context24, Effect as Effect28, Layer as Layer26 } from "effect";
 
 // src/server/core/file-system/functions/getDirectoryListing.ts
 import { existsSync } from "node:fs";
@@ -3266,9 +3426,9 @@ var getFileCompletion = async (projectPath, basePath = "/") => {
 };
 
 // src/server/core/file-system/presentation/FileSystemController.ts
-var LayerImpl17 = Effect25.gen(function* () {
+var LayerImpl19 = Effect28.gen(function* () {
   const projectRepository = yield* ProjectRepository;
-  const getFileCompletionRoute = (options) => Effect25.gen(function* () {
+  const getFileCompletionRoute = (options) => Effect28.gen(function* () {
     const { projectId, basePath } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -3279,7 +3439,7 @@ var LayerImpl17 = Effect25.gen(function* () {
     }
     const projectPath = project.meta.projectPath;
     try {
-      const result = yield* Effect25.promise(
+      const result = yield* Effect28.promise(
         () => getFileCompletion(projectPath, basePath)
       );
       return {
@@ -3294,7 +3454,7 @@ var LayerImpl17 = Effect25.gen(function* () {
       };
     }
   });
-  const getDirectoryListingRoute = (options) => Effect25.promise(async () => {
+  const getDirectoryListingRoute = (options) => Effect28.promise(async () => {
     const { currentPath, showHidden = false } = options;
     const rootPath = "/";
     const defaultPath = homedir3();
@@ -3323,14 +3483,14 @@ var LayerImpl17 = Effect25.gen(function* () {
     getDirectoryListingRoute
   };
 });
-var FileSystemController = class extends Context22.Tag("FileSystemController")() {
+var FileSystemController = class extends Context24.Tag("FileSystemController")() {
   static {
-    this.Live = Layer23.effect(this, LayerImpl17);
+    this.Live = Layer26.effect(this, LayerImpl19);
   }
 };
 
 // src/server/core/git/presentation/GitController.ts
-import { Context as Context24, Effect as Effect27, Either as Either2, Layer as Layer25 } from "effect";
+import { Context as Context26, Effect as Effect30, Either as Either2, Layer as Layer28 } from "effect";
 
 // src/server/core/git/functions/getDiff.ts
 import { readFile } from "node:fs/promises";
@@ -3669,8 +3829,8 @@ var getDiff = async (cwd, fromRefText, toRefText) => {
 };
 
 // src/server/core/git/services/GitService.ts
-import { Command as Command2, FileSystem as FileSystem7, Path as Path9 } from "@effect/platform";
-import { Context as Context23, Data as Data4, Duration, Effect as Effect26, Either, Layer as Layer24 } from "effect";
+import { Command as Command2, FileSystem as FileSystem9, Path as Path11 } from "@effect/platform";
+import { Context as Context25, Data as Data4, Duration, Effect as Effect29, Either, Layer as Layer27 } from "effect";
 
 // src/server/core/git/functions/parseGitBranchesOutput.ts
 var parseGitBranchesOutput = (output) => {
@@ -3747,14 +3907,14 @@ var GitCommandError = class extends Data4.TaggedError("GitCommandError") {
 };
 var DetachedHeadError = class extends Data4.TaggedError("DetachedHeadError") {
 };
-var LayerImpl18 = Effect26.gen(function* () {
-  const fs = yield* FileSystem7.FileSystem;
-  const path = yield* Path9.Path;
+var LayerImpl20 = Effect29.gen(function* () {
+  const fs = yield* FileSystem9.FileSystem;
+  const path = yield* Path11.Path;
   const envService = yield* EnvService;
-  const execGitCommand = (args, cwd) => Effect26.gen(function* () {
+  const execGitCommand = (args, cwd) => Effect29.gen(function* () {
     const absoluteCwd = path.resolve(cwd);
     if (!(yield* fs.exists(absoluteCwd))) {
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new NotARepositoryError({ cwd: absoluteCwd })
       );
     }
@@ -3764,9 +3924,9 @@ var LayerImpl18 = Effect26.gen(function* () {
         PATH: yield* envService.getEnv("PATH")
       })
     );
-    const result = yield* Effect26.either(Command2.string(command));
+    const result = yield* Effect29.either(Command2.string(command));
     if (Either.isLeft(result)) {
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: `git ${args.join(" ")}`
@@ -3775,22 +3935,22 @@ var LayerImpl18 = Effect26.gen(function* () {
     }
     return result.right;
   });
-  const getBranches = (cwd) => Effect26.gen(function* () {
+  const getBranches = (cwd) => Effect29.gen(function* () {
     const result = yield* execGitCommand(["branch", "-vv", "--all"], cwd);
     return parseGitBranchesOutput(result);
   });
-  const getCurrentBranch = (cwd) => Effect26.gen(function* () {
+  const getCurrentBranch = (cwd) => Effect29.gen(function* () {
     const currentBranch = yield* execGitCommand(
       ["branch", "--show-current"],
       cwd
-    ).pipe(Effect26.map((result) => result.trim()));
+    ).pipe(Effect29.map((result) => result.trim()));
     if (currentBranch === "") {
-      return yield* Effect26.fail(new DetachedHeadError({ cwd }));
+      return yield* Effect29.fail(new DetachedHeadError({ cwd }));
     }
     return currentBranch;
   });
-  const branchExists = (cwd, branchName) => Effect26.gen(function* () {
-    const result = yield* Effect26.either(
+  const branchExists = (cwd, branchName) => Effect29.gen(function* () {
+    const result = yield* Effect29.either(
       execGitCommand(["branch", "--exists", branchName], cwd)
     );
     if (Either.isLeft(result)) {
@@ -3798,7 +3958,7 @@ var LayerImpl18 = Effect26.gen(function* () {
     }
     return true;
   });
-  const getCommits = (cwd) => Effect26.gen(function* () {
+  const getCommits = (cwd) => Effect29.gen(function* () {
     const result = yield* execGitCommand(
       [
         "log",
@@ -3812,9 +3972,9 @@ var LayerImpl18 = Effect26.gen(function* () {
     );
     return parseGitCommitsOutput(result);
   });
-  const stageFiles = (cwd, files) => Effect26.gen(function* () {
+  const stageFiles = (cwd, files) => Effect29.gen(function* () {
     if (files.length === 0) {
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new GitCommandError({
           cwd,
           command: "git add (no files)"
@@ -3824,10 +3984,10 @@ var LayerImpl18 = Effect26.gen(function* () {
     const result = yield* execGitCommand(["add", ...files], cwd);
     return result;
   });
-  const commit = (cwd, message) => Effect26.gen(function* () {
+  const commit = (cwd, message) => Effect29.gen(function* () {
     const trimmedMessage = message.trim();
     if (trimmedMessage.length === 0) {
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new GitCommandError({
           cwd,
           command: "git commit (empty message)"
@@ -3864,7 +4024,7 @@ var LayerImpl18 = Effect26.gen(function* () {
     );
     return sha.trim();
   });
-  const push = (cwd) => Effect26.gen(function* () {
+  const push = (cwd) => Effect29.gen(function* () {
     const branch = yield* getCurrentBranch(cwd);
     const absoluteCwd = path.resolve(cwd);
     const command = Command2.make("git", "push", "origin", "HEAD").pipe(
@@ -3873,12 +4033,12 @@ var LayerImpl18 = Effect26.gen(function* () {
         PATH: yield* envService.getEnv("PATH")
       })
     );
-    const exitCodeResult = yield* Effect26.either(
-      Command2.exitCode(command).pipe(Effect26.timeout(Duration.seconds(60)))
+    const exitCodeResult = yield* Effect29.either(
+      Command2.exitCode(command).pipe(Effect29.timeout(Duration.seconds(60)))
     );
     if (Either.isLeft(exitCodeResult)) {
       console.log("[GitService.push] Command failed or timeout");
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: "git push origin HEAD (timeout after 60s)"
@@ -3896,10 +4056,10 @@ var LayerImpl18 = Effect26.gen(function* () {
           }),
           Command2.stderr("inherit")
         )
-      ).pipe(Effect26.orElse(() => Effect26.succeed([])));
+      ).pipe(Effect29.orElse(() => Effect29.succeed([])));
       const stderr = Array.from(stderrLines).join("\n");
       console.log("[GitService.push] Failed with stderr:", stderr);
-      return yield* Effect26.fail(
+      return yield* Effect29.fail(
         new GitCommandError({
           cwd: absoluteCwd,
           command: `git push origin HEAD - ${stderr}`
@@ -3909,20 +4069,20 @@ var LayerImpl18 = Effect26.gen(function* () {
     console.log("[GitService.push] Push succeeded");
     return { branch, output: "success" };
   });
-  const getBranchHash = (cwd, branchName) => Effect26.gen(function* () {
+  const getBranchHash = (cwd, branchName) => Effect29.gen(function* () {
     const result = yield* execGitCommand(["rev-parse", branchName], cwd).pipe(
-      Effect26.map((output) => output.trim().split("\n")[0] ?? null)
+      Effect29.map((output) => output.trim().split("\n")[0] ?? null)
     );
     return result;
   });
-  const getBranchNamesByCommitHash = (cwd, hash) => Effect26.gen(function* () {
+  const getBranchNamesByCommitHash = (cwd, hash) => Effect29.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) => Effect26.gen(function* () {
+  const compareCommitHash = (cwd, targetHash, compareHash) => Effect29.gen(function* () {
     const aheadResult = yield* execGitCommand(
       ["rev-list", `${targetHash}..${compareHash}`],
       cwd
@@ -3944,7 +4104,7 @@ var LayerImpl18 = Effect26.gen(function* () {
     }
     return "un-related";
   });
-  const getCommitsWithParent = (cwd, options) => Effect26.gen(function* () {
+  const getCommitsWithParent = (cwd, options) => Effect29.gen(function* () {
     const { offset, limit } = options;
     const result = yield* execGitCommand(
       [
@@ -3971,7 +4131,7 @@ var LayerImpl18 = Effect26.gen(function* () {
     }
     return commits;
   });
-  const findBaseBranch = (cwd, targetBranch) => Effect26.gen(function* () {
+  const findBaseBranch = (cwd, targetBranch) => Effect29.gen(function* () {
     let offset = 0;
     const limit = 20;
     while (offset < 100) {
@@ -4005,7 +4165,7 @@ var LayerImpl18 = Effect26.gen(function* () {
     }
     return null;
   });
-  const getCommitsBetweenBranches = (cwd, baseBranch, targetBranch) => Effect26.gen(function* () {
+  const getCommitsBetweenBranches = (cwd, baseBranch, targetBranch) => Effect29.gen(function* () {
     const result = yield* execGitCommand(
       [
         "log",
@@ -4033,17 +4193,17 @@ var LayerImpl18 = Effect26.gen(function* () {
     getCommitsBetweenBranches
   };
 });
-var GitService = class extends Context23.Tag("GitService")() {
+var GitService = class extends Context25.Tag("GitService")() {
   static {
-    this.Live = Layer24.effect(this, LayerImpl18);
+    this.Live = Layer27.effect(this, LayerImpl20);
   }
 };
 
 // src/server/core/git/presentation/GitController.ts
-var LayerImpl19 = Effect27.gen(function* () {
+var LayerImpl21 = Effect30.gen(function* () {
   const gitService = yield* GitService;
   const projectRepository = yield* ProjectRepository;
-  const getGitDiff = (options) => Effect27.gen(function* () {
+  const getGitDiff = (options) => Effect30.gen(function* () {
     const { projectId, fromRef, toRef } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     try {
@@ -4054,7 +4214,7 @@ var LayerImpl19 = Effect27.gen(function* () {
         };
       }
       const projectPath = project.meta.projectPath;
-      const result = yield* Effect27.promise(
+      const result = yield* Effect30.promise(
         () => getDiff(projectPath, fromRef, toRef)
       );
       return {
@@ -4075,7 +4235,7 @@ var LayerImpl19 = Effect27.gen(function* () {
       };
     }
   });
-  const commitFiles = (options) => Effect27.gen(function* () {
+  const commitFiles = (options) => Effect30.gen(function* () {
     const { projectId, files, message } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -4088,7 +4248,7 @@ var LayerImpl19 = Effect27.gen(function* () {
     const projectPath = project.meta.projectPath;
     console.log("[GitController.commitFiles] Project path:", projectPath);
     console.log("[GitController.commitFiles] Staging files...");
-    const stageResult = yield* Effect27.either(
+    const stageResult = yield* Effect30.either(
       gitService.stageFiles(projectPath, files)
     );
     if (Either2.isLeft(stageResult)) {
@@ -4108,7 +4268,7 @@ var LayerImpl19 = Effect27.gen(function* () {
     }
     console.log("[GitController.commitFiles] Stage succeeded");
     console.log("[GitController.commitFiles] Committing...");
-    const commitResult = yield* Effect27.either(
+    const commitResult = yield* Effect30.either(
       gitService.commit(projectPath, message)
     );
     if (Either2.isLeft(commitResult)) {
@@ -4143,7 +4303,7 @@ var LayerImpl19 = Effect27.gen(function* () {
       status: 200
     };
   });
-  const pushCommits = (options) => Effect27.gen(function* () {
+  const pushCommits = (options) => Effect30.gen(function* () {
     const { projectId } = options;
     console.log("[GitController.pushCommits] Request:", { projectId });
     const { project } = yield* projectRepository.getProject(projectId);
@@ -4157,7 +4317,7 @@ var LayerImpl19 = Effect27.gen(function* () {
     const projectPath = project.meta.projectPath;
     console.log("[GitController.pushCommits] Project path:", projectPath);
     console.log("[GitController.pushCommits] Pushing...");
-    const pushResult = yield* Effect27.either(gitService.push(projectPath));
+    const pushResult = yield* Effect30.either(gitService.push(projectPath));
     if (Either2.isLeft(pushResult)) {
       console.log(
         "[GitController.pushCommits] Push failed:",
@@ -4186,7 +4346,7 @@ var LayerImpl19 = Effect27.gen(function* () {
       status: 200
     };
   });
-  const commitAndPush = (options) => Effect27.gen(function* () {
+  const commitAndPush = (options) => Effect30.gen(function* () {
     const { projectId, files, message } = options;
     console.log("[GitController.commitAndPush] Request:", {
       projectId,
@@ -4237,7 +4397,7 @@ var LayerImpl19 = Effect27.gen(function* () {
       status: 200
     };
   });
-  const getCurrentRevisions = (options) => Effect27.gen(function* () {
+  const getCurrentRevisions = (options) => Effect30.gen(function* () {
     const { projectId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     if (project.meta.projectPath === null) {
@@ -4247,7 +4407,7 @@ var LayerImpl19 = Effect27.gen(function* () {
       };
     }
     const projectPath = project.meta.projectPath;
-    const currentBranchResult = yield* Effect27.either(
+    const currentBranchResult = yield* Effect30.either(
       gitService.getCurrentBranch(projectPath)
     );
     if (Either2.isLeft(currentBranchResult)) {
@@ -4259,10 +4419,10 @@ var LayerImpl19 = Effect27.gen(function* () {
       };
     }
     const currentBranch = currentBranchResult.right;
-    const baseBranchResult = yield* Effect27.either(
+    const baseBranchResult = yield* Effect30.either(
       gitService.findBaseBranch(projectPath, currentBranch)
     );
-    const allBranchesResult = yield* Effect27.either(
+    const allBranchesResult = yield* Effect30.either(
       gitService.getBranches(projectPath)
     );
     if (Either2.isLeft(allBranchesResult)) {
@@ -4287,7 +4447,7 @@ var LayerImpl19 = Effect27.gen(function* () {
     let commits = [];
     if (Either2.isRight(baseBranchResult) && baseBranchResult.right !== null) {
       const baseBranchHash = baseBranchResult.right.hash;
-      const commitsResult = yield* Effect27.either(
+      const commitsResult = yield* Effect30.either(
         gitService.getCommitsBetweenBranches(
           projectPath,
           baseBranchHash,
@@ -4350,21 +4510,21 @@ function getPushErrorMessage(code) {
   };
   return messages[code];
 }
-var GitController = class extends Context24.Tag("GitController")() {
+var GitController = class extends Context26.Tag("GitController")() {
   static {
-    this.Live = Layer25.effect(this, LayerImpl19);
+    this.Live = Layer28.effect(this, LayerImpl21);
   }
 };
 
 // src/server/core/project/presentation/ProjectController.ts
-import { FileSystem as FileSystem8, Path as Path11 } from "@effect/platform";
-import { Context as Context25, Effect as Effect29, Layer as Layer26 } from "effect";
+import { FileSystem as FileSystem10, Path as Path13 } from "@effect/platform";
+import { Context as Context27, Effect as Effect32, Layer as Layer29 } from "effect";
 
 // src/server/core/claude-code/functions/computeClaudeProjectFilePath.ts
-import { Path as Path10 } from "@effect/platform";
-import { Effect as Effect28 } from "effect";
-var computeClaudeProjectFilePath = (options) => Effect28.gen(function* () {
-  const path = yield* Path10.Path;
+import { Path as Path12 } from "@effect/platform";
+import { Effect as Effect31 } from "effect";
+var computeClaudeProjectFilePath = (options) => Effect31.gen(function* () {
+  const path = yield* Path12.Path;
   const { projectPath, claudeProjectsDirPath } = options;
   return path.join(
     claudeProjectsDirPath,
@@ -4373,22 +4533,22 @@ var computeClaudeProjectFilePath = (options) => Effect28.gen(function* () {
 });
 
 // src/server/core/project/presentation/ProjectController.ts
-var LayerImpl20 = Effect29.gen(function* () {
+var LayerImpl22 = Effect32.gen(function* () {
   const projectRepository = yield* ProjectRepository;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const userConfigService = yield* UserConfigService;
   const sessionRepository = yield* SessionRepository;
   const context = yield* ApplicationContext;
-  const fileSystem = yield* FileSystem8.FileSystem;
-  const path = yield* Path11.Path;
-  const getProjects = () => Effect29.gen(function* () {
+  const fileSystem = yield* FileSystem10.FileSystem;
+  const path = yield* Path13.Path;
+  const getProjects = () => Effect32.gen(function* () {
     const { projects } = yield* projectRepository.getProjects();
     return {
       status: 200,
       response: { projects }
     };
   });
-  const getProject = (options) => Effect29.gen(function* () {
+  const getProject = (options) => Effect32.gen(function* () {
     const { projectId, cursor } = options;
     const userConfig = yield* userConfigService.getUserConfig();
     const { project } = yield* projectRepository.getProject(projectId);
@@ -4442,7 +4602,7 @@ var LayerImpl20 = Effect29.gen(function* () {
       }
     };
   });
-  const getProjectLatestSession = (options) => Effect29.gen(function* () {
+  const getProjectLatestSession = (options) => Effect32.gen(function* () {
     const { projectId } = options;
     const { sessions } = yield* sessionRepository.getSessions(projectId, {
       maxCount: 1
@@ -4454,7 +4614,7 @@ var LayerImpl20 = Effect29.gen(function* () {
       }
     };
   });
-  const createProject = (options) => Effect29.gen(function* () {
+  const createProject = (options) => Effect32.gen(function* () {
     const { projectPath } = options;
     const claudeProjectFilePath = yield* computeClaudeProjectFilePath({
       projectPath,
@@ -4491,16 +4651,16 @@ var LayerImpl20 = Effect29.gen(function* () {
     createProject
   };
 });
-var ProjectController = class extends Context25.Tag("ProjectController")() {
+var ProjectController = class extends Context27.Tag("ProjectController")() {
   static {
-    this.Live = Layer26.effect(this, LayerImpl20);
+    this.Live = Layer29.effect(this, LayerImpl22);
   }
 };
 
 // src/server/core/scheduler/config.ts
 import { homedir as homedir4 } from "node:os";
-import { FileSystem as FileSystem9, Path as Path12 } from "@effect/platform";
-import { Context as Context26, Data as Data5, Effect as Effect30, Layer as Layer27 } from "effect";
+import { FileSystem as FileSystem11, Path as Path14 } from "@effect/platform";
+import { Context as Context28, Data as Data5, Effect as Effect33, Layer as Layer30 } from "effect";
 
 // src/server/core/scheduler/schema.ts
 import { z as z23 } from "zod";
@@ -4561,29 +4721,29 @@ var ConfigParseError = class extends Data5.TaggedError("ConfigParseError") {
 };
 var CONFIG_DIR = "scheduler";
 var CONFIG_FILE = "schedules.json";
-var SchedulerConfigBaseDir = class extends Context26.Tag(
+var SchedulerConfigBaseDir = class extends Context28.Tag(
   "SchedulerConfigBaseDir"
 )() {
   static {
-    this.Live = Layer27.succeed(this, `${homedir4()}/.claude-code-viewer`);
+    this.Live = Layer30.succeed(this, `${homedir4()}/.claude-code-viewer`);
   }
 };
-var getConfigPath = Effect30.gen(function* () {
-  const path = yield* Path12.Path;
+var getConfigPath = Effect33.gen(function* () {
+  const path = yield* Path14.Path;
   const baseDir = yield* SchedulerConfigBaseDir;
   return path.join(baseDir, CONFIG_DIR, CONFIG_FILE);
 });
-var readConfig = Effect30.gen(function* () {
-  const fs = yield* FileSystem9.FileSystem;
+var readConfig = Effect33.gen(function* () {
+  const fs = yield* FileSystem11.FileSystem;
   const configPath = yield* getConfigPath;
   const exists = yield* fs.exists(configPath);
   if (!exists) {
-    return yield* Effect30.fail(
+    return yield* Effect33.fail(
       new ConfigFileNotFoundError({ path: configPath })
     );
   }
   const content = yield* fs.readFileString(configPath);
-  const jsonResult = yield* Effect30.try({
+  const jsonResult = yield* Effect33.try({
     try: () => JSON.parse(content),
     catch: (error) => new ConfigParseError({
       path: configPath,
@@ -4592,7 +4752,7 @@ var readConfig = Effect30.gen(function* () {
   });
   const parsed = schedulerConfigSchema.safeParse(jsonResult);
   if (!parsed.success) {
-    return yield* Effect30.fail(
+    return yield* Effect33.fail(
       new ConfigParseError({
         path: configPath,
         cause: parsed.error
@@ -4601,24 +4761,24 @@ var readConfig = Effect30.gen(function* () {
   }
   return parsed.data;
 });
-var writeConfig = (config) => Effect30.gen(function* () {
-  const fs = yield* FileSystem9.FileSystem;
-  const path = yield* Path12.Path;
+var writeConfig = (config) => Effect33.gen(function* () {
+  const fs = yield* FileSystem11.FileSystem;
+  const path = yield* Path14.Path;
   const configPath = yield* getConfigPath;
   const configDir = path.dirname(configPath);
   yield* fs.makeDirectory(configDir, { recursive: true });
   const content = JSON.stringify(config, null, 2);
   yield* fs.writeFileString(configPath, content);
 });
-var initializeConfig = Effect30.gen(function* () {
+var initializeConfig = Effect33.gen(function* () {
   const result = yield* readConfig.pipe(
-    Effect30.catchTags({
-      ConfigFileNotFoundError: () => Effect30.gen(function* () {
+    Effect33.catchTags({
+      ConfigFileNotFoundError: () => Effect33.gen(function* () {
         const initialConfig = { jobs: [] };
         yield* writeConfig(initialConfig);
         return initialConfig;
       }),
-      ConfigParseError: () => Effect30.gen(function* () {
+      ConfigParseError: () => Effect33.gen(function* () {
         const initialConfig = { jobs: [] };
         yield* writeConfig(initialConfig);
         return initialConfig;
@@ -4630,21 +4790,21 @@ var initializeConfig = Effect30.gen(function* () {
 
 // src/server/core/scheduler/domain/Scheduler.ts
 import {
-  Context as Context27,
+  Context as Context29,
   Cron,
   Data as Data6,
   Duration as Duration2,
-  Effect as Effect32,
+  Effect as Effect35,
   Fiber,
-  Layer as Layer28,
+  Layer as Layer31,
   Ref as Ref10,
   Schedule
 } from "effect";
 import { ulid as ulid4 } from "ulid";
 
 // src/server/core/scheduler/domain/Job.ts
-import { Effect as Effect31 } from "effect";
-var executeJob = (job) => Effect31.gen(function* () {
+import { Effect as Effect34 } from "effect";
+var executeJob = (job) => Effect34.gen(function* () {
   const lifeCycleService = yield* ClaudeCodeLifeCycleService;
   const projectRepository = yield* ProjectRepository;
   const userConfigService = yield* UserConfigService;
@@ -4652,7 +4812,7 @@ var executeJob = (job) => Effect31.gen(function* () {
   const { project } = yield* projectRepository.getProject(message.projectId);
   const userConfig = yield* userConfigService.getUserConfig();
   if (project.meta.projectPath === null) {
-    return yield* Effect31.fail(
+    return yield* Effect34.fail(
       new Error(`Project path not found for projectId: ${message.projectId}`)
     );
   }
@@ -4686,15 +4846,15 @@ var InvalidCronExpressionError = class extends Data6.TaggedError(
   "InvalidCronExpressionError"
 ) {
 };
-var LayerImpl21 = Effect32.gen(function* () {
+var LayerImpl23 = Effect35.gen(function* () {
   const fibersRef = yield* Ref10.make(/* @__PURE__ */ new Map());
   const runningJobsRef = yield* Ref10.make(/* @__PURE__ */ new Set());
-  const startJob = (job) => Effect32.gen(function* () {
+  const startJob = (job) => Effect35.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* Effect32.fail(
+        return yield* Effect35.fail(
           new InvalidCronExpressionError({
             expression: job.schedule.expression,
             cause: cronResult.left
@@ -4702,12 +4862,12 @@ var LayerImpl21 = Effect32.gen(function* () {
         );
       }
       const cronSchedule = Schedule.cron(cronResult.right);
-      const fiber = yield* Effect32.gen(function* () {
+      const fiber = yield* Effect35.gen(function* () {
         const nextTime = Cron.next(cronResult.right, /* @__PURE__ */ new Date());
         const nextDelay = Math.max(0, nextTime.getTime() - Date.now());
-        yield* Effect32.sleep(Duration2.millis(nextDelay));
-        yield* Effect32.repeat(runJobWithConcurrencyControl(job), cronSchedule);
-      }).pipe(Effect32.forkDaemon);
+        yield* Effect35.sleep(Duration2.millis(nextDelay));
+        yield* Effect35.repeat(runJobWithConcurrencyControl(job), cronSchedule);
+      }).pipe(Effect35.forkDaemon);
       yield* Ref10.update(
         fibersRef,
         (fibers) => new Map(fibers).set(job.id, fiber)
@@ -4718,17 +4878,17 @@ var LayerImpl21 = Effect32.gen(function* () {
       }
       const delay = calculateReservedDelay(job, now);
       const delayDuration = Duration2.millis(delay);
-      const fiber = yield* Effect32.delay(
+      const fiber = yield* Effect35.delay(
         runJobWithConcurrencyControl(job),
         delayDuration
-      ).pipe(Effect32.forkDaemon);
+      ).pipe(Effect35.forkDaemon);
       yield* Ref10.update(
         fibersRef,
         (fibers) => new Map(fibers).set(job.id, fiber)
       );
     }
   });
-  const runJobWithConcurrencyControl = (job) => Effect32.gen(function* () {
+  const runJobWithConcurrencyControl = (job) => Effect35.gen(function* () {
     if (job.schedule.type === "cron" && job.schedule.concurrencyPolicy === "skip") {
       const runningJobs = yield* Ref10.get(runningJobsRef);
       if (runningJobs.has(job.id)) {
@@ -4738,9 +4898,9 @@ var LayerImpl21 = Effect32.gen(function* () {
     yield* Ref10.update(runningJobsRef, (jobs) => new Set(jobs).add(job.id));
     if (job.schedule.type === "reserved") {
       const result2 = yield* executeJob(job).pipe(
-        Effect32.matchEffect({
-          onSuccess: () => Effect32.void,
-          onFailure: () => Effect32.void
+        Effect35.matchEffect({
+          onSuccess: () => Effect35.void,
+          onFailure: () => Effect35.void
         })
       );
       yield* Ref10.update(runningJobsRef, (jobs) => {
@@ -4749,18 +4909,18 @@ var LayerImpl21 = Effect32.gen(function* () {
         return newJobs;
       });
       yield* deleteJobFromConfig(job.id).pipe(
-        Effect32.catchAll((error) => {
+        Effect35.catchAll((error) => {
           console.error(
             `[Scheduler] Failed to delete reserved job ${job.id}:`,
             error
           );
-          return Effect32.void;
+          return Effect35.void;
         })
       );
       return result2;
     }
     const result = yield* executeJob(job).pipe(
-      Effect32.matchEffect({
+      Effect35.matchEffect({
         onSuccess: () => updateJobStatus(job.id, "success", (/* @__PURE__ */ new Date()).toISOString()),
         onFailure: () => updateJobStatus(job.id, "failed", (/* @__PURE__ */ new Date()).toISOString())
       })
@@ -4772,7 +4932,7 @@ var LayerImpl21 = Effect32.gen(function* () {
     });
     return result;
   });
-  const updateJobStatus = (jobId, status, runAt) => Effect32.gen(function* () {
+  const updateJobStatus = (jobId, status, runAt) => Effect35.gen(function* () {
     const config = yield* readConfig;
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
@@ -4788,7 +4948,7 @@ var LayerImpl21 = Effect32.gen(function* () {
     };
     yield* writeConfig(updatedConfig);
   });
-  const stopJob = (jobId) => Effect32.gen(function* () {
+  const stopJob = (jobId) => Effect35.gen(function* () {
     const fibers = yield* Ref10.get(fibersRef);
     const fiber = fibers.get(jobId);
     if (fiber !== void 0) {
@@ -4800,7 +4960,7 @@ var LayerImpl21 = Effect32.gen(function* () {
       });
     }
   });
-  const startScheduler = Effect32.gen(function* () {
+  const startScheduler = Effect35.gen(function* () {
     yield* initializeConfig;
     const config = yield* readConfig;
     for (const job of config.jobs) {
@@ -4809,27 +4969,27 @@ var LayerImpl21 = Effect32.gen(function* () {
       }
     }
   });
-  const stopScheduler = Effect32.gen(function* () {
+  const stopScheduler = Effect35.gen(function* () {
     const fibers = yield* Ref10.get(fibersRef);
     for (const fiber of fibers.values()) {
       yield* Fiber.interrupt(fiber);
     }
     yield* Ref10.set(fibersRef, /* @__PURE__ */ new Map());
   });
-  const getJobs = () => Effect32.gen(function* () {
+  const getJobs = () => Effect35.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect32.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] })))
+      Effect35.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] })))
       })
     );
     return config.jobs;
   });
-  const addJob = (newJob) => Effect32.gen(function* () {
+  const addJob = (newJob) => Effect35.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect32.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] })))
+      Effect35.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] })))
       })
     );
     const job = {
@@ -4848,16 +5008,16 @@ var LayerImpl21 = Effect32.gen(function* () {
     }
     return job;
   });
-  const updateJob = (jobId, updates) => Effect32.gen(function* () {
+  const updateJob = (jobId, updates) => Effect35.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect32.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] })))
+      Effect35.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect32.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect35.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     yield* stopJob(jobId);
     const updatedJob = {
@@ -4873,32 +5033,32 @@ var LayerImpl21 = Effect32.gen(function* () {
     }
     return updatedJob;
   });
-  const deleteJobFromConfig = (jobId) => Effect32.gen(function* () {
+  const deleteJobFromConfig = (jobId) => Effect35.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect32.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] })))
+      Effect35.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect32.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect35.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     const updatedConfig = {
       jobs: config.jobs.filter((j) => j.id !== jobId)
     };
     yield* writeConfig(updatedConfig);
   });
-  const deleteJob = (jobId) => Effect32.gen(function* () {
+  const deleteJob = (jobId) => Effect35.gen(function* () {
     const config = yield* readConfig.pipe(
-      Effect32.catchTags({
-        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] }))),
-        ConfigParseError: () => initializeConfig.pipe(Effect32.map(() => ({ jobs: [] })))
+      Effect35.catchTags({
+        ConfigFileNotFoundError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] }))),
+        ConfigParseError: () => initializeConfig.pipe(Effect35.map(() => ({ jobs: [] })))
       })
     );
     const job = config.jobs.find((j) => j.id === jobId);
     if (job === void 0) {
-      return yield* Effect32.fail(new SchedulerJobNotFoundError({ jobId }));
+      return yield* Effect35.fail(new SchedulerJobNotFoundError({ jobId }));
     }
     yield* stopJob(jobId);
     yield* deleteJobFromConfig(jobId);
@@ -4912,24 +5072,24 @@ var LayerImpl21 = Effect32.gen(function* () {
     deleteJob
   };
 });
-var SchedulerService = class extends Context27.Tag("SchedulerService")() {
+var SchedulerService = class extends Context29.Tag("SchedulerService")() {
   static {
-    this.Live = Layer28.effect(this, LayerImpl21);
+    this.Live = Layer31.effect(this, LayerImpl23);
   }
 };
 
 // src/server/core/scheduler/presentation/SchedulerController.ts
-import { Context as Context28, Effect as Effect33, Layer as Layer29 } from "effect";
-var LayerImpl22 = Effect33.gen(function* () {
+import { Context as Context30, Effect as Effect36, Layer as Layer32 } from "effect";
+var LayerImpl24 = Effect36.gen(function* () {
   const schedulerService = yield* SchedulerService;
-  const getJobs = () => Effect33.gen(function* () {
+  const getJobs = () => Effect36.gen(function* () {
     const jobs = yield* schedulerService.getJobs();
     return {
       response: jobs,
       status: 200
     };
   });
-  const addJob = (options) => Effect33.gen(function* () {
+  const addJob = (options) => Effect36.gen(function* () {
     const { job } = options;
     const result = yield* schedulerService.addJob(job);
     return {
@@ -4937,12 +5097,12 @@ var LayerImpl22 = Effect33.gen(function* () {
       status: 201
     };
   });
-  const updateJob = (options) => Effect33.gen(function* () {
+  const updateJob = (options) => Effect36.gen(function* () {
     const { id, job } = options;
     const result = yield* schedulerService.updateJob(id, job).pipe(
-      Effect33.catchTag(
+      Effect36.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect33.succeed(null)
+        () => Effect36.succeed(null)
       )
     );
     if (result === null) {
@@ -4956,14 +5116,14 @@ var LayerImpl22 = Effect33.gen(function* () {
       status: 200
     };
   });
-  const deleteJob = (options) => Effect33.gen(function* () {
+  const deleteJob = (options) => Effect36.gen(function* () {
     const { id } = options;
     const result = yield* schedulerService.deleteJob(id).pipe(
-      Effect33.catchTag(
+      Effect36.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect33.succeed(false)
+        () => Effect36.succeed(false)
       ),
-      Effect33.map(() => true)
+      Effect36.map(() => true)
     );
     if (!result) {
       return {
@@ -4983,17 +5143,17 @@ var LayerImpl22 = Effect33.gen(function* () {
     deleteJob
   };
 });
-var SchedulerController = class extends Context28.Tag("SchedulerController")() {
+var SchedulerController = class extends Context30.Tag("SchedulerController")() {
   static {
-    this.Live = Layer29.effect(this, LayerImpl22);
+    this.Live = Layer32.effect(this, LayerImpl24);
   }
 };
 
 // src/server/core/session/presentation/SessionController.ts
-import { Context as Context29, Effect as Effect35, Layer as Layer30 } from "effect";
+import { Context as Context31, Effect as Effect38, Layer as Layer33 } from "effect";
 
 // src/server/core/session/services/ExportService.ts
-import { Effect as Effect34 } from "effect";
+import { Effect as Effect37 } from "effect";
 var escapeHtml = (text) => {
   const map = {
     "&": "&amp;",
@@ -5252,7 +5412,7 @@ var renderGroupedAssistantEntries = (entries) => {
     </div>
   `;
 };
-var generateSessionHtml = (session, projectId) => Effect34.gen(function* () {
+var generateSessionHtml = (session, projectId) => Effect37.gen(function* () {
   const grouped = groupConsecutiveAssistantMessages(session.conversations);
   const conversationsHtml = grouped.map((group) => {
     if (group.type === "grouped") {
@@ -5772,9 +5932,9 @@ var generateSessionHtml = (session, projectId) => Effect34.gen(function* () {
 });
 
 // src/server/core/session/presentation/SessionController.ts
-var LayerImpl23 = Effect35.gen(function* () {
+var LayerImpl25 = Effect38.gen(function* () {
   const sessionRepository = yield* SessionRepository;
-  const getSession = (options) => Effect35.gen(function* () {
+  const getSession = (options) => Effect38.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -5785,7 +5945,7 @@ var LayerImpl23 = Effect35.gen(function* () {
       response: { session }
     };
   });
-  const exportSessionHtml = (options) => Effect35.gen(function* () {
+  const exportSessionHtml = (options) => Effect38.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -5808,9 +5968,9 @@ var LayerImpl23 = Effect35.gen(function* () {
     exportSessionHtml
   };
 });
-var SessionController = class extends Context29.Tag("SessionController")() {
+var SessionController = class extends Context31.Tag("SessionController")() {
   static {
-    this.Live = Layer30.effect(this, LayerImpl23);
+    this.Live = Layer33.effect(this, LayerImpl25);
   }
 };
 
@@ -5819,12 +5979,12 @@ import { Hono } from "hono";
 var honoApp = new Hono();
 
 // src/server/hono/initialize.ts
-import { Context as Context30, Effect as Effect36, Layer as Layer31, Ref as Ref11, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context30.Tag("InitializeService")() {
+import { Context as Context32, Effect as Effect39, Layer as Layer34, Ref as Ref11, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context32.Tag("InitializeService")() {
   static {
-    this.Live = Layer31.effect(
+    this.Live = Layer34.effect(
       this,
-      Effect36.gen(function* () {
+      Effect39.gen(function* () {
         const eventBus = yield* EventBus;
         const fileWatcher = yield* FileWatcherService;
         const projectRepository = yield* ProjectRepository;
@@ -5834,20 +5994,20 @@ var InitializeService = class extends Context30.Tag("InitializeService")() {
         const virtualConversationDatabase = yield* VirtualConversationDatabase;
         const listenersRef = yield* Ref11.make({});
         const startInitialization = () => {
-          return Effect36.gen(function* () {
+          return Effect39.gen(function* () {
             yield* fileWatcher.startWatching();
-            const daemon = Effect36.repeat(
+            const daemon = Effect39.repeat(
               eventBus.emit("heartbeat", {}),
               Schedule2.fixed("10 seconds")
             );
             console.log("start heartbeat");
-            yield* Effect36.forkDaemon(daemon);
+            yield* Effect39.forkDaemon(daemon);
             console.log("after starting heartbeat fork");
             const onSessionChanged = (event) => {
-              Effect36.runFork(
+              Effect39.runFork(
                 projectMetaService.invalidateProject(event.projectId)
               );
-              Effect36.runFork(
+              Effect39.runFork(
                 sessionMetaService.invalidateSession(
                   event.projectId,
                   event.sessionId
@@ -5856,7 +6016,7 @@ var InitializeService = class extends Context30.Tag("InitializeService")() {
             };
             const onSessionProcessChanged = (event) => {
               if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect36.runFork(
+                Effect39.runFork(
                   virtualConversationDatabase.deleteVirtualConversations(
                     event.changed.sessionId
                   )
@@ -5870,12 +6030,12 @@ var InitializeService = class extends Context30.Tag("InitializeService")() {
             });
             yield* eventBus.on("sessionChanged", onSessionChanged);
             yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect36.gen(function* () {
+            yield* Effect39.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* Effect36.all(
+              const results = yield* Effect39.all(
                 projects.map(
                   (project) => sessionRepository.getSessions(project.id)
                 ),
@@ -5887,12 +6047,12 @@ var InitializeService = class extends Context30.Tag("InitializeService")() {
               );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect36.catchAll(() => Effect36.void),
-              Effect36.withSpan("initialize-cache")
+              Effect39.catchAll(() => Effect39.void),
+              Effect39.withSpan("initialize-cache")
             );
-          }).pipe(Effect36.withSpan("start-initialization"));
+          }).pipe(Effect39.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect36.gen(function* () {
+        const stopCleanup = () => Effect39.gen(function* () {
           const listeners = yield* Ref11.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
@@ -5917,7 +6077,7 @@ var InitializeService = class extends Context30.Tag("InitializeService")() {
 
 // src/server/hono/route.ts
 import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect38, Runtime as Runtime3 } from "effect";
+import { Effect as Effect41, Runtime as Runtime3 } from "effect";
 import { setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
@@ -5926,7 +6086,7 @@ import { z as z28 } from "zod";
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.4.5",
+  version: "0.4.7",
   type: "module",
   license: "MIT",
   repository: {
@@ -6191,9 +6351,9 @@ var userConfigSchema = z27.object({
 var defaultUserConfig = userConfigSchema.parse({});
 
 // src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect37 } from "effect";
+import { Effect as Effect40 } from "effect";
 var effectToResponse = async (ctx, effect) => {
-  const result = await Effect37.runPromise(effect);
+  const result = await Effect40.runPromise(effect);
   const result2 = ctx.json(result.response, result.status);
   return result2;
 };
@@ -6236,9 +6396,10 @@ var configMiddleware = createMiddleware(
 );
 
 // src/server/hono/route.ts
-var routes = (app) => Effect38.gen(function* () {
+var routes = (app) => Effect41.gen(function* () {
   const projectController = yield* ProjectController;
   const sessionController = yield* SessionController;
+  const agentSessionController = yield* AgentSessionController;
   const gitController = yield* GitController;
   const claudeCodeSessionProcessController = yield* ClaudeCodeSessionProcessController;
   const claudeCodePermissionController = yield* ClaudeCodePermissionController;
@@ -6251,7 +6412,7 @@ var routes = (app) => Effect38.gen(function* () {
   const userConfigService = yield* UserConfigService;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const initializeService = yield* InitializeService;
-  const runtime = yield* Effect38.runtime();
+  const runtime = yield* Effect41.runtime();
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
     prexit(async () => {
@@ -6259,7 +6420,7 @@ var routes = (app) => Effect38.gen(function* () {
     });
   }
   return app.use(configMiddleware).use(async (c, next) => {
-    await Effect38.runPromise(
+    await Effect41.runPromise(
       userConfigService.setUserConfig({
         ...c.get("userConfig")
       })
@@ -6294,7 +6455,7 @@ var routes = (app) => Effect38.gen(function* () {
         projectController.getProject({
           ...c.req.param(),
           ...c.req.valid("query")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6311,7 +6472,7 @@ var routes = (app) => Effect38.gen(function* () {
         c,
         projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6320,13 +6481,13 @@ var routes = (app) => Effect38.gen(function* () {
       c,
       projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect38.provide(runtime))
+      }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect38.provide(runtime))
+      sessionController.getSession({ ...c.req.param() }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).get(
@@ -6334,16 +6495,26 @@ var routes = (app) => Effect38.gen(function* () {
     async (c) => {
       const response = await effectToResponse(
         c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect38.provide(runtime))
+        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
-  ).get("/api/projects/:projectId/git/current-revisions", async (c) => {
+  ).get("/api/projects/:projectId/agent-sessions/:agentId", async (c) => {
+    const { projectId, agentId } = c.req.param();
+    const response = await effectToResponse(
+      c,
+      agentSessionController.getAgentSession({
+        projectId,
+        agentId
+      }).pipe(Effect41.provide(runtime))
+    );
+    return response;
+  }).get("/api/projects/:projectId/git/current-revisions", async (c) => {
     const response = await effectToResponse(
       c,
       gitController.getCurrentRevisions({
         ...c.req.param()
-      }).pipe(Effect38.provide(runtime))
+      }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).post(
@@ -6361,7 +6532,7 @@ var routes = (app) => Effect38.gen(function* () {
         gitController.getGitDiff({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6374,7 +6545,7 @@ var routes = (app) => Effect38.gen(function* () {
         gitController.commitFiles({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6387,7 +6558,7 @@ var routes = (app) => Effect38.gen(function* () {
         gitController.pushCommits({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6400,7 +6571,7 @@ var routes = (app) => Effect38.gen(function* () {
         gitController.commitAndPush({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6409,7 +6580,7 @@ var routes = (app) => Effect38.gen(function* () {
       c,
       claudeCodeController.getClaudeCommands({
         ...c.req.param()
-      })
+      }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/mcp/list", async (c) => {
@@ -6417,19 +6588,19 @@ var routes = (app) => Effect38.gen(function* () {
       c,
       claudeCodeController.getMcpListRoute({
         ...c.req.param()
-      }).pipe(Effect38.provide(runtime))
+      }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).get("/api/cc/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect38.provide(runtime))
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect41.provide(runtime))
     );
     return response;
   }).get("/api/cc/features", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect38.provide(runtime))
+      claudeCodeController.getAvailableFeatures().pipe(Effect41.provide(runtime))
     );
     return response;
   }).get("/api/cc/session-processes", async (c) => {
@@ -6473,7 +6644,7 @@ var routes = (app) => Effect38.gen(function* () {
         claudeCodeSessionProcessController.continueSessionProcess({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6482,7 +6653,7 @@ var routes = (app) => Effect38.gen(function* () {
     zValidator("json", z28.object({ projectId: z28.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
-      void Effect38.runFork(
+      void Effect41.runFork(
         claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
       return c.json({ message: "Task aborted" });
@@ -6510,7 +6681,7 @@ var routes = (app) => Effect38.gen(function* () {
       c,
       async (rawStream) => {
         await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect38.provide(TypeSafeSSE.make(rawStream)))
+          sseController.handleSSE(rawStream).pipe(Effect41.provide(TypeSafeSSE.make(rawStream)))
         );
       },
       async (err) => {
@@ -6520,7 +6691,7 @@ var routes = (app) => Effect38.gen(function* () {
   }).get("/api/scheduler/jobs", async (c) => {
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect38.provide(runtime))
+      schedulerController.getJobs().pipe(Effect41.provide(runtime))
     );
     return response;
   }).post(
@@ -6531,7 +6702,7 @@ var routes = (app) => Effect38.gen(function* () {
         c,
         schedulerController.addJob({
           job: c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6544,7 +6715,7 @@ var routes = (app) => Effect38.gen(function* () {
         schedulerController.updateJob({
           id: c.req.param("id"),
           job: c.req.valid("json")
-        }).pipe(Effect38.provide(runtime))
+        }).pipe(Effect41.provide(runtime))
       );
       return response;
     }
@@ -6553,7 +6724,7 @@ var routes = (app) => Effect38.gen(function* () {
       c,
       schedulerController.deleteJob({
         id: c.req.param("id")
-      }).pipe(Effect38.provide(runtime))
+      }).pipe(Effect41.provide(runtime))
     );
     return response;
   }).get(
@@ -6595,7 +6766,7 @@ var routes = (app) => Effect38.gen(function* () {
   ).get("/api/flags", async (c) => {
     const response = await effectToResponse(
       c,
-      featureFlagController.getFlags().pipe(Effect38.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect41.provide(runtime))
     );
     return response;
   });
@@ -6603,13 +6774,13 @@ var routes = (app) => Effect38.gen(function* () {
 
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer32 } from "effect";
-var platformLayer = Layer32.mergeAll(
+import { Layer as Layer35 } from "effect";
+var platformLayer = Layer35.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
   EnvService.Live
-).pipe(Layer32.provide(EnvService.Live), Layer32.provide(NodeContext.layer));
+).pipe(Layer35.provide(EnvService.Live), Layer35.provide(NodeContext.layer));
 
 // src/server/main.ts
 var isDevelopment = process.env.NODE_ENV === "development";
@@ -6632,42 +6803,44 @@ if (!isDevelopment) {
 }
 var program = routes(honoApp).pipe(
   /** Presentation */
-  Effect39.provide(ProjectController.Live),
-  Effect39.provide(SessionController.Live),
-  Effect39.provide(GitController.Live),
-  Effect39.provide(ClaudeCodeController.Live),
-  Effect39.provide(ClaudeCodeSessionProcessController.Live),
-  Effect39.provide(ClaudeCodePermissionController.Live),
-  Effect39.provide(FileSystemController.Live),
-  Effect39.provide(SSEController.Live),
-  Effect39.provide(SchedulerController.Live),
-  Effect39.provide(FeatureFlagController.Live)
+  Effect42.provide(ProjectController.Live),
+  Effect42.provide(SessionController.Live),
+  Effect42.provide(AgentSessionController.Live),
+  Effect42.provide(GitController.Live),
+  Effect42.provide(ClaudeCodeController.Live),
+  Effect42.provide(ClaudeCodeSessionProcessController.Live),
+  Effect42.provide(ClaudeCodePermissionController.Live),
+  Effect42.provide(FileSystemController.Live),
+  Effect42.provide(SSEController.Live),
+  Effect42.provide(SchedulerController.Live),
+  Effect42.provide(FeatureFlagController.Live)
 ).pipe(
   /** Application */
-  Effect39.provide(InitializeService.Live),
-  Effect39.provide(FileWatcherService.Live)
+  Effect42.provide(InitializeService.Live),
+  Effect42.provide(FileWatcherService.Live)
 ).pipe(
   /** Domain */
-  Effect39.provide(ClaudeCodeLifeCycleService.Live),
-  Effect39.provide(ClaudeCodePermissionService.Live),
-  Effect39.provide(ClaudeCodeSessionProcessService.Live),
-  Effect39.provide(ClaudeCodeService.Live),
-  Effect39.provide(GitService.Live),
-  Effect39.provide(SchedulerService.Live),
-  Effect39.provide(SchedulerConfigBaseDir.Live)
+  Effect42.provide(ClaudeCodeLifeCycleService.Live),
+  Effect42.provide(ClaudeCodePermissionService.Live),
+  Effect42.provide(ClaudeCodeSessionProcessService.Live),
+  Effect42.provide(ClaudeCodeService.Live),
+  Effect42.provide(GitService.Live),
+  Effect42.provide(SchedulerService.Live),
+  Effect42.provide(SchedulerConfigBaseDir.Live)
 ).pipe(
   /** Infrastructure */
-  Effect39.provide(ProjectRepository.Live),
-  Effect39.provide(SessionRepository.Live),
-  Effect39.provide(ProjectMetaService.Live),
-  Effect39.provide(SessionMetaService.Live),
-  Effect39.provide(VirtualConversationDatabase.Live)
+  Effect42.provide(ProjectRepository.Live),
+  Effect42.provide(SessionRepository.Live),
+  Effect42.provide(ProjectMetaService.Live),
+  Effect42.provide(SessionMetaService.Live),
+  Effect42.provide(VirtualConversationDatabase.Live),
+  Effect42.provide(AgentSessionLayer)
 ).pipe(
   /** Platform */
-  Effect39.provide(platformLayer),
-  Effect39.provide(NodeContext2.layer)
+  Effect42.provide(platformLayer),
+  Effect42.provide(NodeContext2.layer)
 );
-await Effect39.runPromise(program);
+await Effect42.runPromise(program);
 var port = isDevelopment ? (
   // biome-ignore lint/style/noProcessEnv: allow only here
   process.env.DEV_BE_PORT ?? "3401"