@kimuson/claude-code-viewer 0.6.0-beta.1 → 0.6.0-beta.3

package/dist/main.js

@@ -7,7 +7,7 @@ import { Effect as Effect65 } from "effect";
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.6.0-beta.1",
+  version: "0.6.0-beta.3",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -39,7 +39,7 @@ var package_default = {
     fix: "run-s 'fix:*'",
     "fix:biome-format": "biome format --write .",
     "fix:biome-lint": "biome check --write --unsafe .",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsgo --noEmit",
     test: "vitest --run",
     "test:watch": "vitest",
     e2e: "./scripts/e2e/exec_e2e.sh",
@@ -51,21 +51,21 @@ var package_default = {
     prepare: "lefthook install"
   },
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.2.20",
-    "@anthropic-ai/claude-code": "2.1.29",
-    "@anthropic-ai/sdk": "0.71.2",
-    "@effect/cluster": "0.56.1",
+    "@anthropic-ai/claude-agent-sdk": "0.2.42",
+    "@anthropic-ai/claude-code": "2.1.42",
+    "@anthropic-ai/sdk": "0.74.0",
+    "@effect/cluster": "0.56.4",
     "@effect/experimental": "0.58.0",
-    "@effect/platform": "0.94.2",
+    "@effect/platform": "0.94.5",
     "@effect/platform-node": "0.104.1",
-    "@effect/rpc": "0.73.0",
+    "@effect/rpc": "0.73.1",
     "@effect/sql": "0.49.0",
     "@effect/workflow": "0.16.0",
     "@hono/node-server": "1.19.9",
     "@hono/zod-validator": "0.7.6",
-    "@hookform/resolvers": "^5.2.2",
-    "@lingui/core": "5.9.0",
-    "@lingui/react": "5.9.0",
+    "@hookform/resolvers": "5.2.2",
+    "@lingui/core": "5.9.1",
+    "@lingui/react": "5.9.1",
     "@radix-ui/react-avatar": "1.1.11",
     "@radix-ui/react-checkbox": "1.3.3",
     "@radix-ui/react-collapsible": "1.1.12",
@@ -76,63 +76,64 @@ var package_default = {
     "@radix-ui/react-slot": "1.2.4",
     "@radix-ui/react-tabs": "1.1.13",
     "@radix-ui/react-tooltip": "1.2.8",
+    "@replit/ruspty": "3.6.0",
     "@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",
-    "@xterm/addon-fit": "0.10.0",
-    "@xterm/xterm": "5.5.0",
+    "@tanstack/react-devtools": "0.9.5",
+    "@tanstack/react-query": "5.90.21",
+    "@tanstack/react-router": "1.160.0",
+    "@tanstack/react-router-devtools": "1.160.0",
+    "@xterm/addon-fit": "0.11.0",
+    "@xterm/xterm": "6.0.0",
     "class-variance-authority": "0.7.1",
     clsx: "2.1.1",
-    cmdk: "^1.1.1",
-    commander: "^14.0.2",
+    cmdk: "1.1.1",
+    commander: "14.0.3",
     "date-fns": "4.1.0",
-    effect: "3.19.15",
+    effect: "3.19.17",
     "es-toolkit": "1.44.0",
-    hono: "4.11.5",
-    jotai: "2.16.2",
-    "lucide-react": "0.563.0",
+    hono: "4.11.9",
+    jotai: "2.17.1",
+    "lucide-react": "0.564.0",
     minisearch: "7.2.0",
-    "parse-git-diff": "0.0.19",
+    "parse-git-diff": "0.0.20",
     prexit: "2.3.0",
-    "radix-ui": "^1.4.3",
-    react: "19.2.3",
-    "react-dom": "19.2.3",
-    "react-error-boundary": "6.1.0",
-    "react-hook-form": "^7.71.1",
+    "radix-ui": "1.4.3",
+    react: "19.2.4",
+    "react-dom": "19.2.4",
+    "react-error-boundary": "6.1.1",
+    "react-hook-form": "7.71.1",
     "react-markdown": "10.1.0",
     "react-syntax-highlighter": "16.1.0",
     "remark-gfm": "4.0.1",
     sonner: "2.0.7",
-    "tailwind-merge": "3.4.0",
+    "tailwind-merge": "3.4.1",
     ulid: "3.0.2",
-    "node-pty": "1.1.0-beta34",
-    ws: "8.18.3",
+    ws: "8.19.0",
     zod: "4.3.6"
   },
   devDependencies: {
-    "@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",
+    "@biomejs/biome": "2.4.0",
+    "@effect/language-service": "0.73.1",
+    "@lingui/cli": "5.9.1",
+    "@lingui/conf": "5.9.1",
+    "@lingui/format-json": "5.9.1",
+    "@lingui/loader": "5.9.1",
+    "@lingui/vite-plugin": "5.9.1",
     "@tailwindcss/postcss": "4.1.18",
-    "@tanstack/router-plugin": "1.156.0",
+    "@tanstack/router-plugin": "1.160.0",
     "@tsconfig/strictest": "2.0.8",
-    "@types/node": "25.0.10",
-    "@types/react": "19.2.9",
+    "@types/node": "25.2.3",
+    "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "@types/react-syntax-highlighter": "15.5.13",
-    "@types/ws": "8.18.0",
-    "@vitejs/plugin-react-swc": "4.2.2",
-    dotenv: "17.2.3",
-    esbuild: "0.27.2",
-    lefthook: "2.0.15",
+    "@types/ws": "8.18.1",
+    "@typescript/native-preview": "7.0.0-dev.20260215.1",
+    "@vitejs/plugin-react-swc": "4.2.3",
+    dotenv: "17.3.1",
+    esbuild: "0.27.3",
+    lefthook: "2.1.1",
     "npm-run-all2": "8.0.4",
-    playwright: "1.58.0",
+    playwright: "1.58.2",
     "release-it": "19.2.4",
     "release-it-pnpm": "4.6.6",
     tailwindcss: "4.1.18",
@@ -238,294 +239,310 @@ import { FileSystem, Path } from "@effect/platform";
 import { Context, Effect as Effect2, Layer } from "effect";
 
 // src/lib/conversation-schema/index.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
+
+// src/lib/conversation-schema/entry/AgentNameEntrySchema.ts
+import { z } from "zod";
+var AgentNameEntrySchema = z.object({
+  type: z.literal("agent-name"),
+  agentName: z.string(),
+  sessionId: z.string()
+});
 
 // src/lib/conversation-schema/entry/AssistantEntrySchema.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/lib/conversation-schema/message/AssistantMessageSchema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/lib/conversation-schema/content/TextContentSchema.ts
-import { z } from "zod";
-var TextContentSchema = z.object({
-  type: z.literal("text"),
-  text: z.string()
+import { z as z2 } from "zod";
+var TextContentSchema = z2.object({
+  type: z2.literal("text"),
+  text: z2.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()
+import { z as z3 } from "zod";
+var ThinkingContentSchema = z3.object({
+  type: z3.literal("thinking"),
+  thinking: z3.string(),
+  signature: z3.string().optional()
 });
 
 // src/lib/conversation-schema/content/ToolResultContentSchema.ts
-import { z as z4 } from "zod";
+import { z as z5 } 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"])
+import { z as z4 } from "zod";
+var ImageContentSchema = z4.object({
+  type: z4.literal("image"),
+  source: z4.object({
+    type: z4.literal("base64"),
+    data: z4.string(),
+    media_type: z4.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]))
+var ToolResultContentSchema = z5.object({
+  type: z5.literal("tool_result"),
+  tool_use_id: z5.string(),
+  content: z5.union([
+    z5.string(),
+    z5.array(z5.union([TextContentSchema, ImageContentSchema]))
   ]),
-  is_error: z4.boolean().optional()
+  is_error: z5.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())
+import { z as z6 } from "zod";
+var ToolUseContentSchema = z6.object({
+  type: z6.literal("tool_use"),
+  id: z6.string(),
+  name: z6.string(),
+  input: z6.record(z6.string(), z6.unknown())
 });
 
 // src/lib/conversation-schema/message/AssistantMessageSchema.ts
-var AssistantMessageContentSchema = z6.union([
+var AssistantMessageContentSchema = z7.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()
+var AssistantMessageSchema = z7.object({
+  id: z7.string(),
+  container: z7.null().optional(),
+  type: z7.literal("message"),
+  role: z7.literal("assistant"),
+  model: z7.string(),
+  content: z7.array(AssistantMessageContentSchema),
+  stop_reason: z7.string().nullable(),
+  stop_sequence: z7.string().nullable(),
+  usage: z7.object({
+    input_tokens: z7.number(),
+    cache_creation_input_tokens: z7.number().optional(),
+    cache_read_input_tokens: z7.number().optional(),
+    cache_creation: z7.object({
+      ephemeral_5m_input_tokens: z7.number(),
+      ephemeral_1h_input_tokens: z7.number()
     }).optional(),
-    output_tokens: z6.number(),
-    service_tier: z6.string().nullable().optional(),
-    server_tool_use: z6.object({
-      web_search_requests: z6.number()
+    output_tokens: z7.number(),
+    service_tier: z7.string().nullable().optional(),
+    server_tool_use: z7.object({
+      web_search_requests: z7.number()
     }).optional()
   })
 });
 
 // src/lib/conversation-schema/entry/BaseEntrySchema.ts
-import { z as z7 } from "zod";
-var BaseEntrySchema = z7.object({
+import { z as z8 } from "zod";
+var BaseEntrySchema = z8.object({
   // required
-  isSidechain: z7.boolean(),
-  userType: z7.enum(["external"]),
-  cwd: z7.string(),
-  sessionId: z7.string(),
-  version: z7.string(),
-  uuid: z7.uuid(),
-  timestamp: z7.string(),
+  isSidechain: z8.boolean(),
+  userType: z8.enum(["external"]),
+  cwd: z8.string(),
+  sessionId: z8.string(),
+  version: z8.string(),
+  uuid: z8.uuid(),
+  timestamp: z8.string(),
   // nullable
-  parentUuid: z7.uuid().nullable(),
+  parentUuid: z8.uuid().nullable(),
   // optional
-  isMeta: z7.boolean().optional(),
-  toolUseResult: z7.unknown().optional(),
+  isMeta: z8.boolean().optional(),
+  toolUseResult: z8.unknown().optional(),
   // スキーマがツールごとに異なりすぎるし利用もしなそうなので unknown
-  gitBranch: z7.string().optional(),
-  isCompactSummary: z7.boolean().optional(),
-  agentId: z7.string().optional()
+  gitBranch: z8.string().optional(),
+  isCompactSummary: z8.boolean().optional(),
+  agentId: z8.string().optional()
 });
 
 // src/lib/conversation-schema/entry/AssistantEntrySchema.ts
 var AssistantEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z8.literal("assistant"),
+  type: z9.literal("assistant"),
   // required
   message: AssistantMessageSchema,
   // optional
-  requestId: z8.string().optional(),
-  isApiErrorMessage: z8.boolean().optional()
+  requestId: z9.string().optional(),
+  isApiErrorMessage: z9.boolean().optional()
+});
+
+// src/lib/conversation-schema/entry/CustomTitleEntrySchema.ts
+import { z as z10 } from "zod";
+var CustomTitleEntrySchema = z10.object({
+  type: z10.literal("custom-title"),
+  customTitle: z10.string(),
+  sessionId: z10.string()
 });
 
 // src/lib/conversation-schema/entry/FileHIstorySnapshotEntrySchema.ts
-import { z as z9 } from "zod";
-var FileHistorySnapshotEntrySchema = z9.object({
+import { z as z11 } from "zod";
+var FileHistorySnapshotEntrySchema = z11.object({
   // discriminator
-  type: z9.literal("file-history-snapshot"),
+  type: z11.literal("file-history-snapshot"),
   // required
-  messageId: z9.string(),
-  snapshot: z9.object({
-    messageId: z9.string(),
-    trackedFileBackups: z9.record(z9.string(), z9.unknown()),
-    timestamp: z9.string()
+  messageId: z11.string(),
+  snapshot: z11.object({
+    messageId: z11.string(),
+    trackedFileBackups: z11.record(z11.string(), z11.unknown()),
+    timestamp: z11.string()
   }),
-  isSnapshotUpdate: z9.boolean()
+  isSnapshotUpdate: z11.boolean()
 });
 
 // src/lib/conversation-schema/entry/ProgressEntrySchema.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 var ProgressEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z10.literal("progress"),
+  type: z12.literal("progress"),
   // required
-  data: z10.record(z10.string(), z10.any()),
-  toolUseID: z10.string().optional(),
-  parentToolUseID: z10.string().optional()
+  data: z12.record(z12.string(), z12.any()),
+  toolUseID: z12.string().optional(),
+  parentToolUseID: z12.string().optional()
 });
 
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 
 // src/lib/conversation-schema/content/DocumentContentSchema.ts
-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()
+import { z as z13 } from "zod";
+var DocumentContentSchema = z13.object({
+  type: z13.literal("document"),
+  source: z13.union([
+    z13.object({
+      media_type: z13.literal("text/plain"),
+      type: z13.literal("text"),
+      data: z13.string()
     }),
-    z11.object({
-      media_type: z11.enum(["application/pdf"]),
-      type: z11.literal("base64"),
-      data: z11.string()
+    z13.object({
+      media_type: z13.enum(["application/pdf"]),
+      type: z13.literal("base64"),
+      data: z13.string()
     })
   ])
 });
 
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-var QueueOperationContentSchema = z12.union([
-  z12.string(),
+var QueueOperationContentSchema = z14.union([
+  z14.string(),
   TextContentSchema,
   ToolResultContentSchema,
   ImageContentSchema,
   DocumentContentSchema
 ]);
-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]))
+var QueueOperationEntrySchema = z14.union([
+  z14.object({
+    type: z14.literal("queue-operation"),
+    operation: z14.literal("enqueue"),
+    content: z14.union([
+      z14.string(),
+      z14.array(z14.union([z14.string(), QueueOperationContentSchema]))
     ]),
-    sessionId: z12.string(),
-    timestamp: z12.iso.datetime()
+    sessionId: z14.string(),
+    timestamp: z14.iso.datetime()
   }),
-  z12.object({
-    type: z12.literal("queue-operation"),
-    operation: z12.literal("dequeue"),
-    sessionId: z12.string(),
-    timestamp: z12.iso.datetime()
+  z14.object({
+    type: z14.literal("queue-operation"),
+    operation: z14.literal("dequeue"),
+    sessionId: z14.string(),
+    timestamp: z14.iso.datetime()
   }),
-  z12.object({
-    type: z12.literal("queue-operation"),
-    operation: z12.literal("remove"),
-    sessionId: z12.string(),
-    timestamp: z12.iso.datetime()
+  z14.object({
+    type: z14.literal("queue-operation"),
+    operation: z14.literal("remove"),
+    sessionId: z14.string(),
+    timestamp: z14.iso.datetime()
   }),
-  z12.object({
-    type: z12.literal("queue-operation"),
-    operation: z12.literal("popAll"),
-    sessionId: z12.string(),
-    timestamp: z12.iso.datetime(),
-    content: z12.string().optional()
+  z14.object({
+    type: z14.literal("queue-operation"),
+    operation: z14.literal("popAll"),
+    sessionId: z14.string(),
+    timestamp: z14.iso.datetime(),
+    content: z14.string().optional()
   })
 ]);
 
 // src/lib/conversation-schema/entry/SummaryEntrySchema.ts
-import { z as z13 } from "zod";
-var SummaryEntrySchema = z13.object({
-  type: z13.literal("summary"),
-  summary: z13.string(),
-  leafUuid: z13.string().uuid()
+import { z as z15 } from "zod";
+var SummaryEntrySchema = z15.object({
+  type: z15.literal("summary"),
+  summary: z15.string(),
+  leafUuid: z15.string().uuid()
 });
 
 // src/lib/conversation-schema/entry/SystemEntrySchema.ts
-import { z as z14 } from "zod";
-var HookInfoSchema = z14.object({
-  command: z14.string()
+import { z as z16 } from "zod";
+var HookInfoSchema = z16.object({
+  command: z16.string()
 });
 var SystemEntryWithContentSchema = BaseEntrySchema.extend({
-  type: z14.literal("system"),
-  content: z14.string(),
-  toolUseID: z14.string(),
-  level: z14.enum(["info"]),
-  subtype: z14.undefined().optional()
+  type: z16.literal("system"),
+  content: z16.string(),
+  toolUseID: z16.string(),
+  level: z16.enum(["info"]),
+  subtype: z16.undefined().optional()
 });
 var StopHookSummaryEntrySchema = BaseEntrySchema.extend({
-  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()
+  type: z16.literal("system"),
+  subtype: z16.literal("stop_hook_summary"),
+  toolUseID: z16.string(),
+  level: z16.enum(["info", "suggestion"]),
+  slug: z16.string().optional(),
+  hookCount: z16.number(),
+  hookInfos: z16.array(HookInfoSchema),
+  hookErrors: z16.array(z16.unknown()),
+  preventedContinuation: z16.boolean(),
+  stopReason: z16.string(),
+  hasOutput: z16.boolean()
 });
 var LocalCommandEntrySchema = BaseEntrySchema.extend({
-  type: z14.literal("system"),
-  subtype: z14.literal("local_command"),
-  content: z14.string(),
-  level: z14.enum(["info"])
+  type: z16.literal("system"),
+  subtype: z16.literal("local_command"),
+  content: z16.string(),
+  level: z16.enum(["info"])
 });
 var TurnDurationEntrySchema = BaseEntrySchema.extend({
-  type: z14.literal("system"),
-  subtype: z14.literal("turn_duration"),
-  durationMs: z14.number(),
-  slug: z14.string().optional()
+  type: z16.literal("system"),
+  subtype: z16.literal("turn_duration"),
+  durationMs: z16.number(),
+  slug: z16.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()
+  type: z16.literal("system"),
+  subtype: z16.literal("compact_boundary"),
+  content: z16.string(),
+  level: z16.enum(["info"]),
+  slug: z16.string().optional(),
+  logicalParentUuid: z16.string().optional(),
+  compactMetadata: z16.object({
+    trigger: z16.string(),
+    preTokens: z16.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()
+  type: z16.literal("system"),
+  subtype: z16.literal("api_error"),
+  level: z16.enum(["error", "warning", "info"]),
+  error: z16.object({
+    status: z16.number().optional(),
+    headers: z16.record(z16.string(), z16.unknown()).optional(),
+    requestID: z16.string().nullable().optional(),
+    error: z16.object({
+      type: z16.string(),
+      error: z16.object({
+        type: z16.string(),
+        message: z16.string()
       }).optional(),
-      message: z14.string().optional()
+      message: z16.string().optional()
     }).optional()
   }),
-  retryInMs: z14.number().optional(),
-  retryAttempt: z14.number().optional(),
-  maxRetries: z14.number().optional()
+  retryInMs: z16.number().optional(),
+  retryAttempt: z16.number().optional(),
+  maxRetries: z16.number().optional()
 });
-var SystemEntrySchema = z14.union([
+var SystemEntrySchema = z16.union([
   StopHookSummaryEntrySchema,
   LocalCommandEntrySchema,
   TurnDurationEntrySchema,
@@ -536,42 +553,44 @@ var SystemEntrySchema = z14.union([
 ]);
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/lib/conversation-schema/message/UserMessageSchema.ts
-import { z as z15 } from "zod";
-var UserMessageContentSchema = z15.union([
-  z15.string(),
+import { z as z17 } from "zod";
+var UserMessageContentSchema = z17.union([
+  z17.string(),
   TextContentSchema,
   ToolResultContentSchema,
   ImageContentSchema,
   DocumentContentSchema
 ]);
-var UserMessageSchema = z15.object({
-  role: z15.literal("user"),
-  content: z15.union([
-    z15.string(),
-    z15.array(z15.union([z15.string(), UserMessageContentSchema]))
+var UserMessageSchema = z17.object({
+  role: z17.literal("user"),
+  content: z17.union([
+    z17.string(),
+    z17.array(z17.union([z17.string(), UserMessageContentSchema]))
   ])
 });
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
 var UserEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z16.literal("user"),
+  type: z18.literal("user"),
   // required
   message: UserMessageSchema
 });
 
 // src/lib/conversation-schema/index.ts
-var ConversationSchema = z17.union([
+var ConversationSchema = z19.union([
   UserEntrySchema,
   AssistantEntrySchema,
   SummaryEntrySchema,
   SystemEntrySchema,
   FileHistorySnapshotEntrySchema,
   QueueOperationEntrySchema,
-  ProgressEntrySchema
+  ProgressEntrySchema,
+  CustomTitleEntrySchema,
+  AgentNameEntrySchema
 ]);
 
 // src/server/core/claude-code/functions/parseJsonl.ts
@@ -603,6 +622,21 @@ var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
   return encodeProjectId(dirname(sessionFilePath));
 };
 
+// src/server/core/session/functions/extractFirstUserText.ts
+var extractFirstUserText = (conversation) => {
+  if (conversation.type !== "user") {
+    return null;
+  }
+  const firstUserText = typeof conversation.message.content === "string" ? conversation.message.content : (() => {
+    const firstContent = conversation.message.content.at(0);
+    if (firstContent === void 0) return null;
+    if (typeof firstContent === "string") return firstContent;
+    if (firstContent.type === "text") return firstContent.text;
+    return null;
+  })();
+  return firstUserText;
+};
+
 // src/server/core/agent-session/infrastructure/AgentSessionRepository.ts
 var LayerImpl = Effect2.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
@@ -630,8 +664,65 @@ var LayerImpl = Effect2.gen(function* () {
     const conversations = parseJsonl(content);
     return conversations;
   });
+  const listAgentSessionsForSession = (projectId, sessionId) => Effect2.gen(function* () {
+    const projectPath = decodeProjectId(projectId);
+    const results = [];
+    const extractAgentId = (filename) => {
+      const match = /^agent-(.+)\.jsonl$/.exec(filename);
+      return match ? match[1] ?? null : null;
+    };
+    const processFile = (filePath, filename) => Effect2.gen(function* () {
+      const agentId = extractAgentId(filename);
+      if (agentId === null) return;
+      const content = yield* fs.readFileString(filePath);
+      const firstLine = content.split("\n")[0];
+      if (!firstLine || firstLine.trim() === "") return;
+      try {
+        const conversations = parseJsonl(firstLine);
+        const firstConv = conversations[0];
+        const firstMessage = firstConv ? extractFirstUserText(firstConv) : null;
+        results.push({ agentId, firstMessage });
+      } catch {
+        results.push({ agentId, firstMessage: null });
+      }
+    });
+    const subagentsDir = path.join(projectPath, sessionId, "subagents");
+    const subagentsDirExists = yield* fs.exists(subagentsDir);
+    if (subagentsDirExists) {
+      const entries = yield* fs.readDirectory(subagentsDir).pipe(Effect2.catchAll(() => Effect2.succeed([])));
+      const agentFiles = entries.filter(
+        (f) => f.startsWith("agent-") && f.endsWith(".jsonl")
+      );
+      for (const filename of agentFiles) {
+        yield* processFile(path.join(subagentsDir, filename), filename).pipe(
+          Effect2.catchAll(() => Effect2.void)
+        );
+      }
+    }
+    const rootEntries = yield* fs.readDirectory(projectPath).pipe(Effect2.catchAll(() => Effect2.succeed([])));
+    const rootAgentFiles = rootEntries.filter(
+      (f) => f.startsWith("agent-") && f.endsWith(".jsonl")
+    );
+    for (const filename of rootAgentFiles) {
+      const filePath = path.join(projectPath, filename);
+      const content = yield* fs.readFileString(filePath).pipe(Effect2.catchAll(() => Effect2.succeed("")));
+      const firstLine = content.split("\n")[0];
+      if (!firstLine || firstLine.trim() === "") continue;
+      try {
+        const parsed = JSON.parse(firstLine);
+        if (typeof parsed === "object" && parsed !== null && "sessionId" in parsed && parsed.sessionId === sessionId) {
+          yield* processFile(filePath, filename).pipe(
+            Effect2.catchAll(() => Effect2.void)
+          );
+        }
+      } catch {
+      }
+    }
+    return results;
+  });
   return {
-    getAgentSessionByAgentId
+    getAgentSessionByAgentId,
+    listAgentSessionsForSession
   };
 });
 var AgentSessionRepository = class extends Context.Tag(
@@ -670,8 +761,22 @@ var LayerImpl2 = Effect3.gen(function* () {
       }
     };
   });
+  const listAgentSessions = (params) => Effect3.gen(function* () {
+    const { projectId, sessionId } = params;
+    const agentSessions = yield* repository.listAgentSessionsForSession(
+      projectId,
+      sessionId
+    );
+    return {
+      status: 200,
+      response: {
+        agentSessions
+      }
+    };
+  });
   return {
-    getAgentSession
+    getAgentSession,
+    listAgentSessions
   };
 });
 var AgentSessionController = class extends Context2.Tag(
@@ -719,7 +824,8 @@ var LayerImpl3 = Effect4.gen(function* () {
           claudeDir: cliOptions.claudeDir ?? getOptionalEnv2("CCV_GLOBAL_CLAUDE_DIR"),
           terminalDisabled: cliOptions.terminalDisabled ?? (isFlagEnabled(getOptionalEnv2("CCV_TERMINAL_DISABLED")) ? true : void 0),
           terminalShell: cliOptions.terminalShell ?? getOptionalEnv2("CCV_TERMINAL_SHELL") ?? void 0,
-          terminalUnrestricted: cliOptions.terminalUnrestricted ?? (isFlagEnabled(getOptionalEnv2("CCV_TERMINAL_UNRESTRICTED")) ? true : void 0)
+          terminalUnrestricted: cliOptions.terminalUnrestricted ?? (isFlagEnabled(getOptionalEnv2("CCV_TERMINAL_UNRESTRICTED")) ? true : void 0),
+          apiOnly: cliOptions.apiOnly ?? (isFlagEnabled(getOptionalEnv2("CCV_API_ONLY")) ? true : void 0)
         };
       });
     });
@@ -784,7 +890,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 z19 } from "zod";
+import { z as z21 } 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";
@@ -792,7 +898,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 z18 } from "zod";
+import { z as z20 } from "zod";
 
 // src/server/lib/config/paths.ts
 import { homedir as homedir2 } from "node:os";
@@ -804,7 +910,7 @@ var claudeCodeViewerCacheDirPath = resolve(
 );
 
 // src/server/lib/storage/FileCacheStorage/PersistentService.ts
-var saveSchema = z18.array(z18.tuple([z18.string(), z18.unknown()]));
+var saveSchema = z20.array(z20.tuple([z20.string(), z20.unknown()]));
 var LayerImpl5 = Effect6.gen(function* () {
   const path = yield* Path3.Path;
   const getCacheFilePath = (key) => path.resolve(claudeCodeViewerCacheDirPath, `${key}.json`);
@@ -917,7 +1023,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer7.effect(
 );
 
 // src/server/core/project/services/ProjectMetaService.ts
-var ProjectPathSchema = z19.string().nullable();
+var ProjectPathSchema = z21.string().nullable();
 var LayerImpl6 = Effect8.gen(function* () {
   const fs = yield* FileSystem3.FileSystem;
   const path = yield* Path4.Path;
@@ -933,7 +1039,7 @@ var LayerImpl6 = Effect8.gen(function* () {
     let cwd = null;
     for (const line of lines) {
       const conversation = parseJsonl(line).at(0);
-      if (conversation === void 0 || conversation.type === "summary" || conversation.type === "x-error" || conversation.type === "file-history-snapshot" || conversation.type === "queue-operation") {
+      if (conversation === void 0 || conversation.type === "summary" || conversation.type === "x-error" || conversation.type === "file-history-snapshot" || conversation.type === "queue-operation" || conversation.type === "custom-title" || conversation.type === "agent-name") {
         continue;
       }
       cwd = conversation.cwd;
@@ -1200,12 +1306,12 @@ var scanSkillFilesWithMetadata = (dirPath) => Effect10.gen(function* () {
 });
 
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-var versionSchema = z20.object({
-  major: z20.string().transform((value) => Number.parseInt(value, 10)),
-  minor: z20.string().transform((value) => Number.parseInt(value, 10)),
-  patch: z20.string().transform((value) => Number.parseInt(value, 10))
+var versionSchema = z22.object({
+  major: z22.string().transform((value) => Number.parseInt(value, 10)),
+  minor: z22.string().transform((value) => Number.parseInt(value, 10)),
+  patch: z22.string().transform((value) => Number.parseInt(value, 10))
 }).refine(
   (data) => [data.major, data.minor, data.patch].every((value) => !Number.isNaN(value))
 );
@@ -1868,26 +1974,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 z21 } from "zod";
+import { z as z23 } from "zod";
 var regExp = /<(?<tag>[^>]+)>(?<content>[\s\S]*?)<\/\k<tag>>/g;
-var matchSchema = z21.object({
-  tag: z21.string(),
-  content: z21.string()
+var matchSchema = z23.object({
+  tag: z23.string(),
+  content: z23.string()
 });
-var parsedUserMessageSchema = z21.union([
-  z21.object({
-    kind: z21.literal("command"),
-    commandName: z21.string(),
-    commandArgs: z21.string().optional(),
-    commandMessage: z21.string().optional()
+var parsedUserMessageSchema = z23.union([
+  z23.object({
+    kind: z23.literal("command"),
+    commandName: z23.string(),
+    commandArgs: z23.string().optional(),
+    commandMessage: z23.string().optional()
   }),
-  z21.object({
-    kind: z21.literal("local-command"),
-    stdout: z21.string()
+  z23.object({
+    kind: z23.literal("local-command"),
+    stdout: z23.string()
   }),
-  z21.object({
-    kind: z21.literal("text"),
-    content: z21.string()
+  z23.object({
+    kind: z23.literal("text"),
+    content: z23.string()
   })
 ]);
 var parseUserMessage = (content) => {
@@ -2232,21 +2338,6 @@ var getAgentSessionFilesForSession = (projectPath, sessionId) => Effect19.gen(fu
   return matchingFilePaths;
 });
 
-// src/server/core/session/functions/extractFirstUserText.ts
-var extractFirstUserText = (conversation) => {
-  if (conversation.type !== "user") {
-    return null;
-  }
-  const firstUserText = typeof conversation.message.content === "string" ? conversation.message.content : (() => {
-    const firstContent = conversation.message.content.at(0);
-    if (firstContent === void 0) return null;
-    if (typeof firstContent === "string") return firstContent;
-    if (firstContent.type === "text") return firstContent.text;
-    return null;
-  })();
-  return firstUserText;
-};
-
 // src/server/core/session/functions/isValidFirstMessage.ts
 var ignoreCommands = [
   "/clear",
@@ -2282,6 +2373,9 @@ var extractFirstUserMessage = (conversation) => {
   if (command.kind === "command" && ignoreCommands.includes(command.commandName)) {
     return void 0;
   }
+  if (command.kind === "local-command" && command.stdout.trim() === "") {
+    return void 0;
+  }
   return command;
 };
 
@@ -2301,8 +2395,8 @@ var SessionMetaService = class extends Context15.Tag("SessionMetaService")() {
         const getFirstUserMessage = (jsonlFilePath, lines) => Effect20.gen(function* () {
           const cached = yield* firstUserMessageCache.get(jsonlFilePath);
           if (cached !== void 0) {
-            if (cached !== null && cached.kind === "text" && isLocalCommandCaveat(cached.content)) {
-            } else {
+            const isStale = cached !== null && (cached.kind === "text" && isLocalCommandCaveat(cached.content) || cached.kind === "local-command" && cached.stdout.trim() === "");
+            if (!isStale) {
               return cached;
             }
           }
@@ -3679,16 +3773,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 z22 from "zod";
+import z24 from "zod";
 var sessionFileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl$/;
 var agentFileRegExp = /(?<projectId>.*?)\/agent-(?<agentSessionId>.*?)\.jsonl$/;
-var sessionFileGroupSchema = z22.object({
-  projectId: z22.string(),
-  sessionId: z22.string()
+var sessionFileGroupSchema = z24.object({
+  projectId: z24.string(),
+  sessionId: z24.string()
 });
-var agentFileGroupSchema = z22.object({
-  projectId: z22.string(),
-  agentSessionId: z22.string()
+var agentFileGroupSchema = z24.object({
+  projectId: z24.string(),
+  agentSessionId: z24.string()
 });
 var parseSessionFilePath = (filePath) => {
   const agentMatch = filePath.match(agentFileRegExp);
@@ -4720,16 +4814,16 @@ 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 z23 } from "zod";
-var envSchema = z23.object({
+import { z as z25 } from "zod";
+var envSchema = z25.object({
   // Frameworks
-  CCV_ENV: z23.enum(["development", "production", "test"]).optional().default("development"),
-  NEXT_PHASE: z23.string().optional(),
-  PATH: z23.string().optional(),
-  SHELL: z23.string().optional(),
-  CCV_TERMINAL_SHELL: z23.string().optional(),
-  CCV_TERMINAL_UNRESTRICTED: z23.string().optional(),
-  CCV_TERMINAL_DISABLED: z23.string().optional()
+  CCV_ENV: z25.enum(["development", "production", "test"]).optional().default("development"),
+  NEXT_PHASE: z25.string().optional(),
+  PATH: z25.string().optional(),
+  SHELL: z25.string().optional(),
+  CCV_TERMINAL_SHELL: z25.string().optional(),
+  CCV_TERMINAL_UNRESTRICTED: z25.string().optional(),
+  CCV_TERMINAL_DISABLED: z25.string().optional()
 });
 
 // src/server/core/platform/services/EnvService.ts
@@ -5686,49 +5780,49 @@ 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 z24 } from "zod";
-var concurrencyPolicySchema = z24.enum(["skip", "run"]);
-var cronScheduleSchema = z24.object({
-  type: z24.literal("cron"),
-  expression: z24.string(),
+import { z as z26 } from "zod";
+var concurrencyPolicySchema = z26.enum(["skip", "run"]);
+var cronScheduleSchema = z26.object({
+  type: z26.literal("cron"),
+  expression: z26.string(),
   concurrencyPolicy: concurrencyPolicySchema
 });
-var reservedScheduleSchema = z24.object({
-  type: z24.literal("reserved"),
-  reservedExecutionTime: z24.iso.datetime()
+var reservedScheduleSchema = z26.object({
+  type: z26.literal("reserved"),
+  reservedExecutionTime: z26.iso.datetime()
 });
-var scheduleSchema = z24.discriminatedUnion("type", [
+var scheduleSchema = z26.discriminatedUnion("type", [
   cronScheduleSchema,
   reservedScheduleSchema
 ]);
-var messageConfigSchema = z24.object({
-  content: z24.string(),
-  projectId: z24.string(),
-  baseSession: z24.union([
-    z24.null(),
-    z24.object({
-      type: z24.literal("fork"),
-      sessionId: z24.string()
+var messageConfigSchema = z26.object({
+  content: z26.string(),
+  projectId: z26.string(),
+  baseSession: z26.union([
+    z26.null(),
+    z26.object({
+      type: z26.literal("fork"),
+      sessionId: z26.string()
     }),
-    z24.object({
-      type: z24.literal("resume"),
-      sessionId: z24.string()
+    z26.object({
+      type: z26.literal("resume"),
+      sessionId: z26.string()
     })
   ])
 });
-var jobStatusSchema = z24.enum(["success", "failed"]);
-var schedulerJobSchema = z24.object({
-  id: z24.string(),
-  name: z24.string(),
+var jobStatusSchema = z26.enum(["success", "failed"]);
+var schedulerJobSchema = z26.object({
+  id: z26.string(),
+  name: z26.string(),
   schedule: scheduleSchema,
   message: messageConfigSchema,
-  enabled: z24.boolean(),
-  createdAt: z24.string().datetime(),
-  lastRunAt: z24.string().datetime().nullable(),
+  enabled: z26.boolean(),
+  createdAt: z26.string().datetime(),
+  lastRunAt: z26.string().datetime().nullable(),
   lastRunStatus: jobStatusSchema.nullable()
 });
-var schedulerConfigSchema = z24.object({
-  jobs: z24.array(schedulerJobSchema)
+var schedulerConfigSchema = z26.object({
+  jobs: z26.array(schedulerJobSchema)
 });
 var newSchedulerJobSchema = schedulerJobSchema.omit({
   id: true,
@@ -5736,7 +5830,7 @@ var newSchedulerJobSchema = schedulerJobSchema.omit({
   lastRunAt: true,
   lastRunStatus: true
 }).extend({
-  enabled: z24.boolean().default(true)
+  enabled: z26.boolean().default(true)
 });
 var updateSchedulerJobSchema = schedulerJobSchema.partial().pick({
   name: true,
@@ -6110,17 +6204,17 @@ var SchedulerService = class extends Context30.Tag("SchedulerService")() {
 };
 
 // src/server/core/rate-limit/schema.ts
-import { z as z25 } from "zod";
-var RateLimitEntrySchema = z25.object({
-  type: z25.literal("assistant"),
-  error: z25.literal("rate_limit"),
-  isApiErrorMessage: z25.literal(true),
-  sessionId: z25.string(),
-  message: z25.object({
-    content: z25.array(
-      z25.object({
-        type: z25.literal("text"),
-        text: z25.string()
+import { z as z27 } from "zod";
+var RateLimitEntrySchema = z27.object({
+  type: z27.literal("assistant"),
+  error: z27.literal("rate_limit"),
+  isApiErrorMessage: z27.literal(true),
+  sessionId: z27.string(),
+  message: z27.object({
+    content: z27.array(
+      z27.object({
+        type: z27.literal("text"),
+        text: z27.string()
       })
     )
   })
@@ -6505,6 +6599,12 @@ var extractSearchableText = (conversation) => {
   if (conversation.type === "assistant") {
     return extractAssistantText(conversation);
   }
+  if (conversation.type === "custom-title") {
+    return conversation.customTitle;
+  }
+  if (conversation.type === "agent-name") {
+    return null;
+  }
   return null;
 };
 var extractUserText = (entry) => {
@@ -6972,7 +7072,7 @@ var hasAgentId = (toolUseResult) => {
 };
 var buildSidechainData = (conversations) => {
   const sidechainConversations = conversations.filter(
-    (conv) => conv.type !== "summary" && conv.type !== "file-history-snapshot" && conv.type !== "queue-operation" && conv.type !== "progress" && conv.isSidechain === true
+    (conv) => conv.type !== "summary" && conv.type !== "file-history-snapshot" && conv.type !== "queue-operation" && conv.type !== "progress" && conv.type !== "custom-title" && conv.type !== "agent-name" && conv.isSidechain === true
   );
   const uuidMap = new Map(
     sidechainConversations.map((conv) => [conv.uuid, conv])
@@ -7441,7 +7541,7 @@ var generateSessionHtml = (session, projectId, agentSessionRepo) => Effect44.gen
   const existingAgentIds = /* @__PURE__ */ new Set();
   for (const conv of session.conversations) {
     if (conv.type === "x-error") continue;
-    if (conv.type !== "summary" && conv.type !== "file-history-snapshot" && conv.type !== "queue-operation" && conv.type !== "progress" && conv.isSidechain === true && conv.agentId !== void 0) {
+    if (conv.type !== "summary" && conv.type !== "file-history-snapshot" && conv.type !== "queue-operation" && conv.type !== "progress" && conv.type !== "custom-title" && conv.type !== "agent-name" && conv.isSidechain === true && conv.agentId !== void 0) {
       existingAgentIds.add(conv.agentId);
     }
   }
@@ -8427,40 +8527,40 @@ import { FileSystem as FileSystem17, Path as Path19 } from "@effect/platform";
 import { Context as Context36, Effect as Effect46, Layer as Layer38, Option as Option4 } from "effect";
 
 // src/server/core/tasks/schema.ts
-import { z as z26 } from "zod";
-var TaskStatusSchema = z26.enum([
+import { z as z28 } from "zod";
+var TaskStatusSchema = z28.enum([
   "pending",
   "in_progress",
   "completed",
   "failed"
 ]);
-var TaskSchema = z26.object({
-  id: z26.string(),
-  subject: z26.string(),
-  description: z26.string().optional(),
+var TaskSchema = z28.object({
+  id: z28.string(),
+  subject: z28.string(),
+  description: z28.string().optional(),
   status: TaskStatusSchema,
-  owner: z26.string().optional(),
-  blocks: z26.array(z26.string()).optional(),
-  blockedBy: z26.array(z26.string()).optional(),
-  metadata: z26.record(z26.string(), z26.any()).optional(),
-  activeForm: z26.string().optional()
+  owner: z28.string().optional(),
+  blocks: z28.array(z28.string()).optional(),
+  blockedBy: z28.array(z28.string()).optional(),
+  metadata: z28.record(z28.string(), z28.any()).optional(),
+  activeForm: z28.string().optional()
 });
-var TaskCreateSchema = z26.object({
-  subject: z26.string(),
-  description: z26.string().optional(),
-  activeForm: z26.string().optional(),
-  metadata: z26.record(z26.string(), z26.any()).optional()
+var TaskCreateSchema = z28.object({
+  subject: z28.string(),
+  description: z28.string().optional(),
+  activeForm: z28.string().optional(),
+  metadata: z28.record(z28.string(), z28.any()).optional()
 });
-var TaskUpdateSchema = z26.object({
-  taskId: z26.string(),
+var TaskUpdateSchema = z28.object({
+  taskId: z28.string(),
   status: TaskStatusSchema.optional(),
-  subject: z26.string().optional(),
-  description: z26.string().optional(),
-  activeForm: z26.string().optional(),
-  owner: z26.string().optional(),
-  addBlockedBy: z26.array(z26.string()).optional(),
-  addBlocks: z26.array(z26.string()).optional(),
-  metadata: z26.record(z26.string(), z26.any()).optional()
+  subject: z28.string().optional(),
+  description: z28.string().optional(),
+  activeForm: z28.string().optional(),
+  owner: z28.string().optional(),
+  addBlockedBy: z28.array(z28.string()).optional(),
+  addBlocks: z28.array(z28.string()).optional(),
+  metadata: z28.record(z28.string(), z28.any()).optional()
 });
 
 // src/server/core/tasks/services/TasksService.ts
@@ -8758,6 +8858,41 @@ var TasksController = class extends Context37.Tag("TasksController")() {
 // src/server/core/terminal/TerminalService.ts
 import { Context as Context38, Effect as Effect48, Layer as Layer40 } from "effect";
 import { ulid as ulid5 } from "ulid";
+
+// src/server/core/terminal/normalizePtyChunk.ts
+var normalizePtyChunk = (chunk) => {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return null;
+};
+
+// src/server/core/terminal/rusptyAdapter.ts
+var createRusptySession = (ruspty, options) => {
+  const pty = new ruspty.Pty(options);
+  return {
+    process: {
+      write: (data) => {
+        pty.write.write(data);
+      },
+      resize: (cols, rows) => {
+        pty.resize({ cols, rows });
+      },
+      kill: () => {
+        pty.close();
+      }
+    },
+    read: pty.read
+  };
+};
+
+// src/server/core/terminal/TerminalService.ts
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
 var MAX_BUFFER_BYTES = 1024 * 1024 * 2;
@@ -8794,9 +8929,9 @@ var LayerImpl30 = Effect48.gen(function* () {
       snapshotSince: () => Effect48.succeed(void 0)
     };
   };
-  const nodePty = yield* Effect48.tryPromise({
-    try: () => import("node-pty"),
-    catch: (error) => new Error(`Failed to load node-pty: ${String(error)}`)
+  const ruspty = yield* Effect48.tryPromise({
+    try: () => import("@replit/ruspty"),
+    catch: (error) => new Error(`Failed to load @replit/ruspty: ${String(error)}`)
   }).pipe(
     Effect48.catchAll(
       (error) => Effect48.sync(() => {
@@ -8805,10 +8940,9 @@ var LayerImpl30 = Effect48.gen(function* () {
       })
     )
   );
-  if (!nodePty) {
-    return disabledService("node-pty failed to load");
+  if (!ruspty) {
+    return disabledService("@replit/ruspty failed to load");
   }
-  const { spawn } = nodePty;
   const trimBuffer = (session) => {
     while (session.bufferBytes > MAX_BUFFER_BYTES && session.buffer.length > 0) {
       const removed = session.buffer.shift();
@@ -8864,16 +8998,26 @@ var LayerImpl30 = Effect48.gen(function* () {
       options.fallbackShell,
       options.unrestrictedFlag
     );
-    const pty = spawn(shell.command, shell.args, {
-      name: "xterm-color",
-      cols: DEFAULT_COLS,
-      rows: DEFAULT_ROWS,
-      cwd: options.cwd,
-      env: options.env
+    const { process: ptyProcess, read } = createRusptySession(ruspty, {
+      command: shell.command,
+      args: shell.args,
+      envs: options.env,
+      dir: options.cwd,
+      size: { cols: DEFAULT_COLS, rows: DEFAULT_ROWS },
+      onExit: (_error, exitCode) => {
+        const current = sessions.get(id);
+        if (!current) return;
+        current.exited = true;
+        current.lastActivity = Date.now();
+        broadcast(current, { type: "exit", code: exitCode });
+        if (current.clients.size === 0) {
+          destroySession(current.id);
+        }
+      }
     });
     const session = {
       id,
-      pty,
+      pty: ptyProcess,
       seq: 0,
       buffer: [],
       bufferBytes: 0,
@@ -8882,27 +9026,22 @@ var LayerImpl30 = Effect48.gen(function* () {
       exited: false,
       inputBuffer: ""
     };
-    pty.onData((data) => {
-      if (session.exited) return;
-      session.lastActivity = Date.now();
-      session.seq += 1;
-      session.buffer.push({ seq: session.seq, data });
-      session.bufferBytes += Buffer.byteLength(data, "utf8");
-      trimBuffer(session);
-      broadcast(session, {
+    read.on("data", (chunk) => {
+      const data = normalizePtyChunk(chunk);
+      if (data === null) return;
+      const current = sessions.get(session.id);
+      if (!current || current.exited) return;
+      current.lastActivity = Date.now();
+      current.seq += 1;
+      current.buffer.push({ seq: current.seq, data });
+      current.bufferBytes += Buffer.byteLength(data, "utf8");
+      trimBuffer(current);
+      broadcast(current, {
         type: "output",
-        seq: session.seq,
+        seq: current.seq,
         data
       });
     });
-    pty.onExit((event) => {
-      session.exited = true;
-      session.lastActivity = Date.now();
-      broadcast(session, { type: "exit", code: event.exitCode });
-      if (session.clients.size === 0) {
-        destroySession(session.id);
-      }
-    });
     sessions.set(id, session);
     return session;
   };
@@ -9139,7 +9278,15 @@ var generateSessionToken = (password) => {
   if (!password) return "";
   return Buffer.from(`ccv-session:${password}`).toString("base64");
 };
-var createAuthRequiredMiddleware = (authEnabled, validSessionToken) => {
+var getBearerToken = (authorization) => {
+  if (!authorization) return void 0;
+  const [scheme, token] = authorization.split(" ");
+  if (!scheme || !token) return void 0;
+  if (scheme.toLowerCase() !== "bearer") return void 0;
+  const trimmedToken = token.trim();
+  return trimmedToken.length > 0 ? trimmedToken : void 0;
+};
+var createAuthRequiredMiddleware = (authEnabled, validSessionToken, authPassword) => {
   return createMiddleware(async (c, next) => {
     if (!c.req.path.startsWith("/api")) {
       return next();
@@ -9148,7 +9295,10 @@ var createAuthRequiredMiddleware = (authEnabled, validSessionToken) => {
       return next();
     }
     const sessionToken = getCookie(c, "ccv-session");
-    if (!sessionToken || sessionToken !== validSessionToken) {
+    const bearerToken = getBearerToken(c.req.header("Authorization"));
+    const cookieAuthorized = sessionToken === validSessionToken;
+    const bearerAuthorized = authPassword !== void 0 && bearerToken === authPassword;
+    if (!cookieAuthorized && !bearerAuthorized) {
       return c.json({ error: "Unauthorized" }, 401);
     }
     await next();
@@ -9170,11 +9320,12 @@ var LayerImpl31 = Effect50.gen(function* () {
         if (!c.req.path.startsWith("/api")) {
           return next();
         }
-        const { authEnabled, validSessionToken } = await runPromise(getAuthState);
-        return createAuthRequiredMiddleware(authEnabled, validSessionToken)(
-          c,
-          next
-        );
+        const { authEnabled, validSessionToken, authPassword } = await runPromise(getAuthState);
+        return createAuthRequiredMiddleware(
+          authEnabled,
+          validSessionToken,
+          authPassword
+        )(c, next);
       }
     );
     return {
@@ -9193,25 +9344,26 @@ var AuthMiddleware = class extends Context40.Tag("AuthMiddleware")() {
 import { zValidator as zValidator8 } from "@hono/zod-validator";
 import { Effect as Effect62, Runtime as Runtime5 } from "effect";
 import { setCookie as setCookie3 } from "hono/cookie";
+import { createMiddleware as createMiddleware3 } from "hono/factory";
 import prexit from "prexit";
 
 // src/server/lib/config/config.ts
-import z28 from "zod";
+import z30 from "zod";
 
 // src/lib/i18n/schema.ts
-import z27 from "zod";
-var localeSchema = z27.enum(["ja", "en", "zh_CN"]);
+import z29 from "zod";
+var localeSchema = z29.enum(["ja", "en", "zh_CN"]);
 
 // src/server/lib/config/config.ts
-var userConfigSchema = 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"),
+var userConfigSchema = z30.object({
+  hideNoUserMessageSession: z30.boolean().optional().default(true),
+  unifySameTitleSession: z30.boolean().optional().default(false),
+  enterKeyBehavior: z30.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+  permissionMode: z30.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
   locale: localeSchema.optional().default("en"),
-  theme: z28.enum(["light", "dark", "system"]).optional().default("system"),
-  searchHotkey: z28.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
-  autoScheduleContinueOnRateLimit: z28.boolean().optional().default(false)
+  theme: z30.enum(["light", "dark", "system"]).optional().default("system"),
+  searchHotkey: z30.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
+  autoScheduleContinueOnRateLimit: z30.boolean().optional().default(false)
 });
 var defaultUserConfig = userConfigSchema.parse({});
 
@@ -9261,13 +9413,13 @@ import { zValidator } from "@hono/zod-validator";
 import { Effect as Effect52 } from "effect";
 import { Hono as Hono2 } from "hono";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 var authRoutes = Effect52.gen(function* () {
   const { getAuthState } = yield* AuthMiddleware;
   const { validSessionToken, authEnabled, authPassword } = yield* getAuthState;
   return new Hono2().post(
     "/login",
-    zValidator("json", z29.object({ password: z29.string() })),
+    zValidator("json", z31.object({ password: z31.string() })),
     async (c) => {
       const { password } = c.req.valid("json");
       if (!authEnabled) {
@@ -9306,75 +9458,75 @@ var authRoutes = Effect52.gen(function* () {
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Effect as Effect54 } from "effect";
 import { Hono as Hono3 } from "hono";
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 
 // src/server/core/claude-code/schema.ts
-import { z as z30 } from "zod";
-var mediaTypeSchema = z30.enum([
+import { z as z32 } from "zod";
+var mediaTypeSchema = z32.enum([
   "image/png",
   "image/jpeg",
   "image/gif",
   "image/webp"
 ]);
-var imageBlockSchema = z30.object({
-  type: z30.literal("image"),
-  source: z30.object({
-    type: z30.literal("base64"),
+var imageBlockSchema = z32.object({
+  type: z32.literal("image"),
+  source: z32.object({
+    type: z32.literal("base64"),
     media_type: mediaTypeSchema,
-    data: z30.string()
+    data: z32.string()
   })
 });
-var documentBlockSchema = z30.object({
-  type: z30.literal("document"),
-  source: z30.union([
-    z30.object({
-      type: z30.literal("text"),
-      media_type: z30.enum(["text/plain"]),
-      data: z30.string()
+var documentBlockSchema = z32.object({
+  type: z32.literal("document"),
+  source: z32.union([
+    z32.object({
+      type: z32.literal("text"),
+      media_type: z32.enum(["text/plain"]),
+      data: z32.string()
     }),
-    z30.object({
-      type: z30.literal("base64"),
-      media_type: z30.enum(["application/pdf"]),
-      data: z30.string()
+    z32.object({
+      type: z32.literal("base64"),
+      media_type: z32.enum(["application/pdf"]),
+      data: z32.string()
     })
   ])
 });
-var userMessageInputSchema = z30.object({
-  text: z30.string().min(1),
-  images: z30.array(imageBlockSchema).optional(),
-  documents: z30.array(documentBlockSchema).optional()
+var userMessageInputSchema = z32.object({
+  text: z32.string().min(1),
+  images: z32.array(imageBlockSchema).optional(),
+  documents: z32.array(documentBlockSchema).optional()
 });
-var sandboxNetworkConfigSchema = z30.object({
-  allowedDomains: z30.array(z30.string()).optional(),
-  allowUnixSockets: z30.array(z30.string()).optional(),
-  allowAllUnixSockets: z30.boolean().optional(),
-  allowLocalBinding: z30.boolean().optional(),
-  httpProxyPort: z30.number().optional(),
-  socksProxyPort: z30.number().optional()
+var sandboxNetworkConfigSchema = z32.object({
+  allowedDomains: z32.array(z32.string()).optional(),
+  allowUnixSockets: z32.array(z32.string()).optional(),
+  allowAllUnixSockets: z32.boolean().optional(),
+  allowLocalBinding: z32.boolean().optional(),
+  httpProxyPort: z32.number().optional(),
+  socksProxyPort: z32.number().optional()
 });
-var sandboxSettingsSchema = z30.object({
-  enabled: z30.boolean().optional(),
-  autoAllowBashIfSandboxed: z30.boolean().optional(),
-  allowUnsandboxedCommands: z30.boolean().optional(),
+var sandboxSettingsSchema = z32.object({
+  enabled: z32.boolean().optional(),
+  autoAllowBashIfSandboxed: z32.boolean().optional(),
+  allowUnsandboxedCommands: z32.boolean().optional(),
   network: sandboxNetworkConfigSchema.optional()
 });
-var ccOptionsSchema = z30.object({
-  disallowedTools: z30.array(z30.string()).optional(),
-  settingSources: z30.array(z30.enum(["user", "project", "local"])).optional(),
-  systemPrompt: z30.union([
-    z30.string(),
-    z30.object({
-      type: z30.literal("preset"),
-      preset: z30.literal("claude_code"),
-      append: z30.string().optional()
+var ccOptionsSchema = z32.object({
+  disallowedTools: z32.array(z32.string()).optional(),
+  settingSources: z32.array(z32.enum(["user", "project", "local"])).optional(),
+  systemPrompt: z32.union([
+    z32.string(),
+    z32.object({
+      type: z32.literal("preset"),
+      preset: z32.literal("claude_code"),
+      append: z32.string().optional()
     })
   ]).optional(),
-  model: z30.string().optional(),
+  model: z32.string().optional(),
   sandbox: sandboxSettingsSchema.optional(),
-  maxTurns: z30.number().optional(),
-  maxThinkingTokens: z30.number().optional(),
-  env: z30.record(z30.string(), z30.string().optional()).optional(),
-  maxBudgetUsd: z30.number().optional()
+  maxTurns: z32.number().optional(),
+  maxThinkingTokens: z32.number().optional(),
+  env: z32.record(z32.string(), z32.string().optional()).optional(),
+  maxBudgetUsd: z32.number().optional()
 });
 
 // src/server/lib/effect/toEffectResponse.ts
@@ -9434,18 +9586,18 @@ var claudeCodeRoutes = Effect54.gen(function* () {
     "/session-processes",
     zValidator2(
       "json",
-      z31.object({
-        projectId: z31.string(),
+      z33.object({
+        projectId: z33.string(),
         input: userMessageInputSchema,
-        baseSession: z31.union([
-          z31.undefined(),
-          z31.object({
-            type: z31.literal("fork"),
-            sessionId: z31.string()
+        baseSession: z33.union([
+          z33.undefined(),
+          z33.object({
+            type: z33.literal("fork"),
+            sessionId: z33.string()
           }),
-          z31.object({
-            type: z31.literal("resume"),
-            sessionId: z31.string()
+          z33.object({
+            type: z33.literal("resume"),
+            sessionId: z33.string()
           })
         ]),
         ccOptions: ccOptionsSchema.optional()
@@ -9469,10 +9621,10 @@ var claudeCodeRoutes = Effect54.gen(function* () {
     "/session-processes/:sessionProcessId/continue",
     zValidator2(
       "json",
-      z31.object({
-        projectId: z31.string(),
+      z33.object({
+        projectId: z33.string(),
         input: userMessageInputSchema,
-        baseSessionId: z31.string()
+        baseSessionId: z33.string()
       })
     ),
     async (c) => {
@@ -9490,7 +9642,7 @@ var claudeCodeRoutes = Effect54.gen(function* () {
     }
   ).post(
     "/session-processes/:sessionProcessId/abort",
-    zValidator2("json", z31.object({ projectId: z31.string() })),
+    zValidator2("json", z33.object({ projectId: z33.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
       void Effect54.runFork(
@@ -9502,9 +9654,9 @@ var claudeCodeRoutes = Effect54.gen(function* () {
     "/permission-response",
     zValidator2(
       "json",
-      z31.object({
-        permissionRequestId: z31.string(),
-        decision: z31.enum(["allow", "deny"])
+      z33.object({
+        permissionRequestId: z33.string(),
+        decision: z33.enum(["allow", "deny"])
       })
     ),
     async (c) => {
@@ -9538,16 +9690,16 @@ var featureFlagRoutes = Effect55.gen(function* () {
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Effect as Effect56 } from "effect";
 import { Hono as Hono5 } from "hono";
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var fileSystemRoutes = Effect56.gen(function* () {
   const fileSystemController = yield* FileSystemController;
   return new Hono5().get(
     "/file-completion",
     zValidator3(
       "query",
-      z32.object({
-        projectId: z32.string(),
-        basePath: z32.string().optional().default("/api/")
+      z34.object({
+        projectId: z34.string(),
+        basePath: z34.string().optional().default("/api/")
       })
     ),
     async (c) => {
@@ -9563,9 +9715,9 @@ var fileSystemRoutes = Effect56.gen(function* () {
     "/directory-browser",
     zValidator3(
       "query",
-      z32.object({
-        currentPath: z32.string().optional(),
-        showHidden: z32.string().optional().transform((val) => val === "true")
+      z34.object({
+        currentPath: z34.string().optional(),
+        showHidden: z34.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {
@@ -9584,24 +9736,24 @@ var fileSystemRoutes = Effect56.gen(function* () {
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Effect as Effect57 } from "effect";
 import { Hono as Hono6 } from "hono";
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 
 // src/server/core/git/schema.ts
-import { z as z33 } from "zod";
-var CommitRequestSchema = z33.object({
-  files: z33.array(z33.string().min(1)).min(1),
-  message: z33.string().trim().min(1)
+import { z as z35 } from "zod";
+var CommitRequestSchema = z35.object({
+  files: z35.array(z35.string().min(1)).min(1),
+  message: z35.string().trim().min(1)
 });
-var CommitResultSuccessSchema = z33.object({
-  success: z33.literal(true),
-  commitSha: z33.string().length(40),
-  filesCommitted: z33.number().int().positive(),
-  message: z33.string()
+var CommitResultSuccessSchema = z35.object({
+  success: z35.literal(true),
+  commitSha: z35.string().length(40),
+  filesCommitted: z35.number().int().positive(),
+  message: z35.string()
 });
-var CommitResultErrorSchema = z33.object({
-  success: z33.literal(false),
-  error: z33.string(),
-  errorCode: z33.enum([
+var CommitResultErrorSchema = z35.object({
+  success: z35.literal(false),
+  error: z35.string(),
+  errorCode: z35.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -9609,22 +9761,22 @@ var CommitResultErrorSchema = z33.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z33.string().optional()
+  details: z35.string().optional()
 });
-var CommitResultSchema = z33.discriminatedUnion("success", [
+var CommitResultSchema = z35.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z33.object({
-  success: z33.literal(true),
-  remote: z33.string(),
-  branch: z33.string(),
-  objectsPushed: z33.number().int().optional()
+var PushResultSuccessSchema = z35.object({
+  success: z35.literal(true),
+  remote: z35.string(),
+  branch: z35.string(),
+  objectsPushed: z35.number().int().optional()
 });
-var PushResultErrorSchema = z33.object({
-  success: z33.literal(false),
-  error: z33.string(),
-  errorCode: z33.enum([
+var PushResultErrorSchema = z35.object({
+  success: z35.literal(false),
+  error: z35.string(),
+  errorCode: z35.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -9634,26 +9786,26 @@ var PushResultErrorSchema = z33.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z33.string().optional()
+  details: z35.string().optional()
 });
-var PushResultSchema = z33.discriminatedUnion("success", [
+var PushResultSchema = z35.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z33.object({
-  success: z33.literal(true),
-  commitSha: z33.string().length(40),
-  filesCommitted: z33.number().int().positive(),
-  message: z33.string(),
-  remote: z33.string(),
-  branch: z33.string()
+var CommitAndPushResultSuccessSchema = z35.object({
+  success: z35.literal(true),
+  commitSha: z35.string().length(40),
+  filesCommitted: z35.number().int().positive(),
+  message: z35.string(),
+  remote: z35.string(),
+  branch: z35.string()
 });
-var CommitAndPushResultErrorSchema = z33.object({
-  success: z33.literal(false),
-  commitSucceeded: z33.boolean(),
-  commitSha: z33.string().length(40).optional(),
-  error: z33.string(),
-  errorCode: z33.enum([
+var CommitAndPushResultErrorSchema = z35.object({
+  success: z35.literal(false),
+  commitSucceeded: z35.boolean(),
+  commitSha: z35.string().length(40).optional(),
+  error: z35.string(),
+  errorCode: z35.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -9666,9 +9818,9 @@ var CommitAndPushResultErrorSchema = z33.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z33.string().optional()
+  details: z35.string().optional()
 });
-var CommitAndPushResultSchema = z33.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z35.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
@@ -9690,7 +9842,7 @@ var projectRoutes = Effect57.gen(function* () {
     return response;
   }).get(
     "/:projectId",
-    zValidator4("query", z34.object({ cursor: z34.string().optional() })),
+    zValidator4("query", z36.object({ cursor: z36.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
@@ -9705,8 +9857,8 @@ var projectRoutes = Effect57.gen(function* () {
     "/",
     zValidator4(
       "json",
-      z34.object({
-        projectPath: z34.string().min(1, "Project path is required")
+      z36.object({
+        projectPath: z36.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -9750,15 +9902,35 @@ var projectRoutes = Effect57.gen(function* () {
       sessionController.deleteSession({ projectId, sessionId }).pipe(Effect57.provide(runtime))
     );
     return response;
-  }).get("/:projectId/agent-sessions/:agentId", async (c) => {
+  }).get("/:projectId/sessions/:sessionId/agent-sessions", async (c) => {
     const projectId = c.req.param("projectId");
-    const agentId = c.req.param("agentId");
+    const sessionId = c.req.param("sessionId");
     const response = await effectToResponse(
       c,
-      agentSessionController.getAgentSession({ projectId, agentId })
+      agentSessionController.listAgentSessions({
+        projectId,
+        sessionId
+      })
     );
     return response;
-  }).get("/:projectId/claude-commands", async (c) => {
+  }).get(
+    "/:projectId/agent-sessions/:agentId",
+    zValidator4("query", z36.object({ sessionId: z36.string().optional() })),
+    async (c) => {
+      const projectId = c.req.param("projectId");
+      const agentId = c.req.param("agentId");
+      const { sessionId } = c.req.valid("query");
+      const response = await effectToResponse(
+        c,
+        agentSessionController.getAgentSession({
+          projectId,
+          agentId,
+          sessionId
+        })
+      );
+      return response;
+    }
+  ).get("/:projectId/claude-commands", async (c) => {
     const response = await effectToResponse(
       c,
       claudeCodeController.getClaudeCommands({
@@ -9778,8 +9950,8 @@ var projectRoutes = Effect57.gen(function* () {
     "/:projectId/files",
     zValidator4(
       "query",
-      z34.object({
-        filePath: z34.string().min(1, "filePath is required")
+      z36.object({
+        filePath: z36.string().min(1, "filePath is required")
       })
     ),
     async (c) => {
@@ -9807,9 +9979,9 @@ var projectRoutes = Effect57.gen(function* () {
     "/:projectId/git/diff",
     zValidator4(
       "json",
-      z34.object({
-        fromRef: z34.string().min(1, "fromRef is required"),
-        toRef: z34.string().min(1, "toRef is required")
+      z36.object({
+        fromRef: z36.string().min(1, "fromRef is required"),
+        toRef: z36.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -9873,8 +10045,8 @@ var projectRoutes = Effect57.gen(function* () {
     "/:projectId/git/checkout",
     zValidator4(
       "json",
-      z34.object({
-        branchName: z34.string().min(1, "branchName is required")
+      z36.object({
+        branchName: z36.string().min(1, "branchName is required")
       })
     ),
     async (c) => {
@@ -9940,7 +10112,7 @@ var schedulerRoutes = Effect58.gen(function* () {
 import { zValidator as zValidator6 } from "@hono/zod-validator";
 import { Effect as Effect59 } from "effect";
 import { Hono as Hono8 } from "hono";
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 var searchRoutes = Effect59.gen(function* () {
   const searchController = yield* SearchController;
   const runtime = yield* getHonoRuntime;
@@ -9948,10 +10120,10 @@ var searchRoutes = Effect59.gen(function* () {
     "/",
     zValidator6(
       "query",
-      z35.object({
-        q: z35.string().min(2),
-        limit: z35.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
-        projectId: z35.string().optional()
+      z37.object({
+        q: z37.string().min(2),
+        limit: z37.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z37.string().optional()
       })
     ),
     async (c) => {
@@ -9972,7 +10144,7 @@ import { streamSSE } from "hono/streaming";
 var sseRoutes = Effect60.gen(function* () {
   const sseController = yield* SSEController;
   const runtime = yield* getHonoRuntime;
-  return new Hono9().get("/sse", async (c) => {
+  return new Hono9().get("/", async (c) => {
     return streamSSE(
       c,
       async (rawStream) => {
@@ -9991,7 +10163,7 @@ var sseRoutes = Effect60.gen(function* () {
 import { zValidator as zValidator7 } from "@hono/zod-validator";
 import { Effect as Effect61 } from "effect";
 import { Hono as Hono10 } from "hono";
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 var tasksRoutes = Effect61.gen(function* () {
   const tasksController = yield* TasksController;
   const runtime = yield* getHonoRuntime;
@@ -9999,9 +10171,9 @@ var tasksRoutes = Effect61.gen(function* () {
     "/",
     zValidator7(
       "query",
-      z36.object({
-        projectId: z36.string(),
-        sessionId: z36.string().optional()
+      z38.object({
+        projectId: z38.string(),
+        sessionId: z38.string().optional()
       })
     ),
     async (c) => {
@@ -10024,9 +10196,9 @@ var tasksRoutes = Effect61.gen(function* () {
     "/",
     zValidator7(
       "query",
-      z36.object({
-        projectId: z36.string(),
-        sessionId: z36.string().optional()
+      z38.object({
+        projectId: z38.string(),
+        sessionId: z38.string().optional()
       })
     ),
     zValidator7("json", TaskCreateSchema),
@@ -10051,9 +10223,9 @@ var tasksRoutes = Effect61.gen(function* () {
     "/:taskId",
     zValidator7(
       "query",
-      z36.object({
-        projectId: z36.string(),
-        sessionId: z36.string().optional()
+      z38.object({
+        projectId: z38.string(),
+        sessionId: z38.string().optional()
       })
     ),
     zValidator7("json", TaskUpdateSchema.omit({ taskId: true })),
@@ -10079,6 +10251,26 @@ var tasksRoutes = Effect61.gen(function* () {
 });
 
 // src/server/hono/routes/index.ts
+var API_ONLY_ALLOWED_PREFIXES = [
+  "/api/version",
+  "/api/config",
+  "/api/projects",
+  "/api/claude-code",
+  "/api/search",
+  "/api/sse"
+];
+var createApiOnlyMiddleware = (apiOnly) => createMiddleware3(async (c, next) => {
+  if (apiOnly) {
+    const path = c.req.path;
+    const allowed = API_ONLY_ALLOWED_PREFIXES.some(
+      (prefix) => path === prefix || path.startsWith(`${prefix}/`)
+    );
+    if (!allowed) {
+      return c.json({ error: "Not Found" }, 404);
+    }
+  }
+  return next();
+});
 var routes = (app, options) => Effect62.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
   yield* ccvOptionsService.loadCliOptions(options);
@@ -10086,6 +10278,8 @@ var routes = (app, options) => Effect62.gen(function* () {
   const userConfigService = yield* UserConfigService;
   const initializeService = yield* InitializeService;
   const { authRequiredMiddleware } = yield* AuthMiddleware;
+  const apiOnly = (yield* ccvOptionsService.getCcvOptions("apiOnly")) === true;
+  const apiOnlyMiddleware = createApiOnlyMiddleware(apiOnly);
   const runtime = yield* getHonoRuntime;
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
@@ -10093,7 +10287,7 @@ var routes = (app, options) => Effect62.gen(function* () {
       await Runtime5.runPromise(runtime)(initializeService.stopCleanup());
     });
   }
-  return app.use(configMiddleware).use(async (c, next) => {
+  return app.use(configMiddleware).use(apiOnlyMiddleware).use(async (c, next) => {
     await Runtime5.runPromise(
       runtime,
       userConfigService.setUserConfig({
@@ -10267,7 +10461,8 @@ var setupTerminalWebSocket = (server) => Effect63.gen(function* () {
 // src/server/startServer.ts
 var startServer = async (options) => {
   const isDevelopment = isDevelopmentEnv(process.env.CCV_ENV);
-  if (!isDevelopment) {
+  const apiOnly = options.apiOnly === true;
+  if (!isDevelopment && !apiOnly) {
     const staticPath = resolve7(import.meta.dirname, "static");
     console.log("Serving static files from ", staticPath);
     honoApp.use(
@@ -10289,7 +10484,9 @@ var startServer = async (options) => {
   });
   const program2 = Effect64.gen(function* () {
     yield* routes(honoApp, options);
-    yield* setupTerminalWebSocket(server);
+    if (!apiOnly) {
+      yield* setupTerminalWebSocket(server);
+    }
   }).pipe(Effect64.provide(MainLayer), Effect64.scoped);
   await Effect64.runPromise(program2);
   const port = isDevelopment ? (
@@ -10303,7 +10500,8 @@ var startServer = async (options) => {
   server.listen(parseInt(port, 10), hostname, () => {
     const info = server.address();
     const serverPort = typeof info === "object" && info !== null ? info.port : port;
-    console.log(`Server is running on http://${hostname}:${serverPort}`);
+    const mode = apiOnly ? " (API-only mode)" : "";
+    console.log(`Server is running on http://${hostname}:${serverPort}${mode}`);
   });
 };
 var PlatformLayer = Layer44.mergeAll(platformLayer, NodeContext2.layer);
@@ -10370,7 +10568,7 @@ program.option("-p, --port <port>", "port to listen on").option("-h, --hostname
 ).option("--terminal-shell <path>", "shell executable for terminal sessions").option(
   "--terminal-unrestricted",
   "disable restricted shell flags for bash sessions"
-).action(async (options) => {
+).option("--api-only", "run in API-only mode without Web UI").action(async (options) => {
   await Effect65.runPromise(checkDeprecatedEnvs);
   await startServer(options);
 });