@kimuson/claude-code-viewer 0.5.5 → 0.5.7

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.7",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -51,89 +51,89 @@ var package_default = {
     prepare: "lefthook install"
   },
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.2.2",
+    "@anthropic-ai/claude-agent-sdk": "0.2.19",
     "@anthropic-ai/claude-code": "2.0.24",
     "@anthropic-ai/sdk": "0.71.2",
-    "@effect/cluster": "0.55.0",
-    "@effect/experimental": "0.57.11",
-    "@effect/platform": "0.93.6",
-    "@effect/platform-node": "0.103.0",
-    "@effect/rpc": "0.72.2",
-    "@effect/sql": "0.48.6",
-    "@effect/workflow": "0.15.1",
-    "@hono/node-server": "1.19.5",
+    "@effect/cluster": "0.56.1",
+    "@effect/experimental": "0.58.0",
+    "@effect/platform": "0.94.2",
+    "@effect/platform-node": "0.104.1",
+    "@effect/rpc": "0.73.0",
+    "@effect/sql": "0.49.0",
+    "@effect/workflow": "0.16.0",
+    "@hono/node-server": "1.19.9",
     "@hono/zod-validator": "0.7.6",
-    "@lingui/core": "5.5.1",
-    "@lingui/react": "5.5.1",
-    "@radix-ui/react-avatar": "1.1.10",
+    "@lingui/core": "5.9.0",
+    "@lingui/react": "5.9.0",
+    "@radix-ui/react-avatar": "1.1.11",
     "@radix-ui/react-checkbox": "1.3.3",
     "@radix-ui/react-collapsible": "1.1.12",
     "@radix-ui/react-dialog": "1.1.15",
     "@radix-ui/react-hover-card": "1.1.15",
     "@radix-ui/react-popover": "1.1.15",
     "@radix-ui/react-select": "2.2.6",
-    "@radix-ui/react-slot": "1.2.3",
+    "@radix-ui/react-slot": "1.2.4",
     "@radix-ui/react-tabs": "1.1.13",
     "@radix-ui/react-tooltip": "1.2.8",
-    "@tailwindcss/vite": "4.1.16",
-    "@tanstack/react-devtools": "0.7.8",
-    "@tanstack/react-query": "5.90.5",
-    "@tanstack/react-router": "1.133.32",
-    "@tanstack/react-router-devtools": "1.133.32",
+    "@tailwindcss/vite": "4.1.18",
+    "@tanstack/react-devtools": "0.9.2",
+    "@tanstack/react-query": "5.90.20",
+    "@tanstack/react-router": "1.156.0",
+    "@tanstack/react-router-devtools": "1.156.0",
     "class-variance-authority": "0.7.1",
     clsx: "2.1.1",
     commander: "^14.0.2",
     "date-fns": "4.1.0",
-    effect: "3.19.9",
-    "es-toolkit": "1.41.0",
-    hono: "4.10.3",
-    jotai: "2.15.0",
-    "lucide-react": "0.548.0",
+    effect: "3.19.15",
+    "es-toolkit": "1.44.0",
+    hono: "4.11.5",
+    jotai: "2.16.2",
+    "lucide-react": "0.563.0",
     minisearch: "7.2.0",
     "parse-git-diff": "0.0.19",
     prexit: "2.3.0",
-    react: "19.2.0",
-    "react-dom": "19.2.0",
-    "react-error-boundary": "6.0.0",
+    react: "19.2.3",
+    "react-dom": "19.2.3",
+    "react-error-boundary": "6.1.0",
     "react-markdown": "10.1.0",
-    "react-syntax-highlighter": "15.6.6",
+    "react-syntax-highlighter": "16.1.0",
     "remark-gfm": "4.0.1",
     sonner: "2.0.7",
-    "tailwind-merge": "3.3.1",
-    ulid: "3.0.1",
-    zod: "4.1.13"
+    "tailwind-merge": "3.4.0",
+    ulid: "3.0.2",
+    zod: "4.3.6"
   },
   devDependencies: {
-    "@biomejs/biome": "2.3.1",
-    "@effect/language-service": "0.60.0",
-    "@lingui/cli": "5.5.1",
-    "@lingui/conf": "5.5.1",
-    "@lingui/format-json": "5.5.1",
-    "@lingui/loader": "5.5.1",
-    "@lingui/vite-plugin": "5.5.1",
-    "@tailwindcss/postcss": "4.1.16",
-    "@tanstack/router-plugin": "1.133.32",
-    "@tsconfig/strictest": "2.0.6",
-    "@types/node": "24.9.1",
-    "@types/react": "19.2.2",
-    "@types/react-dom": "19.2.2",
+    "@biomejs/biome": "2.3.12",
+    "@effect/language-service": "0.72.0",
+    "@lingui/cli": "5.9.0",
+    "@lingui/conf": "5.9.0",
+    "@lingui/format-json": "5.9.0",
+    "@lingui/loader": "5.9.0",
+    "@lingui/vite-plugin": "5.9.0",
+    "@tailwindcss/postcss": "4.1.18",
+    "@tanstack/router-plugin": "1.156.0",
+    "@tsconfig/strictest": "2.0.8",
+    "@types/node": "25.0.10",
+    "@types/react": "19.2.9",
+    "@types/react-dom": "19.2.3",
     "@types/react-syntax-highlighter": "15.5.13",
-    "@vitejs/plugin-react-swc": "4.2.0",
+    "@vitejs/plugin-react-swc": "4.2.2",
     dotenv: "17.2.3",
-    esbuild: "0.25.11",
-    lefthook: "2.0.8",
+    esbuild: "0.27.2",
+    lefthook: "2.0.15",
     "npm-run-all2": "8.0.4",
-    playwright: "1.56.1",
-    "release-it": "19.0.5",
+    playwright: "1.58.0",
+    "release-it": "19.2.4",
     "release-it-pnpm": "4.6.6",
-    tailwindcss: "4.1.16",
-    tsx: "4.20.6",
+    tailwindcss: "4.1.18",
+    tsx: "4.21.0",
     "tw-animate-css": "1.4.0",
     typescript: "5.9.3",
-    vite: "7.1.12",
-    vitest: "4.0.3"
+    vite: "7.3.1",
+    vitest: "4.0.18"
   },
