@kimuson/claude-code-viewer 0.5.5 → 0.5.6

package/dist/main.js

@@ -7,7 +7,7 @@ import { Effect as Effect49 } from "effect";
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.5.5",
+  version: "0.5.6",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -229,7 +229,7 @@ import { FileSystem, Path } from "@effect/platform";
 import { Context, Effect as Effect2, Layer } from "effect";
 
 // src/lib/conversation-schema/index.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/lib/conversation-schema/entry/AssistantEntrySchema.ts
 import { z as z8 } from "zod";
@@ -336,7 +336,8 @@ var BaseEntrySchema = z7.object({
   toolUseResult: z7.unknown().optional(),
   // スキーマがツールごとに異なりすぎるし利用もしなそうなので unknown
   gitBranch: z7.string().optional(),
-  isCompactSummary: z7.boolean().optional()
+  isCompactSummary: z7.boolean().optional(),
+  agentId: z7.string().optional()
 });
 
 // src/lib/conversation-schema/entry/AssistantEntrySchema.ts
@@ -365,156 +366,203 @@ var FileHistorySnapshotEntrySchema = z9.object({
   isSnapshotUpdate: z9.boolean()
 });
 
+// src/lib/conversation-schema/entry/ProgressEntrySchema.ts
+import { z as z10 } from "zod";
+var ProgressEntrySchema = BaseEntrySchema.extend({
+  // discriminator
+  type: z10.literal("progress"),
+  // required
+  data: z10.record(z10.string(), z10.any()),
+  toolUseID: z10.string().optional(),
+  parentToolUseID: z10.string().optional()
+});
+
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-import { z as z11 } from "zod";
+import { z as z12 } 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()
+import { z as z11 } from "zod";
+var DocumentContentSchema = z11.object({
+  type: z11.literal("document"),
+  source: z11.union([
+    z11.object({
+      media_type: z11.literal("text/plain"),
+      type: z11.literal("text"),
+      data: z11.string()
     }),
-    z10.object({
-      media_type: z10.enum(["application/pdf"]),
-      type: z10.literal("base64"),
-      data: z10.string()
+    z11.object({
+      media_type: z11.enum(["application/pdf"]),
+      type: z11.literal("base64"),
+      data: z11.string()
     })
   ])
 });
 
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-var QueueOperationContentSchema = z11.union([
-  z11.string(),
+var QueueOperationContentSchema = z12.union([
+  z12.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]))
+var QueueOperationEntrySchema = z12.union([
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("enqueue"),
+    content: z12.union([
+      z12.string(),
+      z12.array(z12.union([z12.string(), QueueOperationContentSchema]))
     ]),
-    sessionId: z11.string(),
-    timestamp: z11.iso.datetime()
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime()
   }),
-  z11.object({
-    type: z11.literal("queue-operation"),
-    operation: z11.literal("dequeue"),
-    sessionId: z11.string(),
-    timestamp: z11.iso.datetime()
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("dequeue"),
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime()
   }),
-  z11.object({
-    type: z11.literal("queue-operation"),
-    operation: z11.literal("remove"),
-    sessionId: z11.string(),
-    timestamp: z11.iso.datetime()
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("remove"),
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime()
   }),
-  z11.object({
-    type: z11.literal("queue-operation"),
-    operation: z11.literal("popAll"),
-    sessionId: z11.string(),
-    timestamp: z11.iso.datetime(),
-    content: z11.string().optional()
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("popAll"),
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime(),
+    content: z12.string().optional()
   })
 ]);
 
 // 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()
+import { z as z13 } from "zod";
+var SummaryEntrySchema = z13.object({
+  type: z13.literal("summary"),
+  summary: z13.string(),
+  leafUuid: z13.string().uuid()
 });
 
 // src/lib/conversation-schema/entry/SystemEntrySchema.ts
-import { z as z13 } from "zod";
-var HookInfoSchema = z13.object({
-  command: z13.string()
+import { z as z14 } from "zod";
+var HookInfoSchema = z14.object({
+  command: z14.string()
 });
 var SystemEntryWithContentSchema = BaseEntrySchema.extend({
-  type: z13.literal("system"),
-  content: z13.string(),
-  toolUseID: z13.string(),
-  level: z13.enum(["info"]),
-  subtype: z13.undefined().optional()
+  type: z14.literal("system"),
+  content: z14.string(),
+  toolUseID: z14.string(),
+  level: z14.enum(["info"]),
+  subtype: z14.undefined().optional()
 });
 var StopHookSummaryEntrySchema = BaseEntrySchema.extend({
-  type: z13.literal("system"),
-  subtype: z13.literal("stop_hook_summary"),
-  toolUseID: z13.string(),
-  level: z13.enum(["info", "suggestion"]),
-  slug: z13.string().optional(),
-  hookCount: z13.number(),
-  hookInfos: z13.array(HookInfoSchema),
-  hookErrors: z13.array(z13.unknown()),
-  preventedContinuation: z13.boolean(),
-  stopReason: z13.string(),
-  hasOutput: z13.boolean()
+  type: z14.literal("system"),
+  subtype: z14.literal("stop_hook_summary"),
+  toolUseID: z14.string(),
+  level: z14.enum(["info", "suggestion"]),
+  slug: z14.string().optional(),
+  hookCount: z14.number(),
+  hookInfos: z14.array(HookInfoSchema),
+  hookErrors: z14.array(z14.unknown()),
+  preventedContinuation: z14.boolean(),
+  stopReason: z14.string(),
+  hasOutput: z14.boolean()
 });
 var LocalCommandEntrySchema = BaseEntrySchema.extend({
-  type: z13.literal("system"),
-  subtype: z13.literal("local_command"),
-  content: z13.string(),
-  level: z13.enum(["info"])
+  type: z14.literal("system"),
+  subtype: z14.literal("local_command"),
+  content: z14.string(),
+  level: z14.enum(["info"])
 });
 var TurnDurationEntrySchema = BaseEntrySchema.extend({
-  type: z13.literal("system"),
-  subtype: z13.literal("turn_duration"),
-  durationMs: z13.number(),
-  slug: z13.string().optional()
+  type: z14.literal("system"),
+  subtype: z14.literal("turn_duration"),
+  durationMs: z14.number(),
+  slug: z14.string().optional()
+});
+var CompactBoundaryEntrySchema = BaseEntrySchema.extend({
+  type: z14.literal("system"),
+  subtype: z14.literal("compact_boundary"),
+  content: z14.string(),
+  level: z14.enum(["info"]),
+  slug: z14.string().optional(),
+  logicalParentUuid: z14.string().optional(),
+  compactMetadata: z14.object({
+    trigger: z14.string(),
+    preTokens: z14.number()
+  }).optional()
+});
+var ApiErrorEntrySchema = BaseEntrySchema.extend({
+  type: z14.literal("system"),
+  subtype: z14.literal("api_error"),
+  level: z14.enum(["error", "warning", "info"]),
+  error: z14.object({
+    status: z14.number().optional(),
+    headers: z14.record(z14.string(), z14.unknown()).optional(),
+    requestID: z14.string().nullable().optional(),
+    error: z14.object({
+      type: z14.string(),
+      error: z14.object({
+        type: z14.string(),
+        message: z14.string()
+      }).optional(),
+      message: z14.string().optional()
+    }).optional()
+  }),
+  retryInMs: z14.number().optional(),
+  retryAttempt: z14.number().optional(),
+  maxRetries: z14.number().optional()
 });
-var SystemEntrySchema = z13.union([
+var SystemEntrySchema = z14.union([
   StopHookSummaryEntrySchema,
   LocalCommandEntrySchema,
   TurnDurationEntrySchema,
+  CompactBoundaryEntrySchema,
+  ApiErrorEntrySchema,
   SystemEntryWithContentSchema
   // Must be last (catch-all for undefined subtype)
 ]);
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/lib/conversation-schema/message/UserMessageSchema.ts
-import { z as z14 } from "zod";
-var UserMessageContentSchema = z14.union([
-  z14.string(),
+import { z as z15 } from "zod";
+var UserMessageContentSchema = z15.union([
+  z15.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]))
+var UserMessageSchema = z15.object({
+  role: z15.literal("user"),
+  content: z15.union([
+    z15.string(),
+    z15.array(z15.union([z15.string(), UserMessageContentSchema]))
   ])
 });
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
 var UserEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z15.literal("user"),
+  type: z16.literal("user"),
   // required
   message: UserMessageSchema
 });
 
 // src/lib/conversation-schema/index.ts
-var ConversationSchema = z16.union([
+var ConversationSchema = z17.union([
   UserEntrySchema,
   AssistantEntrySchema,
   SummaryEntrySchema,
   SystemEntrySchema,
   FileHistorySnapshotEntrySchema,
-  QueueOperationEntrySchema
+  QueueOperationEntrySchema,
+  ProgressEntrySchema
 ]);
 
 // src/server/core/claude-code/functions/parseJsonl.ts
@@ -550,8 +598,20 @@ var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
 var LayerImpl = Effect2.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const getAgentSessionByAgentId = (projectId, agentId) => Effect2.gen(function* () {
+  const getAgentSessionByAgentId = (projectId, agentId, sessionId) => Effect2.gen(function* () {
     const projectPath = decodeProjectId(projectId);
+    if (sessionId) {
+      const newPath = path.resolve(
+        projectPath,
+        sessionId,
+        "subagents",
+        `agent-${agentId}.jsonl`
+      );
+      if (yield* fs.exists(newPath)) {
+        const content2 = yield* fs.readFileString(newPath);
+        return parseJsonl(content2);
+      }
+    }
     const agentFilePath = path.resolve(projectPath, `agent-${agentId}.jsonl`);
     const exists = yield* fs.exists(agentFilePath);
     if (!exists) {
@@ -578,10 +638,11 @@ import { Context as Context2, Effect as Effect3, Layer as Layer2 } from "effect"
 var LayerImpl2 = Effect3.gen(function* () {
   const repository = yield* AgentSessionRepository;
   const getAgentSession = (params) => Effect3.gen(function* () {
-    const { projectId, agentId } = params;
+    const { projectId, agentId, sessionId } = params;
     const conversations = yield* repository.getAgentSessionByAgentId(
       projectId,
-      agentId
+      agentId,
+      sessionId
     );
     if (conversations === null) {
       return {
@@ -707,7 +768,7 @@ import { Context as Context7, Effect as Effect9, Layer as Layer9, Option as Opti
 // src/server/core/project/services/ProjectMetaService.ts
 import { FileSystem as FileSystem3, Path as Path4 } from "@effect/platform";
 import { Context as Context6, Effect as Effect8, Layer as Layer8, Option, Ref as Ref3 } from "effect";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/server/lib/storage/FileCacheStorage/index.ts
 import { Context as Context5, Effect as Effect7, Layer as Layer7, Ref as Ref2, Runtime } from "effect";
@@ -715,7 +776,7 @@ import { Context as Context5, Effect as Effect7, Layer as Layer7, Ref as Ref2, R
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
 import { FileSystem as FileSystem2, Path as Path3 } from "@effect/platform";
 import { Context as Context4, Effect as Effect6, Layer as Layer6 } from "effect";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/server/lib/config/paths.ts
 import { homedir as homedir2 } from "node:os";
@@ -727,7 +788,7 @@ var claudeCodeViewerCacheDirPath = resolve(
 );
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
-var saveSchema = z17.array(z17.tuple([z17.string(), z17.unknown()]));
+var saveSchema = z18.array(z18.tuple([z18.string(), z18.unknown()]));
 var LayerImpl5 = Effect6.gen(function* () {
   const path = yield* Path3.Path;
   const getCacheFilePath = (key) => path.resolve(claudeCodeViewerCacheDirPath, `${key}.json`);
@@ -840,7 +901,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
 );
 
 // src/server/core/project/services/ProjectMetaService.ts
-var ProjectPathSchema = z18.string().nullable();
+var ProjectPathSchema = z19.string().nullable();
 var LayerImpl6 = Effect8.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path4.Path;
@@ -1102,12 +1163,12 @@ var scanSkillFilesRecursively = (dirPath) => Effect10.gen(function* () {
 });
 
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-var versionSchema = z19.object({
-  major: z19.string().transform((value) => Number.parseInt(value, 10)),
-  minor: z19.string().transform((value) => Number.parseInt(value, 10)),
-  patch: z19.string().transform((value) => Number.parseInt(value, 10))
+var versionSchema = z20.object({
+  major: z20.string().transform((value) => Number.parseInt(value, 10)),
+  minor: z20.string().transform((value) => Number.parseInt(value, 10)),
+  patch: z20.string().transform((value) => Number.parseInt(value, 10))
 }).refine(
   (data) => [data.major, data.minor, data.patch].every((value) => !Number.isNaN(value))
 );
@@ -1745,26 +1806,26 @@ import { FileSystem as FileSystem9, Path as Path11 } from "@effect/platform";
 import { Context as Context16, Effect as Effect21, Layer as Layer18, Option as Option3 } from "effect";
 
 // src/server/core/claude-code/functions/parseUserMessage.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var regExp = /<(?<tag>[^>]+)>(?<content>\s*[^<]*?\s*)<\/\k<tag>>/g;
-var matchSchema = z20.object({
-  tag: z20.string(),
-  content: z20.string()
+var matchSchema = z21.object({
+  tag: z21.string(),
+  content: z21.string()
 });
-var parsedUserMessageSchema = z20.union([
-  z20.object({
-    kind: z20.literal("command"),
-    commandName: z20.string(),
-    commandArgs: z20.string().optional(),
-    commandMessage: z20.string().optional()
+var parsedUserMessageSchema = z21.union([
+  z21.object({
+    kind: z21.literal("command"),
+    commandName: z21.string(),
+    commandArgs: z21.string().optional(),
+    commandMessage: z21.string().optional()
   }),
-  z20.object({
-    kind: z20.literal("local-command"),
-    stdout: z20.string()
+  z21.object({
+    kind: z21.literal("local-command"),
+    stdout: z21.string()
   }),
-  z20.object({
-    kind: z20.literal("text"),
-    content: z20.string()
+  z21.object({
+    kind: z21.literal("text"),
+    content: z21.string()
   })
 ]);
 var parseUserMessage = (content) => {
@@ -2059,36 +2120,53 @@ import { Effect as Effect19 } from "effect";
 var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect19.gen(function* () {
   const fs = yield* FileSystem7.FileSystem;
   const path = yield* Path9.Path;
-  const entries = yield* fs.readDirectory(projectPath);
-  const agentFiles = entries.filter(
-    (filename) => filename.startsWith("agent-") && filename.endsWith(".jsonl")
-  );
-  const matchingFilePaths = [];
-  for (const agentFile of agentFiles) {
-    const filePath = path.join(projectPath, agentFile);
-    const maybeMatches = yield* Effect19.gen(function* () {
-      const content = yield* fs.readFileString(filePath);
-      const firstLine = content.split("\n")[0];
-      if (!firstLine || firstLine.trim() === "") {
+  const isValidAgentFile = (filePath, expectedSessionId) => Effect19.gen(function* () {
+    const content = yield* fs.readFileString(filePath);
+    const firstLine = content.split("\n")[0];
+    if (!firstLine || firstLine.trim() === "") {
+      return false;
+    }
+    try {
+      const firstLineData = JSON.parse(firstLine);
+      if (typeof firstLineData !== "object" || firstLineData === null) {
         return false;
       }
-      try {
-        const firstLineData = JSON.parse(firstLine);
-        if (typeof firstLineData === "object" && firstLineData !== null && "sessionId" in firstLineData && firstLineData.sessionId === sessionId) {
-          return true;
-        }
-      } catch {
-        return false;
+      if (expectedSessionId !== void 0) {
+        return "sessionId" in firstLineData && firstLineData.sessionId === expectedSessionId;
       }
+      return "sessionId" in firstLineData;
+    } catch {
       return false;
-    }).pipe(
-      Effect19.catchAll(() => Effect19.succeed(false))
-      // On any error, skip this file
-    );
-    if (maybeMatches) {
+    }
+  }).pipe(Effect19.catchAll(() => Effect19.succeed(false)));
+  const matchingFilePaths = [];
+  const rootEntries = yield* fs.readDirectory(projectPath);
+  const rootAgentFiles = rootEntries.filter(
+    (filename) => filename.startsWith("agent-") && filename.endsWith(".jsonl")
+  );
+  for (const agentFile of rootAgentFiles) {
+    const filePath = path.join(projectPath, agentFile);
+    if (yield* isValidAgentFile(filePath, sessionId)) {
       matchingFilePaths.push(filePath);
     }
   }
+  const subagentsDir = path.join(projectPath, sessionId, "subagents");
+  const subagentsDirExists = yield* fs.exists(subagentsDir);
+  if (subagentsDirExists) {
+    const subagentEntries = yield* fs.readDirectory(subagentsDir).pipe(
+      Effect19.catchAll(() => Effect19.succeed([]))
+      // Handle permission or other errors gracefully
+    );
+    const subagentFiles = subagentEntries.filter(
+      (filename) => filename.startsWith("agent-") && filename.endsWith(".jsonl")
+    );
+    for (const agentFile of subagentFiles) {
+      const filePath = path.join(subagentsDir, agentFile);
+      if (yield* isValidAgentFile(filePath, void 0)) {
+        matchingFilePaths.push(filePath);
+      }
+    }
+  }
   return matchingFilePaths;
 });
 
@@ -2219,7 +2297,7 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
             }
           }
           const fileContents = [content, ...agentContents];
-          const { totalCost } = aggregateTokenUsageAndCost(fileContents);
+          const { totalCost, modelName } = aggregateTokenUsageAndCost(fileContents);
           const sessionMeta = {
             messageCount: lines.length,
             firstUserMessage,
@@ -2227,7 +2305,8 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
               totalUsd: totalCost.totalUsd,
               breakdown: totalCost.breakdown,
               tokenUsage: totalCost.tokenUsage
-            }
+            },
+            modelName
           };
           yield* Ref7.update(sessionMetaCacheRef, (cache) => {
             cache.set(sessionId, sessionMeta);
@@ -2333,7 +2412,8 @@ var LayerImpl13 = Effect21.gen(function* () {
               cacheCreationTokens: 0,
               cacheReadTokens: 0
             }
-          }
+          },
+          modelName: null
         },
         conversations: virtualConversation.conversations,
         lastModifiedAt: lastConversation !== void 0 ? new Date(lastConversation.timestamp) : /* @__PURE__ */ new Date()
@@ -2449,7 +2529,8 @@ var LayerImpl13 = Effect21.gen(function* () {
               cacheCreationTokens: 0,
               cacheReadTokens: 0
             }
-          }
+          },
+          modelName: null
         }
       };
     }).sort((a, b) => {
@@ -3019,6 +3100,10 @@ var LayerImpl15 = Effect24.gen(function* () {
         baseSessionId,
         [virtualConversation]
       );
+      yield* eventBusService.emit("virtualConversationUpdated", {
+        projectId: sessionProcess.def.projectId,
+        sessionId: baseSessionId
+      });
       sessionProcess.def.setNextMessage(input);
       return {
         sessionProcess,
@@ -3072,7 +3157,7 @@ var LayerImpl15 = Effect24.gen(function* () {
           return "break";
         }
         if (processState.type === "paused") {
-          yield* Effect24.die(
+          return yield* Effect24.die(
             new Error("Illegal state: paused is not expected")
           );
         }
@@ -3125,6 +3210,10 @@ var LayerImpl15 = Effect24.gen(function* () {
           sessionFileCreatedPromise.resolve({
             sessionId: message.session_id
           });
+          yield* eventBusService.emit("virtualConversationUpdated", {
+            projectId: processState.def.projectId,
+            sessionId: message.session_id
+          });
           yield* virtualConversationDatabase.deleteVirtualConversations(
             message.session_id
           );
@@ -3481,12 +3570,24 @@ var LayerImpl17 = Effect27.gen(function* () {
         })
       );
     };
+    const onVirtualConversationUpdated = (event) => {
+      Effect27.runFork(
+        typeSafeSSE.writeSSE("virtualConversationUpdated", {
+          projectId: event.projectId,
+          sessionId: event.sessionId
+        })
+      );
+    };
     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);
+    yield* eventBus.on(
+      "virtualConversationUpdated",
+      onVirtualConversationUpdated
+    );
     const { connectionPromise } = adaptInternalEventToSSE(rawStream, {
       timeout: 5 * 60 * 1e3,
       cleanUp: async () => {
@@ -3501,6 +3602,10 @@ var LayerImpl17 = Effect27.gen(function* () {
             );
             yield* eventBus.off("heartbeat", onHeartbeat);
             yield* eventBus.off("permissionRequested", onPermissionRequested);
+            yield* eventBus.off(
+              "virtualConversationUpdated",
+              onVirtualConversationUpdated
+            );
           })
         );
       }
@@ -3523,16 +3628,16 @@ import { Path as Path12 } from "@effect/platform";
 import { Context as Context22, Effect as Effect28, Layer as Layer24, Ref as Ref9 } from "effect";
 
 // src/server/core/events/functions/parseSessionFilePath.ts
-import z21 from "zod";
+import z22 from "zod";
 var sessionFileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl$/;
 var agentFileRegExp = /(?<projectId>.*?)\/agent-(?<agentSessionId>.*?)\.jsonl$/;
-var sessionFileGroupSchema = z21.object({
-  projectId: z21.string(),
-  sessionId: z21.string()
+var sessionFileGroupSchema = z22.object({
+  projectId: z22.string(),
+  sessionId: z22.string()
 });
-var agentFileGroupSchema = z21.object({
-  projectId: z21.string(),
-  agentSessionId: z21.string()
+var agentFileGroupSchema = z22.object({
+  projectId: z22.string(),
+  agentSessionId: z22.string()
 });
 var parseSessionFilePath = (filePath) => {
   const agentMatch = filePath.match(agentFileRegExp);
@@ -3630,7 +3735,7 @@ var FileWatcherService = class extends Context22.Tag("FileWatcherService")() {
                             yield* Ref9.set(debounceTimersRef, currentTimers);
                           })
                         );
-                      }, 300);
+                      }, 100);
                       timers.set(debounceKey, newTimer);
                       yield* Ref9.set(debounceTimersRef, timers);
                     })
@@ -4267,12 +4372,12 @@ import { Context as Context26, Data as Data4, Duration, Effect as Effect32, Eith
 import { Context as Context25, Effect as Effect31, Layer as Layer27, Ref as Ref10 } from "effect";
 
 // src/server/core/platform/schema.ts
-import { z as z22 } from "zod";
-var envSchema = z22.object({
+import { z as z23 } from "zod";
+var envSchema = z23.object({
   // Frameworks
-  NODE_ENV: z22.enum(["development", "production", "test"]).optional().default("development"),
-  NEXT_PHASE: z22.string().optional(),
-  PATH: z22.string().optional()
+  NODE_ENV: z23.enum(["development", "production", "test"]).optional().default("development"),
+  NEXT_PHASE: z23.string().optional(),
+  PATH: z23.string().optional()
 });
 
 // src/server/core/platform/services/EnvService.ts
@@ -5144,39 +5249,39 @@ import { FileSystem as FileSystem12, Path as Path16 } from "@effect/platform";
 import { Context as Context29, Data as Data5, Effect as Effect36, Layer as Layer31 } from "effect";
 
 // src/server/core/scheduler/schema.ts
-import { z as z23 } from "zod";
-var concurrencyPolicySchema = z23.enum(["skip", "run"]);
-var cronScheduleSchema = z23.object({
-  type: z23.literal("cron"),
-  expression: z23.string(),
+import { z as z24 } from "zod";
+var concurrencyPolicySchema = z24.enum(["skip", "run"]);
+var cronScheduleSchema = z24.object({
+  type: z24.literal("cron"),
+  expression: z24.string(),
   concurrencyPolicy: concurrencyPolicySchema
 });
-var reservedScheduleSchema = z23.object({
-  type: z23.literal("reserved"),
-  reservedExecutionTime: z23.iso.datetime()
+var reservedScheduleSchema = z24.object({
+  type: z24.literal("reserved"),
+  reservedExecutionTime: z24.iso.datetime()
 });
-var scheduleSchema = z23.discriminatedUnion("type", [
+var scheduleSchema = z24.discriminatedUnion("type", [
   cronScheduleSchema,
   reservedScheduleSchema
 ]);
-var messageConfigSchema = z23.object({
-  content: z23.string(),
-  projectId: z23.string(),
-  baseSessionId: z23.string().nullable()
+var messageConfigSchema = z24.object({
+  content: z24.string(),
+  projectId: z24.string(),
+  baseSessionId: z24.string().nullable()
 });
-var jobStatusSchema = z23.enum(["success", "failed"]);
-var schedulerJobSchema = z23.object({
-  id: z23.string(),
-  name: z23.string(),
+var jobStatusSchema = z24.enum(["success", "failed"]);
+var schedulerJobSchema = z24.object({
+  id: z24.string(),
+  name: z24.string(),
   schedule: scheduleSchema,
   message: messageConfigSchema,
-  enabled: z23.boolean(),
-  createdAt: z23.string().datetime(),
-  lastRunAt: z23.string().datetime().nullable(),
+  enabled: z24.boolean(),
+  createdAt: z24.string().datetime(),
+  lastRunAt: z24.string().datetime().nullable(),
   lastRunStatus: jobStatusSchema.nullable()
 });
-var schedulerConfigSchema = z23.object({
-  jobs: z23.array(schedulerJobSchema)
+var schedulerConfigSchema = z24.object({
+  jobs: z24.array(schedulerJobSchema)
 });
 var newSchedulerJobSchema = schedulerJobSchema.omit({
   id: true,
@@ -5184,7 +5289,7 @@ var newSchedulerJobSchema = schedulerJobSchema.omit({
   lastRunAt: true,
   lastRunStatus: true
 }).extend({
-  enabled: z23.boolean().default(true)
+  enabled: z24.boolean().default(true)
 });
 var updateSchedulerJobSchema = schedulerJobSchema.partial().pick({
   name: true,
@@ -6847,65 +6952,65 @@ import { Effect as Effect47, Runtime as Runtime3 } from "effect";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // src/server/core/claude-code/schema.ts
-import { z as z24 } from "zod";
-var mediaTypeSchema = z24.enum([
+import { z as z25 } from "zod";
+var mediaTypeSchema = z25.enum([
   "image/png",
   "image/jpeg",
   "image/gif",
   "image/webp"
 ]);
-var imageBlockSchema = z24.object({
-  type: z24.literal("image"),
-  source: z24.object({
-    type: z24.literal("base64"),
+var imageBlockSchema = z25.object({
+  type: z25.literal("image"),
+  source: z25.object({
+    type: z25.literal("base64"),
     media_type: mediaTypeSchema,
-    data: z24.string()
+    data: z25.string()
   })
 });
-var documentBlockSchema = z24.object({
-  type: z24.literal("document"),
-  source: z24.union([
-    z24.object({
-      type: z24.literal("text"),
-      media_type: z24.enum(["text/plain"]),
-      data: z24.string()
+var documentBlockSchema = z25.object({
+  type: z25.literal("document"),
+  source: z25.union([
+    z25.object({
+      type: z25.literal("text"),
+      media_type: z25.enum(["text/plain"]),
+      data: z25.string()
     }),
-    z24.object({
-      type: z24.literal("base64"),
-      media_type: z24.enum(["application/pdf"]),
-      data: z24.string()
+    z25.object({
+      type: z25.literal("base64"),
+      media_type: z25.enum(["application/pdf"]),
+      data: z25.string()
     })
   ])
 });
-var userMessageInputSchema = z24.object({
-  text: z24.string().min(1),
-  images: z24.array(imageBlockSchema).optional(),
-  documents: z24.array(documentBlockSchema).optional()
+var userMessageInputSchema = z25.object({
+  text: z25.string().min(1),
+  images: z25.array(imageBlockSchema).optional(),
+  documents: z25.array(documentBlockSchema).optional()
 });
 
 // src/server/core/git/schema.ts
-import { z as z25 } from "zod";
-var CommitRequestSchema = z25.object({
-  projectId: z25.string().min(1),
-  files: z25.array(z25.string().min(1)).min(1),
-  message: z25.string().trim().min(1)
+import { z as z26 } from "zod";
+var CommitRequestSchema = z26.object({
+  projectId: z26.string().min(1),
+  files: z26.array(z26.string().min(1)).min(1),
+  message: z26.string().trim().min(1)
 });
-var PushRequestSchema = z25.object({
-  projectId: z25.string().min(1)
+var PushRequestSchema = z26.object({
+  projectId: z26.string().min(1)
 });
-var CommitResultSuccessSchema = z25.object({
-  success: z25.literal(true),
-  commitSha: z25.string().length(40),
-  filesCommitted: z25.number().int().positive(),
-  message: z25.string()
+var CommitResultSuccessSchema = z26.object({
+  success: z26.literal(true),
+  commitSha: z26.string().length(40),
+  filesCommitted: z26.number().int().positive(),
+  message: z26.string()
 });
-var CommitResultErrorSchema = z25.object({
-  success: z25.literal(false),
-  error: z25.string(),
-  errorCode: z25.enum([
+var CommitResultErrorSchema = z26.object({
+  success: z26.literal(false),
+  error: z26.string(),
+  errorCode: z26.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -6913,22 +7018,22 @@ var CommitResultErrorSchema = z25.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z25.string().optional()
+  details: z26.string().optional()
 });
-var CommitResultSchema = z25.discriminatedUnion("success", [
+var CommitResultSchema = z26.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z25.object({
-  success: z25.literal(true),
-  remote: z25.string(),
-  branch: z25.string(),
-  objectsPushed: z25.number().int().optional()
+var PushResultSuccessSchema = z26.object({
+  success: z26.literal(true),
+  remote: z26.string(),
+  branch: z26.string(),
+  objectsPushed: z26.number().int().optional()
 });
-var PushResultErrorSchema = z25.object({
-  success: z25.literal(false),
-  error: z25.string(),
-  errorCode: z25.enum([
+var PushResultErrorSchema = z26.object({
+  success: z26.literal(false),
+  error: z26.string(),
+  errorCode: z26.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -6938,26 +7043,26 @@ var PushResultErrorSchema = z25.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z25.string().optional()
+  details: z26.string().optional()
 });
-var PushResultSchema = z25.discriminatedUnion("success", [
+var PushResultSchema = z26.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z25.object({
-  success: z25.literal(true),
-  commitSha: z25.string().length(40),
-  filesCommitted: z25.number().int().positive(),
-  message: z25.string(),
-  remote: z25.string(),
-  branch: z25.string()
+var CommitAndPushResultSuccessSchema = z26.object({
+  success: z26.literal(true),
+  commitSha: z26.string().length(40),
+  filesCommitted: z26.number().int().positive(),
+  message: z26.string(),
+  remote: z26.string(),
+  branch: z26.string()
 });
-var CommitAndPushResultErrorSchema = z25.object({
-  success: z25.literal(false),
-  commitSucceeded: z25.boolean(),
-  commitSha: z25.string().length(40).optional(),
-  error: z25.string(),
-  errorCode: z25.enum([
+var CommitAndPushResultErrorSchema = z26.object({
+  success: z26.literal(false),
+  commitSucceeded: z26.boolean(),
+  commitSha: z26.string().length(40).optional(),
+  error: z26.string(),
+  errorCode: z26.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -6970,29 +7075,29 @@ var CommitAndPushResultErrorSchema = z25.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z25.string().optional()
+  details: z26.string().optional()
 });
-var CommitAndPushResultSchema = z25.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z26.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
 
 // src/server/lib/config/config.ts
-import z27 from "zod";
+import z28 from "zod";
 
 // src/lib/i18n/schema.ts
-import z26 from "zod";
-var localeSchema = z26.enum(["ja", "en", "zh_CN"]);
+import z27 from "zod";
+var localeSchema = z27.enum(["ja", "en", "zh_CN"]);
 
 // src/server/lib/config/config.ts
-var userConfigSchema = z27.object({
-  hideNoUserMessageSession: z27.boolean().optional().default(true),
-  unifySameTitleSession: z27.boolean().optional().default(false),
-  enterKeyBehavior: z27.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
-  permissionMode: z27.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
+var userConfigSchema = z28.object({
+  hideNoUserMessageSession: z28.boolean().optional().default(true),
+  unifySameTitleSession: z28.boolean().optional().default(false),
+  enterKeyBehavior: z28.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+  permissionMode: z28.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
   locale: localeSchema.optional().default("en"),
-  theme: z27.enum(["light", "dark", "system"]).optional().default("system"),
-  searchHotkey: z27.enum(["ctrl-k", "command-k"]).optional().default("command-k")
+  theme: z28.enum(["light", "dark", "system"]).optional().default("system"),
+  searchHotkey: z28.enum(["ctrl-k", "command-k"]).optional().default("command-k")
 });
 var defaultUserConfig = userConfigSchema.parse({});
 
@@ -7079,7 +7184,7 @@ var routes = (app, options) => Effect47.gen(function* () {
     await next();
   }).post(
     "/api/auth/login",
-    zValidator("json", z28.object({ password: z28.string() })),
+    zValidator("json", z29.object({ password: z29.string() })),
     async (c) => {
       const { password } = c.req.valid("json");
       if (!authEnabled) {
@@ -7133,7 +7238,7 @@ var routes = (app, options) => Effect47.gen(function* () {
     return response;
   }).get(
     "/api/projects/:projectId",
-    zValidator("query", z28.object({ cursor: z28.string().optional() })),
+    zValidator("query", z29.object({ cursor: z29.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
@@ -7148,8 +7253,8 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/projects",
     zValidator(
       "json",
-      z28.object({
-        projectPath: z28.string().min(1, "Project path is required")
+      z29.object({
+        projectPath: z29.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -7184,17 +7289,23 @@ var routes = (app, options) => Effect47.gen(function* () {
       );
       return response;
     }
-  ).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(Effect47.provide(runtime))
-    );
-    return response;
-  }).get("/api/projects/:projectId/git/current-revisions", async (c) => {
+  ).get(
+    "/api/projects/:projectId/agent-sessions/:agentId",
+    zValidator("query", z29.object({ sessionId: z29.string().optional() })),
+    async (c) => {
+      const { projectId, agentId } = c.req.param();
+      const { sessionId } = c.req.valid("query");
+      const response = await effectToResponse(
+        c,
+        agentSessionController.getAgentSession({
+          projectId,
+          agentId,
+          sessionId
+        }).pipe(Effect47.provide(runtime))
+      );
+      return response;
+    }
+  ).get("/api/projects/:projectId/git/current-revisions", async (c) => {
     const response = await effectToResponse(
       c,
       gitController.getCurrentRevisions({
@@ -7206,9 +7317,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/projects/:projectId/git/diff",
     zValidator(
       "json",
-      z28.object({
-        fromRef: z28.string().min(1, "fromRef is required"),
-        toRef: z28.string().min(1, "toRef is required")
+      z29.object({
+        fromRef: z29.string().min(1, "fromRef is required"),
+        toRef: z29.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -7298,10 +7409,10 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/session-processes",
     zValidator(
       "json",
-      z28.object({
-        projectId: z28.string(),
+      z29.object({
+        projectId: z29.string(),
         input: userMessageInputSchema,
-        baseSessionId: z28.string().optional()
+        baseSessionId: z29.string().optional()
       })
     ),
     async (c) => {
@@ -7317,10 +7428,10 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/session-processes/:sessionProcessId/continue",
     zValidator(
       "json",
-      z28.object({
-        projectId: z28.string(),
+      z29.object({
+        projectId: z29.string(),
         input: userMessageInputSchema,
-        baseSessionId: z28.string()
+        baseSessionId: z29.string()
       })
     ),
     async (c) => {
@@ -7335,7 +7446,7 @@ var routes = (app, options) => Effect47.gen(function* () {
     }
   ).post(
     "/api/cc/session-processes/:sessionProcessId/abort",
-    zValidator("json", z28.object({ projectId: z28.string() })),
+    zValidator("json", z29.object({ projectId: z29.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
       void Effect47.runFork(
@@ -7347,9 +7458,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/permission-response",
     zValidator(
       "json",
-      z28.object({
-        permissionRequestId: z28.string(),
-        decision: z28.enum(["allow", "deny"])
+      z29.object({
+        permissionRequestId: z29.string(),
+        decision: z29.enum(["allow", "deny"])
       })
     ),
     async (c) => {
@@ -7416,9 +7527,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/fs/file-completion",
     zValidator(
       "query",
-      z28.object({
-        projectId: z28.string(),
-        basePath: z28.string().optional().default("/api/")
+      z29.object({
+        projectId: z29.string(),
+        basePath: z29.string().optional().default("/api/")
       })
     ),
     async (c) => {
@@ -7434,9 +7545,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/fs/directory-browser",
     zValidator(
       "query",
-      z28.object({
-        currentPath: z28.string().optional(),
-        showHidden: z28.string().optional().transform((val) => val === "true")
+      z29.object({
+        currentPath: z29.string().optional(),
+        showHidden: z29.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {
@@ -7452,10 +7563,10 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/search",
     zValidator(
       "query",
-      z28.object({
-        q: z28.string().min(2),
-        limit: z28.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
-        projectId: z28.string().optional()
+      z29.object({
+        q: z29.string().min(2),
+        limit: z29.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z29.string().optional()
       })
     ),
     async (c) => {