@kimuson/claude-code-viewer 0.7.1 → 0.7.3

package/dist/main.js

@@ -12,7 +12,7 @@ import { Effect as Effect73 } from "effect";
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.7.1",
+  version: "0.7.3",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   homepage: "https://github.com/d-kimuson/claude-code-viewer",
   license: "MIT",
@@ -263,10 +263,10 @@ import { Layer as Layer6 } from "effect";
 // src/server/core/agent-session/infrastructure/AgentSessionRepository.ts
 import { FileSystem, Path as Path2 } from "@effect/platform";
 import { Context as Context3, Effect as Effect5, Layer as Layer4 } from "effect";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/lib/conversation-schema/index.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/lib/conversation-schema/entry/AgentNameEntrySchema.ts
 import { z } from "zod";
@@ -411,204 +411,232 @@ var AssistantEntrySchema = BaseEntrySchema.extend({
   isApiErrorMessage: z11.boolean().optional()
 });
 
-// src/lib/conversation-schema/entry/CustomTitleEntrySchema.ts
+// src/lib/conversation-schema/entry/AttachmentEntrySchema.ts
 import { z as z12 } from "zod";
-var CustomTitleEntrySchema = z12.object({
-  type: z12.literal("custom-title"),
-  customTitle: z12.string(),
-  sessionId: z12.string()
+var AttachmentBaseEntrySchema = BaseEntrySchema.extend({
+  type: z12.literal("attachment"),
+  entrypoint: z12.string().optional(),
+  slug: z12.string().optional()
+});
+var DeferredToolsDeltaSchema = AttachmentBaseEntrySchema.extend({
+  attachment: z12.object({
+    type: z12.literal("deferred_tools_delta"),
+    addedNames: z12.array(z12.string()),
+    addedLines: z12.array(z12.string()),
+    removedNames: z12.array(z12.string())
+  })
 });
+var McpInstructionsDeltaSchema = AttachmentBaseEntrySchema.extend({
+  attachment: z12.object({
+    type: z12.literal("mcp_instructions_delta"),
+    addedNames: z12.array(z12.string()),
+    addedBlocks: z12.array(z12.string()),
+    removedNames: z12.array(z12.string())
+  })
+});
+var AttachmentEntrySchema = z12.union([
+  DeferredToolsDeltaSchema,
+  McpInstructionsDeltaSchema
+]);
 
-// src/lib/conversation-schema/entry/FileHIstorySnapshotEntrySchema.ts
+// src/lib/conversation-schema/entry/CustomTitleEntrySchema.ts
 import { z as z13 } from "zod";
-var FileHistorySnapshotEntrySchema = z13.object({
+var CustomTitleEntrySchema = z13.object({
+  type: z13.literal("custom-title"),
+  customTitle: z13.string(),
+  sessionId: z13.string()
+});
+
+// src/lib/conversation-schema/entry/FileHIstorySnapshotEntrySchema.ts
+import { z as z14 } from "zod";
+var FileHistorySnapshotEntrySchema = z14.object({
   // discriminator
-  type: z13.literal("file-history-snapshot"),
+  type: z14.literal("file-history-snapshot"),
   // required
-  messageId: z13.string(),
-  snapshot: z13.object({
-    messageId: z13.string(),
-    trackedFileBackups: z13.record(z13.string(), z13.unknown()),
-    timestamp: z13.string()
+  messageId: z14.string(),
+  snapshot: z14.object({
+    messageId: z14.string(),
+    trackedFileBackups: z14.record(z14.string(), z14.unknown()),
+    timestamp: z14.string()
   }),
-  isSnapshotUpdate: z13.boolean()
+  isSnapshotUpdate: z14.boolean()
 });
 
 // src/lib/conversation-schema/entry/LastPromptEntrySchema.ts
-import { z as z14 } from "zod";
-var LastPromptEntrySchema = z14.object({
-  type: z14.literal("last-prompt"),
-  lastPrompt: z14.string(),
-  sessionId: z14.string()
+import { z as z15 } from "zod";
+var LastPromptEntrySchema = z15.object({
+  type: z15.literal("last-prompt"),
+  lastPrompt: z15.string(),
+  sessionId: z15.string()
 });
 
 // src/lib/conversation-schema/entry/PermissionModeEntrySchema.ts
-import { z as z15 } from "zod";
-var PermissionModeEntrySchema = z15.object({
-  type: z15.literal("permission-mode"),
-  permissionMode: z15.string(),
-  sessionId: z15.string()
+import { z as z16 } from "zod";
+var PermissionModeEntrySchema = z16.object({
+  type: z16.literal("permission-mode"),
+  permissionMode: z16.string(),
+  sessionId: z16.string()
 });
 
 // src/lib/conversation-schema/entry/PrLinkEntrySchema.ts
-import { z as z16 } from "zod";
-var PrLinkEntrySchema = z16.object({
-  type: z16.literal("pr-link"),
-  sessionId: z16.string(),
-  prNumber: z16.number(),
-  prUrl: z16.string(),
-  prRepository: z16.string(),
-  timestamp: z16.iso.datetime()
+import { z as z17 } from "zod";
+var PrLinkEntrySchema = z17.object({
+  type: z17.literal("pr-link"),
+  sessionId: z17.string(),
+  prNumber: z17.number(),
+  prUrl: z17.string(),
+  prRepository: z17.string(),
+  timestamp: z17.iso.datetime()
 });
 
 // src/lib/conversation-schema/entry/ProgressEntrySchema.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var ProgressEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z17.literal("progress"),
+  type: z18.literal("progress"),
   // required
-  data: z17.record(z17.string(), z17.any()),
-  toolUseID: z17.string().optional(),
-  parentToolUseID: z17.string().optional()
+  data: z18.record(z18.string(), z18.any()),
+  toolUseID: z18.string().optional(),
+  parentToolUseID: z18.string().optional()
 });
 
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/lib/conversation-schema/content/DocumentContentSchema.ts
-import { z as z18 } from "zod";
-var DocumentContentSchema = z18.object({
-  type: z18.literal("document"),
-  source: z18.union([
-    z18.object({
-      media_type: z18.literal("text/plain"),
-      type: z18.literal("text"),
-      data: z18.string()
+import { z as z19 } from "zod";
+var DocumentContentSchema = z19.object({
+  type: z19.literal("document"),
+  source: z19.union([
+    z19.object({
+      media_type: z19.literal("text/plain"),
+      type: z19.literal("text"),
+      data: z19.string()
     }),
-    z18.object({
-      media_type: z18.enum(["application/pdf"]),
-      type: z18.literal("base64"),
-      data: z18.string()
+    z19.object({
+      media_type: z19.enum(["application/pdf"]),
+      type: z19.literal("base64"),
+      data: z19.string()
     })
   ])
 });
 
 // src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
-var QueueOperationContentSchema = z19.union([
-  z19.string(),
+var QueueOperationContentSchema = z20.union([
+  z20.string(),
   TextContentSchema,
   ToolResultContentSchema,
   ImageContentSchema,
   DocumentContentSchema
 ]);
-var QueueOperationEntrySchema = z19.union([
-  z19.object({
-    type: z19.literal("queue-operation"),
-    operation: z19.literal("enqueue"),
-    content: z19.union([z19.string(), z19.array(z19.union([z19.string(), QueueOperationContentSchema]))]).optional(),
-    sessionId: z19.string(),
-    timestamp: z19.iso.datetime()
+var QueueOperationEntrySchema = z20.union([
+  z20.object({
+    type: z20.literal("queue-operation"),
+    operation: z20.literal("enqueue"),
+    content: z20.union([z20.string(), z20.array(z20.union([z20.string(), QueueOperationContentSchema]))]).optional(),
+    sessionId: z20.string(),
+    timestamp: z20.iso.datetime()
   }),
-  z19.object({
-    type: z19.literal("queue-operation"),
-    operation: z19.literal("dequeue"),
-    sessionId: z19.string(),
-    timestamp: z19.iso.datetime()
+  z20.object({
+    type: z20.literal("queue-operation"),
+    operation: z20.literal("dequeue"),
+    sessionId: z20.string(),
+    timestamp: z20.iso.datetime()
   }),
-  z19.object({
-    type: z19.literal("queue-operation"),
-    operation: z19.literal("remove"),
-    sessionId: z19.string(),
-    timestamp: z19.iso.datetime()
+  z20.object({
+    type: z20.literal("queue-operation"),
+    operation: z20.literal("remove"),
+    sessionId: z20.string(),
+    timestamp: z20.iso.datetime()
   }),
-  z19.object({
-    type: z19.literal("queue-operation"),
-    operation: z19.literal("popAll"),
-    sessionId: z19.string(),
-    timestamp: z19.iso.datetime(),
-    content: z19.string().optional()
+  z20.object({
+    type: z20.literal("queue-operation"),
+    operation: z20.literal("popAll"),
+    sessionId: z20.string(),
+    timestamp: z20.iso.datetime(),
+    content: z20.string().optional()
   })
 ]);
 
 // src/lib/conversation-schema/entry/SummaryEntrySchema.ts
-import { z as z20 } from "zod";
-var SummaryEntrySchema = z20.object({
-  type: z20.literal("summary"),
-  summary: z20.string(),
-  leafUuid: z20.uuid()
+import { z as z21 } from "zod";
+var SummaryEntrySchema = z21.object({
+  type: z21.literal("summary"),
+  summary: z21.string(),
+  leafUuid: z21.uuid()
 });
 
 // src/lib/conversation-schema/entry/SystemEntrySchema.ts
-import { z as z21 } from "zod";
-var HookInfoSchema = z21.object({
-  command: z21.string()
+import { z as z22 } from "zod";
+var HookInfoSchema = z22.object({
+  command: z22.string()
 });
 var SystemEntryWithContentSchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  content: z21.string(),
-  toolUseID: z21.string(),
-  level: z21.enum(["info"]),
-  subtype: z21.undefined().optional()
+  type: z22.literal("system"),
+  content: z22.string(),
+  toolUseID: z22.string(),
+  level: z22.enum(["info"]),
+  subtype: z22.undefined().optional()
 });
 var StopHookSummaryEntrySchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  subtype: z21.literal("stop_hook_summary"),
-  toolUseID: z21.string(),
-  level: z21.enum(["info", "suggestion"]),
-  slug: z21.string().optional(),
-  hookCount: z21.number(),
-  hookInfos: z21.array(HookInfoSchema),
-  hookErrors: z21.array(z21.unknown()),
-  preventedContinuation: z21.boolean(),
-  stopReason: z21.string(),
-  hasOutput: z21.boolean()
+  type: z22.literal("system"),
+  subtype: z22.literal("stop_hook_summary"),
+  toolUseID: z22.string(),
+  level: z22.enum(["info", "suggestion"]),
+  slug: z22.string().optional(),
+  hookCount: z22.number(),
+  hookInfos: z22.array(HookInfoSchema),
+  hookErrors: z22.array(z22.unknown()),
+  preventedContinuation: z22.boolean(),
+  stopReason: z22.string(),
+  hasOutput: z22.boolean()
 });
 var LocalCommandEntrySchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  subtype: z21.literal("local_command"),
-  content: z21.string(),
-  level: z21.enum(["info"])
+  type: z22.literal("system"),
+  subtype: z22.literal("local_command"),
+  content: z22.string(),
+  level: z22.enum(["info"])
 });
 var TurnDurationEntrySchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  subtype: z21.literal("turn_duration"),
-  durationMs: z21.number(),
-  slug: z21.string().optional()
+  type: z22.literal("system"),
+  subtype: z22.literal("turn_duration"),
+  durationMs: z22.number(),
+  slug: z22.string().optional()
 });
 var CompactBoundaryEntrySchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  subtype: z21.literal("compact_boundary"),
-  content: z21.string(),
-  level: z21.enum(["info"]),
-  slug: z21.string().optional(),
-  logicalParentUuid: z21.string().optional(),
-  compactMetadata: z21.object({
-    trigger: z21.string(),
-    preTokens: z21.number()
+  type: z22.literal("system"),
+  subtype: z22.literal("compact_boundary"),
+  content: z22.string(),
+  level: z22.enum(["info"]),
+  slug: z22.string().optional(),
+  logicalParentUuid: z22.string().optional(),
+  compactMetadata: z22.object({
+    trigger: z22.string(),
+    preTokens: z22.number()
   }).optional()
 });
 var ApiErrorEntrySchema = BaseEntrySchema.extend({
-  type: z21.literal("system"),
-  subtype: z21.literal("api_error"),
-  level: z21.enum(["error", "warning", "info"]),
-  error: z21.object({
-    status: z21.number().optional(),
-    headers: z21.record(z21.string(), z21.unknown()).optional(),
-    requestID: z21.string().nullable().optional(),
-    error: z21.object({
-      type: z21.string(),
-      error: z21.object({
-        type: z21.string(),
-        message: z21.string()
+  type: z22.literal("system"),
+  subtype: z22.literal("api_error"),
+  level: z22.enum(["error", "warning", "info"]),
+  error: z22.object({
+    status: z22.number().optional(),
+    headers: z22.record(z22.string(), z22.unknown()).optional(),
+    requestID: z22.string().nullable().optional(),
+    error: z22.object({
+      type: z22.string(),
+      error: z22.object({
+        type: z22.string(),
+        message: z22.string()
       }).optional(),
-      message: z21.string().optional()
+      message: z22.string().optional()
     }).optional()
   }),
-  retryInMs: z21.number().optional(),
-  retryAttempt: z21.number().optional(),
-  maxRetries: z21.number().optional()
+  retryInMs: z22.number().optional(),
+  retryAttempt: z22.number().optional(),
+  maxRetries: z22.number().optional()
 });
-var SystemEntrySchema = z21.union([
+var SystemEntrySchema = z22.union([
   StopHookSummaryEntrySchema,
   LocalCommandEntrySchema,
   TurnDurationEntrySchema,
@@ -619,32 +647,32 @@ var SystemEntrySchema = z21.union([
 ]);
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/lib/conversation-schema/message/UserMessageSchema.ts
-import { z as z22 } from "zod";
-var UserMessageContentSchema = z22.union([
-  z22.string(),
+import { z as z23 } from "zod";
+var UserMessageContentSchema = z23.union([
+  z23.string(),
   TextContentSchema,
   ToolResultContentSchema,
   ImageContentSchema,
   DocumentContentSchema
 ]);
-var UserMessageSchema = z22.object({
-  role: z22.literal("user"),
-  content: z22.union([z22.string(), z22.array(z22.union([z22.string(), UserMessageContentSchema]))])
+var UserMessageSchema = z23.object({
+  role: z23.literal("user"),
+  content: z23.union([z23.string(), z23.array(z23.union([z23.string(), UserMessageContentSchema]))])
 });
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
 var UserEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z23.literal("user"),
+  type: z24.literal("user"),
   // required
   message: UserMessageSchema
 });
 
 // src/lib/conversation-schema/index.ts
-var ConversationSchema = z24.union([
+var ConversationSchema = z25.union([
   UserEntrySchema,
   AssistantEntrySchema,
   SummaryEntrySchema,
@@ -657,7 +685,8 @@ var ConversationSchema = z24.union([
   AgentSettingEntrySchema,
   PermissionModeEntrySchema,
   PrLinkEntrySchema,
-  LastPromptEntrySchema
+  LastPromptEntrySchema,
+  AttachmentEntrySchema
 ]);
 
 // src/server/core/claude-code/functions/parseJsonl.ts
@@ -741,17 +770,17 @@ var CcvOptionsService = class extends Context.Tag("CcvOptionsService")() {
 import { Context as Context2, Effect as Effect3, Layer as Layer2, Ref as Ref2 } from "effect";
 
 // src/server/core/platform/schema.ts
-import { z as z25 } from "zod";
-var envSchema = z25.object({
+import { z as z26 } from "zod";
+var envSchema = z26.object({
   // Frameworks
-  CCV_ENV: z25.enum(["development", "production", "test"]).optional().default("development"),
-  NEXT_PHASE: z25.string().optional(),
-  HOME: 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()
+  CCV_ENV: z26.enum(["development", "production", "test"]).optional().default("development"),
+  NEXT_PHASE: z26.string().optional(),
+  HOME: z26.string().optional(),
+  PATH: z26.string().optional(),
+  SHELL: z26.string().optional(),
+  CCV_TERMINAL_SHELL: z26.string().optional(),
+  CCV_TERMINAL_UNRESTRICTED: z26.string().optional(),
+  CCV_TERMINAL_DISABLED: z26.string().optional()
 });
 
 // src/server/core/platform/services/EnvService.ts
@@ -969,7 +998,7 @@ var LayerImpl4 = Effect5.gen(function* () {
       if (firstLine === void 0 || firstLine.trim() === "") continue;
       try {
         const parsed = JSON.parse(firstLine);
-        const sessionIdResult = z26.object({ sessionId: z26.string() }).safeParse(parsed);
+        const sessionIdResult = z27.object({ sessionId: z27.string() }).safeParse(parsed);
         if (sessionIdResult.success && sessionIdResult.data.sessionId === sessionId) {
           yield* processFile(filePath, filename).pipe(Effect5.catchAll(() => Effect5.void));
         }
@@ -1040,7 +1069,7 @@ var AgentSessionLayer = Layer6.mergeAll(AgentSessionRepository.Live);
 // src/server/core/claude-code/infrastructure/SessionAllowlistRepository.ts
 import { eq } from "drizzle-orm";
 import { Context as Context6, Effect as Effect8, Layer as Layer8 } from "effect";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/server/lib/db/DrizzleService.ts
 import { DatabaseSync } from "node:sqlite";
@@ -1153,7 +1182,7 @@ var DrizzleService = class extends Context5.Tag("DrizzleService")() {
 };
 
 // src/server/core/claude-code/infrastructure/SessionAllowlistRepository.ts
-var allowlistSchema = z27.array(z27.string());
+var allowlistSchema = z28.array(z28.string());
 var LayerImpl6 = Effect8.gen(function* () {
   const { db } = yield* DrizzleService;
   const getAllowlist = (sessionId) => Effect8.sync(() => {
@@ -1195,7 +1224,7 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 import { Context as Context8, Deferred, Effect as Effect10, Layer as Layer10, Ref as Ref3 } from "effect";
 import { ulid } from "ulid";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // src/server/core/events/services/EventBus.ts
 import { Context as Context7, Effect as Effect9, Layer as Layer9 } from "effect";
@@ -1303,18 +1332,18 @@ var LayerImpl7 = Effect10.gen(function* () {
   const createMcpServer = (options) => {
     const { turnId, projectId, sessionId } = options;
     const questionInputSchema = {
-      questions: z28.array(
-        z28.object({
-          question: z28.string().describe("The question to ask"),
-          header: z28.string().max(12).describe("Short label (max 12 chars)"),
-          options: z28.array(
-            z28.object({
-              label: z28.string().describe("Display text (1-5 words)"),
-              description: z28.string().describe("What this option means"),
-              preview: z28.string().optional().describe("Optional preview content")
+      questions: z29.array(
+        z29.object({
+          question: z29.string().describe("The question to ask"),
+          header: z29.string().max(12).describe("Short label (max 12 chars)"),
+          options: z29.array(
+            z29.object({
+              label: z29.string().describe("Display text (1-5 words)"),
+              description: z29.string().describe("What this option means"),
+              preview: z29.string().optional().describe("Optional preview content")
             })
           ).min(2).max(4),
-          multiSelect: z28.boolean().default(false)
+          multiSelect: z29.boolean().default(false)
         })
       ).min(1).max(4)
     };
@@ -1455,7 +1484,7 @@ import { Context as Context11, Effect as Effect14, Layer as Layer13 } from "effe
 import { FileSystem as FileSystem4, Path as Path5 } from "@effect/platform";
 import { count, eq as eq2 } from "drizzle-orm";
 import { Context as Context10, Effect as Effect13, Layer as Layer12, Option } from "effect";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 
 // src/server/core/search/functions/extractSearchableText.ts
 var extractSearchableText = (conversation) => {
@@ -1762,26 +1791,26 @@ var decodeSessionId = (projectId, sessionId) => {
 var isRegularSessionFile = (filename) => filename.endsWith(".jsonl") && !filename.startsWith("agent-");
 
 // src/lib/claude-code/parseUserMessage.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var regExp = /<(?<tag>[^>]+)>(?<content>[\s\S]*?)<\/\k<tag>>/g;
-var matchSchema = z29.object({
-  tag: z29.string(),
-  content: z29.string()
-});
-var parsedUserMessageSchema = z29.union([
-  z29.object({
-    kind: z29.literal("command"),
-    commandName: z29.string(),
-    commandArgs: z29.string().optional(),
-    commandMessage: z29.string().optional()
+var matchSchema = z30.object({
+  tag: z30.string(),
+  content: z30.string()
+});
+var parsedUserMessageSchema = z30.union([
+  z30.object({
+    kind: z30.literal("command"),
+    commandName: z30.string(),
+    commandArgs: z30.string().optional(),
+    commandMessage: z30.string().optional()
   }),
-  z29.object({
-    kind: z29.literal("local-command"),
-    stdout: z29.string()
+  z30.object({
+    kind: z30.literal("local-command"),
+    stdout: z30.string()
   }),
-  z29.object({
-    kind: z29.literal("text"),
-    content: z29.string()
+  z30.object({
+    kind: z30.literal("text"),
+    content: z30.string()
   })
 ]);
 var parseUserMessage = (content) => {
@@ -1859,7 +1888,7 @@ var extractActualSessionId = (content) => {
   }
   try {
     const parsed = JSON.parse(firstLine);
-    const result = z30.object({ sessionId: z30.string() }).safeParse(parsed);
+    const result = z31.object({ sessionId: z31.string() }).safeParse(parsed);
     if (result.success) {
       return result.data.sessionId;
     }
@@ -1890,8 +1919,8 @@ var LayerImpl9 = Effect13.gen(function* () {
     if (indexContent !== "") {
       try {
         const parsed = JSON.parse(indexContent);
-        const indexSchema = z30.object({
-          entries: z30.array(z30.looseObject({ projectPath: z30.string() }))
+        const indexSchema = z31.object({
+          entries: z31.array(z31.looseObject({ projectPath: z31.string() }))
         });
         const indexResult = indexSchema.safeParse(parsed);
         if (indexResult.success) {
@@ -2135,6 +2164,20 @@ var LayerImpl9 = Effect13.gen(function* () {
     }
     const fileNames = yield* fs.readDirectory(projectPath).pipe(Effect13.catchAll(() => Effect13.succeed([])));
     const sessionFiles = fileNames.filter(isRegularSessionFile);
+    const existingProject = db.select().from(projects).where(eq2(projects.id, projectId)).get();
+    if (existingProject === void 0) {
+      const projectCwd = yield* extractProjectCwd(projectPath, sessionFiles);
+      const dirStat = yield* fs.stat(projectPath).pipe(Effect13.catchAll(() => Effect13.succeed(null)));
+      const dirMtimeMs = dirStat ? Option.getOrElse(dirStat.mtime, () => /* @__PURE__ */ new Date(0)).getTime() : 0;
+      db.insert(projects).values({
+        id: projectId,
+        name: projectCwd !== null ? path.basename(projectCwd) : null,
+        path: projectCwd,
+        sessionCount: 0,
+        dirMtimeMs,
+        syncedAt: Date.now()
+      }).onConflictDoNothing().run();
+    }
     const knownSessions = db.select().from(sessions).where(eq2(sessions.projectId, projectId)).all();
     const knownSessionPaths = new Set(knownSessions.map((s) => s.filePath));
     const seenFilePaths = /* @__PURE__ */ new Set();
@@ -2375,12 +2418,12 @@ var scanSkillFilesWithMetadata = (dirPath) => Effect16.gen(function* () {
 });
 
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-var versionSchema = z31.object({
-  major: z31.string().transform((value) => Number.parseInt(value, 10)),
-  minor: z31.string().transform((value) => Number.parseInt(value, 10)),
-  patch: z31.string().transform((value) => Number.parseInt(value, 10))
+var versionSchema = z32.object({
+  major: z32.string().transform((value) => Number.parseInt(value, 10)),
+  minor: z32.string().transform((value) => Number.parseInt(value, 10)),
+  patch: z32.string().transform((value) => Number.parseInt(value, 10))
 }).refine((data) => [data.major, data.minor, data.patch].every((value) => !Number.isNaN(value)));
 var fromCLIString = (versionOutput) => {
   const groups = versionOutput.trim().match(versionRegex)?.groups;
@@ -4120,16 +4163,16 @@ import { FileSystem as FileSystem9, Path as Path11 } from "@effect/platform";
 import { Context as Context23, Effect as Effect28, Fiber, Layer as Layer25, Ref as Ref6, Stream } from "effect";
 
 // src/server/core/events/functions/parseSessionFilePath.ts
-import z32 from "zod";
+import z33 from "zod";
 var sessionFileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl$/;
 var agentFileRegExp = /(?<projectId>.*?)\/agent-(?<agentSessionId>.*?)\.jsonl$/;
-var sessionFileGroupSchema = z32.object({
-  projectId: z32.string(),
-  sessionId: z32.string()
+var sessionFileGroupSchema = z33.object({
+  projectId: z33.string(),
+  sessionId: z33.string()
 });
-var agentFileGroupSchema = z32.object({
-  projectId: z32.string(),
-  agentSessionId: z32.string()
+var agentFileGroupSchema = z33.object({
+  projectId: z33.string(),
+  agentSessionId: z33.string()
 });
 var parseSessionFilePath = (filePath) => {
   const agentMatch = filePath.match(agentFileRegExp);
@@ -5801,7 +5844,7 @@ import { FileSystem as FileSystem15 } from "@effect/platform";
 import { Context as Context28, Effect as Effect36, Layer as Layer30, Ref as Ref7 } from "effect";
 import { ulid as ulid5 } from "ulid";
 import webpush from "web-push";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // src/server/core/notification/services/pushError.ts
 var isRecord2 = (value) => typeof value === "object" && value !== null;
@@ -5842,9 +5885,9 @@ var formatPushError = (error) => {
 };
 
 // src/server/core/notification/services/NotificationService.ts
-var vapidKeysSchema = z33.object({
-  publicKey: z33.string(),
-  privateKey: z33.string()
+var vapidKeysSchema = z34.object({
+  publicKey: z34.string(),
+  privateKey: z34.string()
 });
 var VAPID_KEYS_FILENAME = ".claude-code-viewer/vapid-keys.json";
 var DEFAULT_VAPID_SUBJECT = "mailto:noreply@example.com";
@@ -6164,25 +6207,25 @@ import { Context as Context32, Effect as Effect41, Layer as Layer34, Option as O
 // src/server/core/session/services/SessionMetaService.ts
 import { eq as eq6 } from "drizzle-orm";
 import { Context as Context31, Effect as Effect40, Layer as Layer33 } from "effect";
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var parsedUserMessageOrNullSchema = parsedUserMessageSchema.nullable();
-var costBreakdownSchema = z34.object({
-  inputTokensUsd: z34.number(),
-  outputTokensUsd: z34.number(),
-  cacheCreationUsd: z34.number(),
-  cacheReadUsd: z34.number()
-});
-var tokenUsageSchema = z34.object({
-  inputTokens: z34.number(),
-  outputTokens: z34.number(),
-  cacheCreationTokens: z34.number(),
-  cacheReadTokens: z34.number()
-});
-var prLinksSchema = z34.array(
-  z34.object({
-    prNumber: z34.number(),
-    prUrl: z34.string(),
-    prRepository: z34.string()
+var costBreakdownSchema = z35.object({
+  inputTokensUsd: z35.number(),
+  outputTokensUsd: z35.number(),
+  cacheCreationUsd: z35.number(),
+  cacheReadUsd: z35.number()
+});
+var tokenUsageSchema = z35.object({
+  inputTokens: z35.number(),
+  outputTokens: z35.number(),
+  cacheCreationTokens: z35.number(),
+  cacheReadTokens: z35.number()
+});
+var prLinksSchema = z35.array(
+  z35.object({
+    prNumber: z35.number(),
+    prUrl: z35.string(),
+    prRepository: z35.string()
   })
 );
 var defaultBreakdown = {
@@ -6452,40 +6495,40 @@ import { FileSystem as FileSystem18, Path as Path19 } from "@effect/platform";
 import { Context as Context34, Data as Data5, Effect as Effect43, Layer as Layer36 } from "effect";
 
 // src/server/core/scheduler/schema.ts
-import { z as z35 } from "zod";
-var concurrencyPolicySchema = z35.enum(["skip", "run"]);
-var cronScheduleSchema = z35.object({
-  type: z35.literal("cron"),
-  expression: z35.string(),
+import { z as z36 } from "zod";
+var concurrencyPolicySchema = z36.enum(["skip", "run"]);
+var cronScheduleSchema = z36.object({
+  type: z36.literal("cron"),
+  expression: z36.string(),
   concurrencyPolicy: concurrencyPolicySchema
 });
-var reservedScheduleSchema = z35.object({
-  type: z35.literal("reserved"),
-  reservedExecutionTime: z35.iso.datetime()
+var reservedScheduleSchema = z36.object({
+  type: z36.literal("reserved"),
+  reservedExecutionTime: z36.iso.datetime()
 });
-var scheduleSchema = z35.discriminatedUnion("type", [
+var scheduleSchema = z36.discriminatedUnion("type", [
   cronScheduleSchema,
   reservedScheduleSchema
 ]);
-var messageConfigSchema = z35.object({
-  content: z35.string(),
-  projectId: z35.string(),
-  sessionId: z35.uuid(),
-  resume: z35.boolean()
-});
-var jobStatusSchema = z35.enum(["success", "failed"]);
-var schedulerJobSchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
+var messageConfigSchema = z36.object({
+  content: z36.string(),
+  projectId: z36.string(),
+  sessionId: z36.uuid(),
+  resume: z36.boolean()
+});
+var jobStatusSchema = z36.enum(["success", "failed"]);
+var schedulerJobSchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
   schedule: scheduleSchema,
   message: messageConfigSchema,
-  enabled: z35.boolean(),
-  createdAt: z35.iso.datetime(),
-  lastRunAt: z35.iso.datetime().nullable(),
+  enabled: z36.boolean(),
+  createdAt: z36.iso.datetime(),
+  lastRunAt: z36.iso.datetime().nullable(),
   lastRunStatus: jobStatusSchema.nullable()
 });
-var schedulerConfigSchema = z35.object({
-  jobs: z35.array(schedulerJobSchema)
+var schedulerConfigSchema = z36.object({
+  jobs: z36.array(schedulerJobSchema)
 });
 var newSchedulerJobSchema = schedulerJobSchema.omit({
   id: true,
@@ -6493,7 +6536,7 @@ var newSchedulerJobSchema = schedulerJobSchema.omit({
   lastRunAt: true,
   lastRunStatus: true
 }).extend({
-  enabled: z35.boolean().default(true)
+  enabled: z36.boolean().default(true)
 });
 var updateSchedulerJobSchema = schedulerJobSchema.partial().pick({
   name: true,
@@ -6857,17 +6900,17 @@ var SchedulerService = class extends Context35.Tag("SchedulerService")() {
 };
 
 // src/server/core/rate-limit/schema.ts
-import { z as z36 } from "zod";
-var RateLimitEntrySchema = z36.object({
-  type: z36.literal("assistant"),
-  error: z36.literal("rate_limit"),
-  isApiErrorMessage: z36.literal(true),
-  sessionId: z36.string(),
-  message: z36.object({
-    content: z36.array(
-      z36.object({
-        type: z36.literal("text"),
-        text: z36.string()
+import { z as z37 } from "zod";
+var RateLimitEntrySchema = z37.object({
+  type: z37.literal("assistant"),
+  error: z37.literal("rate_limit"),
+  isApiErrorMessage: z37.literal(true),
+  sessionId: z37.string(),
+  message: z37.object({
+    content: z37.array(
+      z37.object({
+        type: z37.literal("text"),
+        text: z37.string()
       })
     )
   })
@@ -8964,38 +9007,38 @@ import { Context as Context42, Effect as Effect54, Layer as Layer44 } from "effe
 // src/server/core/tasks/services/TasksService.ts
 import { FileSystem as FileSystem22, Path as Path21 } from "@effect/platform";
 import { Context as Context41, Effect as Effect53, Layer as Layer43, Option as Option4 } from "effect";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // src/server/core/tasks/schema.ts
-import { z as z37 } from "zod";
-var TaskStatusSchema = z37.enum(["pending", "in_progress", "completed", "failed"]);
-var TaskSchema = z37.object({
-  id: z37.string(),
-  subject: z37.string(),
-  description: z37.string().optional(),
+import { z as z38 } from "zod";
+var TaskStatusSchema = z38.enum(["pending", "in_progress", "completed", "failed"]);
+var TaskSchema = z38.object({
+  id: z38.string(),
+  subject: z38.string(),
+  description: z38.string().optional(),
   status: TaskStatusSchema,
-  owner: z37.string().optional(),
-  blocks: z37.array(z37.string()).optional(),
-  blockedBy: z37.array(z37.string()).optional(),
-  metadata: z37.record(z37.string(), z37.any()).optional(),
-  activeForm: z37.string().optional()
-});
-var TaskCreateSchema = z37.object({
-  subject: z37.string(),
-  description: z37.string().optional(),
-  activeForm: z37.string().optional(),
-  metadata: z37.record(z37.string(), z37.any()).optional()
-});
-var TaskUpdateSchema = z37.object({
-  taskId: z37.string(),
+  owner: z38.string().optional(),
+  blocks: z38.array(z38.string()).optional(),
+  blockedBy: z38.array(z38.string()).optional(),
+  metadata: z38.record(z38.string(), z38.any()).optional(),
+  activeForm: z38.string().optional()
+});
+var TaskCreateSchema = z38.object({
+  subject: z38.string(),
+  description: z38.string().optional(),
+  activeForm: z38.string().optional(),
+  metadata: z38.record(z38.string(), z38.any()).optional()
+});
+var TaskUpdateSchema = z38.object({
+  taskId: z38.string(),
   status: TaskStatusSchema.optional(),
-  subject: z37.string().optional(),
-  description: z37.string().optional(),
-  activeForm: z37.string().optional(),
-  owner: z37.string().optional(),
-  addBlockedBy: z37.array(z37.string()).optional(),
-  addBlocks: z37.array(z37.string()).optional(),
-  metadata: z37.record(z37.string(), z37.any()).optional()
+  subject: z38.string().optional(),
+  description: z38.string().optional(),
+  activeForm: z38.string().optional(),
+  owner: z38.string().optional(),
+  addBlockedBy: z38.array(z38.string()).optional(),
+  addBlocks: z38.array(z38.string()).optional(),
+  metadata: z38.record(z38.string(), z38.any()).optional()
 });
 
 // src/server/core/tasks/services/TasksService.ts
@@ -9122,11 +9165,11 @@ var TasksService = class extends Context41.Tag("TasksService")() {
               Effect53.runFork(
                 Effect53.logWarning(`Invalid task file ${file}: ${parsed.error.message}`)
               );
-              const fallbackSchema = z38.object({
-                id: z38.string().optional(),
-                subject: z38.string().optional(),
-                title: z38.string().optional(),
-                status: z38.enum(["pending", "in_progress", "completed", "failed"]).optional()
+              const fallbackSchema = z39.object({
+                id: z39.string().optional(),
+                subject: z39.string().optional(),
+                title: z39.string().optional(),
+                status: z39.enum(["pending", "in_progress", "completed", "failed"]).optional()
               });
               const fallbackParsed = fallbackSchema.safeParse(task);
               const fb = fallbackParsed.success ? fallbackParsed.data : {};
@@ -9136,7 +9179,7 @@ var TasksService = class extends Context41.Tag("TasksService")() {
               const fallbackTask = {
                 id: taskId,
                 subject: taskSubject,
-                description: `Validation Error: ${JSON.stringify(z38.treeifyError(parsed.error))}. Raw: ${JSON.stringify(task)}`,
+                description: `Validation Error: ${JSON.stringify(z39.treeifyError(parsed.error))}. Raw: ${JSON.stringify(task)}`,
                 status: validStatus,
                 blocks: [],
                 blockedBy: []
@@ -9746,24 +9789,24 @@ import { createMiddleware as createMiddleware3 } from "hono/factory";
 import prexit from "prexit";
 
 // src/lib/config/userConfig.ts
-import z40 from "zod";
+import z41 from "zod";
 
 // src/lib/i18n/schema.ts
-import z39 from "zod";
-var localeSchema = z39.enum(["ja", "en", "zh_CN"]);
+import z40 from "zod";
+var localeSchema = z40.enum(["ja", "en", "zh_CN"]);
 
 // src/lib/config/userConfig.ts
-var userConfigSchema = z40.object({
-  hideNoUserMessageSession: z40.boolean().optional().default(true),
-  unifySameTitleSession: z40.boolean().optional().default(false),
-  enterKeyBehavior: z40.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+var userConfigSchema = z41.object({
+  hideNoUserMessageSession: z41.boolean().optional().default(true),
+  unifySameTitleSession: z41.boolean().optional().default(false),
+  enterKeyBehavior: z41.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
   locale: localeSchema.optional().default("en"),
-  theme: z40.enum(["light", "dark", "system"]).optional().default("system"),
-  searchHotkey: z40.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
-  findHotkey: z40.enum(["ctrl-f", "command-f"]).optional().default("command-f"),
-  autoScheduleContinueOnRateLimit: z40.boolean().optional().default(false),
-  modelChoices: z40.array(z40.string()).optional().default(["default", "haiku", "sonnet", "opus"]),
-  usageMode: z40.enum(["subscription", "api"]).optional()
+  theme: z41.enum(["light", "dark", "system"]).optional().default("system"),
+  searchHotkey: z41.enum(["ctrl-k", "command-k"]).optional().default("command-k"),
+  findHotkey: z41.enum(["ctrl-f", "command-f"]).optional().default("command-f"),
+  autoScheduleContinueOnRateLimit: z41.boolean().optional().default(false),
+  modelChoices: z41.array(z41.string()).optional().default(["default", "haiku", "sonnet", "opus"]),
+  usageMode: z41.enum(["subscription", "api"]).optional()
 });
 var defaultUserConfig = userConfigSchema.parse({});
 
@@ -9812,7 +9855,7 @@ import { zValidator } from "@hono/zod-validator";
 import { Effect as Effect59 } from "effect";
 import { Hono as Hono2 } from "hono";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var safeEqual2 = (a, b) => {
   if (a.length !== b.length) return false;
   return timingSafeEqual2(Buffer.from(a, "utf-8"), Buffer.from(b, "utf-8"));
@@ -9820,7 +9863,7 @@ var safeEqual2 = (a, b) => {
 var authRoutes = Effect59.gen(function* () {
   const { getAuthState } = yield* AuthMiddleware;
   const { validSessionToken, authEnabled, authPassword } = yield* getAuthState;
-  return new Hono2().post("/login", zValidator("json", z41.object({ password: z41.string() })), (c) => {
+  return new Hono2().post("/login", zValidator("json", z42.object({ password: z42.string() })), (c) => {
     const { password } = c.req.valid("json");
     if (!authEnabled) {
       return c.json(
@@ -9857,73 +9900,73 @@ var authRoutes = Effect59.gen(function* () {
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { Effect as Effect61 } from "effect";
 import { Hono as Hono3 } from "hono";
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // src/server/core/claude-code/schema.ts
-import { z as z42 } from "zod";
-var mediaTypeSchema = z42.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-var imageBlockSchema = z42.object({
-  type: z42.literal("image"),
-  source: z42.object({
-    type: z42.literal("base64"),
+import { z as z43 } from "zod";
+var mediaTypeSchema = z43.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+var imageBlockSchema = z43.object({
+  type: z43.literal("image"),
+  source: z43.object({
+    type: z43.literal("base64"),
     media_type: mediaTypeSchema,
-    data: z42.string()
+    data: z43.string()
   })
 });
-var documentBlockSchema = z42.object({
-  type: z42.literal("document"),
-  source: z42.union([
-    z42.object({
-      type: z42.literal("text"),
-      media_type: z42.enum(["text/plain"]),
-      data: z42.string()
+var documentBlockSchema = z43.object({
+  type: z43.literal("document"),
+  source: z43.union([
+    z43.object({
+      type: z43.literal("text"),
+      media_type: z43.enum(["text/plain"]),
+      data: z43.string()
     }),
-    z42.object({
-      type: z42.literal("base64"),
-      media_type: z42.enum(["application/pdf"]),
-      data: z42.string()
+    z43.object({
+      type: z43.literal("base64"),
+      media_type: z43.enum(["application/pdf"]),
+      data: z43.string()
     })
   ])
 });
-var userMessageInputSchema = z42.object({
-  text: z42.string().min(1),
-  images: z42.array(imageBlockSchema).optional(),
-  documents: z42.array(documentBlockSchema).optional()
-});
-var sandboxNetworkConfigSchema = z42.object({
-  allowedDomains: z42.array(z42.string()).optional(),
-  allowUnixSockets: z42.array(z42.string()).optional(),
-  allowAllUnixSockets: z42.boolean().optional(),
-  allowLocalBinding: z42.boolean().optional(),
-  httpProxyPort: z42.number().optional(),
-  socksProxyPort: z42.number().optional()
-});
-var sandboxSettingsSchema = z42.object({
-  enabled: z42.boolean().optional(),
-  autoAllowBashIfSandboxed: z42.boolean().optional(),
-  allowUnsandboxedCommands: z42.boolean().optional(),
+var userMessageInputSchema = z43.object({
+  text: z43.string().min(1),
+  images: z43.array(imageBlockSchema).optional(),
+  documents: z43.array(documentBlockSchema).optional()
+});
+var sandboxNetworkConfigSchema = z43.object({
+  allowedDomains: z43.array(z43.string()).optional(),
+  allowUnixSockets: z43.array(z43.string()).optional(),
+  allowAllUnixSockets: z43.boolean().optional(),
+  allowLocalBinding: z43.boolean().optional(),
+  httpProxyPort: z43.number().optional(),
+  socksProxyPort: z43.number().optional()
+});
+var sandboxSettingsSchema = z43.object({
+  enabled: z43.boolean().optional(),
+  autoAllowBashIfSandboxed: z43.boolean().optional(),
+  allowUnsandboxedCommands: z43.boolean().optional(),
   network: sandboxNetworkConfigSchema.optional()
 });
-var ccOptionsSchema = z42.object({
-  disallowedTools: z42.array(z42.string()).optional(),
-  settingSources: z42.array(z42.enum(["user", "project", "local"])).optional(),
-  systemPrompt: z42.union([
-    z42.string(),
-    z42.object({
-      type: z42.literal("preset"),
-      preset: z42.literal("claude_code"),
-      append: z42.string().optional()
+var ccOptionsSchema = z43.object({
+  disallowedTools: z43.array(z43.string()).optional(),
+  settingSources: z43.array(z43.enum(["user", "project", "local"])).optional(),
+  systemPrompt: z43.union([
+    z43.string(),
+    z43.object({
+      type: z43.literal("preset"),
+      preset: z43.literal("claude_code"),
+      append: z43.string().optional()
     })
   ]).optional(),
-  model: z42.string().optional(),
+  model: z43.string().optional(),
   sandbox: sandboxSettingsSchema.optional(),
-  maxTurns: z42.number().optional(),
-  maxThinkingTokens: z42.number().optional(),
-  env: z42.record(z42.string(), z42.string().optional()).optional(),
-  maxBudgetUsd: z42.number().optional(),
-  effort: z42.enum(["low", "medium", "high", "max"]).optional(),
-  permissionMode: z42.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional(),
-  agent: z42.string().optional()
+  maxTurns: z43.number().optional(),
+  maxThinkingTokens: z43.number().optional(),
+  env: z43.record(z43.string(), z43.string().optional()).optional(),
+  maxBudgetUsd: z43.number().optional(),
+  effort: z43.enum(["low", "medium", "high", "max"]).optional(),
+  permissionMode: z43.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional(),
+  agent: z43.string().optional()
 });
 
 // src/server/lib/effect/toEffectResponse.ts
@@ -9979,11 +10022,11 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     "/session-processes",
     zValidator2(
       "json",
-      z43.object({
-        projectId: z43.string(),
-        sessionId: z43.uuid(),
+      z44.object({
+        projectId: z44.string(),
+        sessionId: z44.uuid(),
         input: userMessageInputSchema,
-        resume: z43.boolean(),
+        resume: z44.boolean(),
         ccOptions: ccOptionsSchema.optional()
       })
     ),
@@ -10003,10 +10046,10 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     "/session-processes/:sessionProcessId/continue",
     zValidator2(
       "json",
-      z43.object({
-        projectId: z43.string(),
+      z44.object({
+        projectId: z44.string(),
         input: userMessageInputSchema,
-        baseSessionId: z43.string()
+        baseSessionId: z44.string()
       })
     ),
     async (c) => {
@@ -10024,7 +10067,7 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     }
   ).post(
     "/session-processes/:sessionProcessId/abort",
-    zValidator2("json", z43.object({ projectId: z43.string() })),
+    zValidator2("json", z44.object({ projectId: z44.string() })),
     (c) => {
       const { sessionProcessId } = c.req.param();
       void Effect61.runFork(claudeCodeLifeCycleService.abortTask(sessionProcessId));
@@ -10046,11 +10089,11 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     "/permission-response",
     zValidator2(
       "json",
-      z43.object({
-        permissionRequestId: z43.string(),
-        decision: z43.enum(["allow", "deny", "always_allow"]),
-        alwaysAllowRule: z43.string().optional(),
-        alwaysAllowScope: z43.enum(["session", "project"]).optional()
+      z44.object({
+        permissionRequestId: z44.string(),
+        decision: z44.enum(["allow", "deny", "always_allow"]),
+        alwaysAllowRule: z44.string().optional(),
+        alwaysAllowScope: z44.enum(["session", "project"]).optional()
       })
     ),
     async (c) => {
@@ -10066,14 +10109,14 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     "/question-response",
     zValidator2(
       "json",
-      z43.object({
-        questionRequestId: z43.string(),
-        answers: z43.record(z43.string(), z43.string()),
-        annotations: z43.record(
-          z43.string(),
-          z43.object({
-            notes: z43.string().optional(),
-            preview: z43.string().optional()
+      z44.object({
+        questionRequestId: z44.string(),
+        answers: z44.record(z44.string(), z44.string()),
+        annotations: z44.record(
+          z44.string(),
+          z44.object({
+            notes: z44.string().optional(),
+            preview: z44.string().optional()
           })
         )
       })
@@ -10091,10 +10134,10 @@ var claudeCodeRoutes = Effect61.gen(function* () {
     "/generate-permission-rule",
     zValidator2(
       "json",
-      z43.object({
-        toolName: z43.string(),
-        toolInput: z43.record(z43.string(), z43.unknown()),
-        projectId: z43.string()
+      z44.object({
+        toolName: z44.string(),
+        toolInput: z44.record(z44.string(), z44.unknown()),
+        projectId: z44.string()
       })
     ),
     async (c) => {
@@ -10127,16 +10170,16 @@ var featureFlagRoutes = Effect62.gen(function* () {
 import { zValidator as zValidator3 } from "@hono/zod-validator";
 import { Effect as Effect63 } from "effect";
 import { Hono as Hono5 } from "hono";
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var fileSystemRoutes = Effect63.gen(function* () {
   const fileSystemController = yield* FileSystemController;
   return new Hono5().get(
     "/file-completion",
     zValidator3(
       "query",
-      z44.object({
-        projectId: z44.string(),
-        basePath: z44.string().optional().default("/")
+      z45.object({
+        projectId: z45.string(),
+        basePath: z45.string().optional().default("/")
       })
     ),
     async (c) => {
@@ -10152,9 +10195,9 @@ var fileSystemRoutes = Effect63.gen(function* () {
     "/directory-browser",
     zValidator3(
       "query",
-      z44.object({
-        currentPath: z44.string().optional(),
-        showHidden: z44.string().optional().transform((val) => val === "true")
+      z45.object({
+        currentPath: z45.string().optional(),
+        showHidden: z45.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {
@@ -10173,12 +10216,12 @@ var fileSystemRoutes = Effect63.gen(function* () {
 import { zValidator as zValidator4 } from "@hono/zod-validator";
 import { Effect as Effect64 } from "effect";
 import { Hono as Hono6 } from "hono";
-import { z as z45 } from "zod";
-var pushSubscriptionSchema = z45.object({
-  endpoint: z45.string(),
-  keys: z45.object({
-    p256dh: z45.string(),
-    auth: z45.string()
+import { z as z46 } from "zod";
+var pushSubscriptionSchema = z46.object({
+  endpoint: z46.string(),
+  keys: z46.object({
+    p256dh: z46.string(),
+    auth: z46.string()
   })
 });
 var notificationRoutes = Effect64.gen(function* () {
@@ -10190,9 +10233,9 @@ var notificationRoutes = Effect64.gen(function* () {
     "/:sessionId/consume",
     zValidator4(
       "json",
-      z45.object({
-        types: z45.array(
-          z45.enum([
+      z46.object({
+        types: z46.array(
+          z46.enum([
             "session_paused",
             "session_completed",
             "permission_requested",
@@ -10230,24 +10273,24 @@ var notificationRoutes = Effect64.gen(function* () {
 import { zValidator as zValidator5 } from "@hono/zod-validator";
 import { Effect as Effect65 } from "effect";
 import { Hono as Hono7 } from "hono";
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 
 // src/server/core/git/schema.ts
-import { z as z46 } from "zod";
-var CommitRequestSchema = z46.object({
-  files: z46.array(z46.string().min(1)).min(1),
-  message: z46.string().trim().min(1)
-});
-var CommitResultSuccessSchema = z46.object({
-  success: z46.literal(true),
-  commitSha: z46.string().length(40),
-  filesCommitted: z46.number().int().positive(),
-  message: z46.string()
-});
-var CommitResultErrorSchema = z46.object({
-  success: z46.literal(false),
-  error: z46.string(),
-  errorCode: z46.enum([
+import { z as z47 } from "zod";
+var CommitRequestSchema = z47.object({
+  files: z47.array(z47.string().min(1)).min(1),
+  message: z47.string().trim().min(1)
+});
+var CommitResultSuccessSchema = z47.object({
+  success: z47.literal(true),
+  commitSha: z47.string().length(40),
+  filesCommitted: z47.number().int().positive(),
+  message: z47.string()
+});
+var CommitResultErrorSchema = z47.object({
+  success: z47.literal(false),
+  error: z47.string(),
+  errorCode: z47.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -10255,22 +10298,22 @@ var CommitResultErrorSchema = z46.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z46.string().optional()
+  details: z47.string().optional()
 });
-var CommitResultSchema = z46.discriminatedUnion("success", [
+var CommitResultSchema = z47.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z46.object({
-  success: z46.literal(true),
-  remote: z46.string(),
-  branch: z46.string(),
-  objectsPushed: z46.number().int().optional()
-});
-var PushResultErrorSchema = z46.object({
-  success: z46.literal(false),
-  error: z46.string(),
-  errorCode: z46.enum([
+var PushResultSuccessSchema = z47.object({
+  success: z47.literal(true),
+  remote: z47.string(),
+  branch: z47.string(),
+  objectsPushed: z47.number().int().optional()
+});
+var PushResultErrorSchema = z47.object({
+  success: z47.literal(false),
+  error: z47.string(),
+  errorCode: z47.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -10280,26 +10323,26 @@ var PushResultErrorSchema = z46.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z46.string().optional()
+  details: z47.string().optional()
 });
-var PushResultSchema = z46.discriminatedUnion("success", [
+var PushResultSchema = z47.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z46.object({
-  success: z46.literal(true),
-  commitSha: z46.string().length(40),
-  filesCommitted: z46.number().int().positive(),
-  message: z46.string(),
-  remote: z46.string(),
-  branch: z46.string()
-});
-var CommitAndPushResultErrorSchema = z46.object({
-  success: z46.literal(false),
-  commitSucceeded: z46.boolean(),
-  commitSha: z46.string().length(40).optional(),
-  error: z46.string(),
-  errorCode: z46.enum([
+var CommitAndPushResultSuccessSchema = z47.object({
+  success: z47.literal(true),
+  commitSha: z47.string().length(40),
+  filesCommitted: z47.number().int().positive(),
+  message: z47.string(),
+  remote: z47.string(),
+  branch: z47.string()
+});
+var CommitAndPushResultErrorSchema = z47.object({
+  success: z47.literal(false),
+  commitSucceeded: z47.boolean(),
+  commitSha: z47.string().length(40).optional(),
+  error: z47.string(),
+  errorCode: z47.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -10312,9 +10355,9 @@ var CommitAndPushResultErrorSchema = z46.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z46.string().optional()
+  details: z47.string().optional()
 });
-var CommitAndPushResultSchema = z46.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z47.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
@@ -10333,7 +10376,7 @@ var projectRoutes = Effect65.gen(function* () {
     return response;
   }).get(
     "/:projectId",
-    zValidator5("query", z47.object({ cursor: z47.string().optional() })),
+    zValidator5("query", z48.object({ cursor: z48.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
@@ -10348,8 +10391,8 @@ var projectRoutes = Effect65.gen(function* () {
     "/",
     zValidator5(
       "json",
-      z47.object({
-        projectPath: z47.string().min(1, "Project path is required")
+      z48.object({
+        projectPath: z48.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -10406,7 +10449,7 @@ var projectRoutes = Effect65.gen(function* () {
     return response;
   }).get(
     "/:projectId/agent-sessions/:agentId",
-    zValidator5("query", z47.object({ sessionId: z47.string().optional() })),
+    zValidator5("query", z48.object({ sessionId: z48.string().optional() })),
     async (c) => {
       const projectId = c.req.param("projectId");
       const agentId = c.req.param("agentId");
@@ -10441,8 +10484,8 @@ var projectRoutes = Effect65.gen(function* () {
     "/:projectId/files",
     zValidator5(
       "query",
-      z47.object({
-        filePath: z47.string().min(1, "filePath is required")
+      z48.object({
+        filePath: z48.string().min(1, "filePath is required")
       })
     ),
     async (c) => {
@@ -10470,9 +10513,9 @@ var projectRoutes = Effect65.gen(function* () {
     "/:projectId/git/diff",
     zValidator5(
       "json",
-      z47.object({
-        fromRef: z47.string().min(1, "fromRef is required"),
-        toRef: z47.string().min(1, "toRef is required")
+      z48.object({
+        fromRef: z48.string().min(1, "fromRef is required"),
+        toRef: z48.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -10532,8 +10575,8 @@ var projectRoutes = Effect65.gen(function* () {
     "/:projectId/git/checkout",
     zValidator5(
       "json",
-      z47.object({
-        branchName: z47.string().min(1, "branchName is required")
+      z48.object({
+        branchName: z48.string().min(1, "branchName is required")
       })
     ),
     async (c) => {
@@ -10595,7 +10638,7 @@ var schedulerRoutes = Effect66.gen(function* () {
 import { zValidator as zValidator7 } from "@hono/zod-validator";
 import { Effect as Effect67 } from "effect";
 import { Hono as Hono9 } from "hono";
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 var searchRoutes = Effect67.gen(function* () {
   const searchController = yield* SearchController;
   const runtime = yield* getHonoRuntime;
@@ -10603,10 +10646,10 @@ var searchRoutes = Effect67.gen(function* () {
     "/",
     zValidator7(
       "query",
-      z48.object({
-        q: z48.string().min(2),
-        limit: z48.string().optional().transform((val) => val !== void 0 && val !== "" ? parseInt(val, 10) : void 0),
-        projectId: z48.string().optional()
+      z49.object({
+        q: z49.string().min(2),
+        limit: z49.string().optional().transform((val) => val !== void 0 && val !== "" ? parseInt(val, 10) : void 0),
+        projectId: z49.string().optional()
       })
     ),
     async (c) => {
@@ -10647,7 +10690,7 @@ import { zValidator as zValidator8 } from "@hono/zod-validator";
 import { Effect as Effect69 } from "effect";
 import { Hono as Hono11 } from "hono";
 import { HTTPException } from "hono/http-exception";
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 var getClaudeProjectsDirPath = Effect69.gen(function* () {
   const applicationContext = yield* ApplicationContext;
   const claudeCodePaths = yield* applicationContext.claudeCodePaths;
@@ -10660,9 +10703,9 @@ var tasksRoutes = Effect69.gen(function* () {
     "/",
     zValidator8(
       "query",
-      z49.object({
-        projectId: z49.string(),
-        sessionId: z49.string().optional()
+      z50.object({
+        projectId: z50.string(),
+        sessionId: z50.string().optional()
       })
     ),
     async (c) => {
@@ -10691,9 +10734,9 @@ var tasksRoutes = Effect69.gen(function* () {
     "/",
     zValidator8(
       "query",
-      z49.object({
-        projectId: z49.string(),
-        sessionId: z49.string().optional()
+      z50.object({
+        projectId: z50.string(),
+        sessionId: z50.string().optional()
       })
     ),
     zValidator8("json", TaskCreateSchema),
@@ -10724,9 +10767,9 @@ var tasksRoutes = Effect69.gen(function* () {
     "/:taskId",
     zValidator8(
       "query",
-      z49.object({
-        projectId: z49.string(),
-        sessionId: z49.string().optional()
+      z50.object({
+        projectId: z50.string(),
+        sessionId: z50.string().optional()
       })
     ),
     zValidator8("json", TaskUpdateSchema.omit({ taskId: true })),
@@ -10844,7 +10887,7 @@ var withServerLogLevel = (verbose) => (effect) => effect.pipe(Logger.withMinimum
 // src/server/terminal/terminalWebSocket.ts
 import { Effect as Effect71, Runtime as Runtime5 } from "effect";
 import WebSocket, { WebSocketServer } from "ws";
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var parseCookies = (cookieHeader) => {
   const result = {};
   if (cookieHeader === void 0 || cookieHeader === "") return result;
@@ -10856,12 +10899,12 @@ var parseCookies = (cookieHeader) => {
   }
   return result;
 };
-var clientMessageSchema = z50.union([
-  z50.object({ type: z50.literal("input"), data: z50.string() }),
-  z50.object({ type: z50.literal("resize"), cols: z50.number(), rows: z50.number() }),
-  z50.object({ type: z50.literal("signal"), name: z50.string() }),
-  z50.object({ type: z50.literal("sync"), lastSeq: z50.number() }),
-  z50.object({ type: z50.literal("ping") })
+var clientMessageSchema = z51.union([
+  z51.object({ type: z51.literal("input"), data: z51.string() }),
+  z51.object({ type: z51.literal("resize"), cols: z51.number(), rows: z51.number() }),
+  z51.object({ type: z51.literal("signal"), name: z51.string() }),
+  z51.object({ type: z51.literal("sync"), lastSeq: z51.number() }),
+  z51.object({ type: z51.literal("ping") })
 ]);
 var parseClientMessage = (payload) => {
   try {