-  packageManager: "pnpm@10.18.3+sha512.bbd16e6d7286fd7e01f6b3c0b3c932cda2965c06a908328f74663f10a9aea51f1129eea615134bf992831b009eabe167ecb7008b597f40ff9bc75946aadfb08d"
+  packageManager: "pnpm@10.28.1+sha512.7d7dbbca9e99447b7c3bf7a73286afaaf6be99251eb9498baefa7d406892f67b879adb3a1d7e687fc4ccc1a388c7175fbaae567a26ab44d1067b54fcb0d6a316"
 };
 
 // src/server/core/platform/services/DeprecatedEnvDetector.ts
@@ -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 SystemEntrySchema = z13.union([
+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 = 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) => {
@@ -2568,17 +2649,28 @@ var fallbackSdkMessage = (message) => {
         plugins: []
       };
     }
+    if (message.subtype === "hook_response") {
+      return {
+        ...message
+      };
+    }
     return message;
   }
   if (message.type === "result") {
     if (message.subtype === "success") {
       return {
-        ...message
+        ...message,
+        modelUsage: {
+          ...message.modelUsage
+        }
       };
     }
     return {
       ...message,
-      errors: []
+      errors: [],
+      modelUsage: {
+        ...message.modelUsage
+      }
     };
   }
   return message;
@@ -3019,6 +3111,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 +3168,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 +3221,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 +3581,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 +3613,10 @@ var LayerImpl17 = Effect27.gen(function* () {
             );
             yield* eventBus.off("heartbeat", onHeartbeat);
             yield* eventBus.off("permissionRequested", onPermissionRequested);
+            yield* eventBus.off(
+              "virtualConversationUpdated",
+              onVirtualConversationUpdated
+            );
           })
         );
       }
@@ -3523,16 +3639,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 +3746,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 +4383,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 +5260,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 +5300,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,
@@ -5853,6 +5969,7 @@ var SearchController = class extends Context33.Tag("SearchController")() {
 };
 
 // src/server/core/session/presentation/SessionController.ts
+import { FileSystem as FileSystem14 } from "@effect/platform";
 import { Context as Context34, Effect as Effect43, Layer as Layer36 } from "effect";
 
 // src/server/core/session/services/ExportService.ts
@@ -6648,6 +6765,8 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
 // src/server/core/session/presentation/SessionController.ts
 var LayerImpl28 = Effect43.gen(function* () {
   const sessionRepository = yield* SessionRepository;
+  const fs = yield* FileSystem14.FileSystem;
+  const eventBus = yield* EventBus;
   const getSession = (options) => Effect43.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
@@ -6677,9 +6796,41 @@ var LayerImpl28 = Effect43.gen(function* () {
       response: { html }
     };
   });
+  const deleteSession = (options) => Effect43.gen(function* () {
+    const { projectId, sessionId } = options;
+    const sessionPath = decodeSessionId(projectId, sessionId);
+    const exists = yield* fs.exists(sessionPath);
+    if (!exists) {
+      return {
+        status: 404,
+        response: { error: "Session not found" }
+      };
+    }
+    const deleteResult = yield* fs.remove(sessionPath).pipe(
+      Effect43.map(() => ({ success: true, error: null })),
+      Effect43.catchAll(
+        (error) => Effect43.succeed({
+          success: false,
+          error: `Failed to delete session: ${error.message}`
+        })
+      )
+    );
+    if (!deleteResult.success) {
+      return {
+        status: 500,
+        response: { error: deleteResult.error }
+      };
+    }
+    yield* eventBus.emit("sessionListChanged", { projectId });
+    return {
+      status: 200,
+      response: { success: true }
+    };
+  });
   return {
     getSession,
-    exportSessionHtml
+    exportSessionHtml,
+    deleteSession
   };
 });
 var SessionController = class extends Context34.Tag("SessionController")() {
@@ -6847,65 +6998,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 +7064,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 +7089,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 +7121,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 +7230,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 +7284,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 +7299,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 +7335,29 @@ var routes = (app, options) => Effect47.gen(function* () {
       );
       return response;
     }
-  ).get("/api/projects/:projectId/agent-sessions/:agentId", async (c) => {
-    const { projectId, agentId } = c.req.param();
+  ).delete("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      agentSessionController.getAgentSession({
-        projectId,
-        agentId
-      }).pipe(Effect47.provide(runtime))
+      sessionController.deleteSession({ ...c.req.param() }).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 +7369,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 +7461,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 +7480,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 +7498,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 +7510,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 +7579,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 +7597,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 +7615,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) => {