@kimuson/claude-code-viewer 0.5.7 → 0.5.9

package/dist/main.js

@@ -2,12 +2,12 @@
 
 // src/server/main.ts
 import { Command as Command3 } from "commander";
-import { Effect as Effect49 } from "effect";
+import { Effect as Effect53 } from "effect";
 
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.5.7",
+  version: "0.5.9",
   description: "A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects.",
   type: "module",
   license: "MIT",
@@ -51,7 +51,7 @@ var package_default = {
     prepare: "lefthook install"
   },
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.2.19",
+    "@anthropic-ai/claude-agent-sdk": "0.2.20",
     "@anthropic-ai/claude-code": "2.0.24",
     "@anthropic-ai/sdk": "0.71.2",
     "@effect/cluster": "0.56.1",
@@ -219,7 +219,7 @@ import { resolve as resolve6 } from "node:path";
 import { NodeContext as NodeContext2 } from "@effect/platform-node";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Effect as Effect48 } from "effect";
+import { Effect as Effect52, Layer as Layer43 } from "effect";
 
 // src/server/core/agent-session/index.ts
 import { Layer as Layer3 } from "effect";
@@ -1077,12 +1077,28 @@ var ProjectRepository = class extends Context7.Tag("ProjectRepository")() {
 // src/server/core/claude-code/functions/scanCommandFiles.ts
 import { FileSystem as FileSystem5, Path as Path6 } from "@effect/platform";
 import { Effect as Effect10 } from "effect";
+var parseCommandFrontmatter = (content) => {
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch?.[1]) {
+    return { description: null, argumentHint: null };
+  }
+  const frontmatter = frontmatterMatch[1];
+  const descriptionMatch = frontmatter.match(
+    /^description:\s*['"]?([^'"\n]+)['"]?\s*$/m
+  );
+  const description = descriptionMatch?.[1]?.trim() ?? null;
+  const argumentHintMatch = frontmatter.match(
+    /^argument-hint:\s*['"]?([^'"\n]+)['"]?\s*$/m
+  );
+  const argumentHint = argumentHintMatch?.[1]?.trim() ?? null;
+  return { description, argumentHint };
+};
 var pathToCommandName = (filePath, baseDir) => {
   const normalizedBaseDir = baseDir.endsWith("/") ? baseDir.slice(0, -1) : baseDir;
   const relativePath = filePath.startsWith(normalizedBaseDir) ? filePath.slice(normalizedBaseDir.length + 1) : filePath;
   return relativePath.replace(/\.md$/, "").replace(/\//g, ":");
 };
-var scanCommandFilesRecursively = (dirPath) => Effect10.gen(function* () {
+var scanCommandFilesWithMetadata = (dirPath) => Effect10.gen(function* () {
   const fs = yield* FileSystem5.FileSystem;
   const path = yield* Path6.Path;
   const scanDirectory = (currentPath) => Effect10.gen(function* () {
@@ -1103,7 +1119,10 @@ var scanCommandFilesRecursively = (dirPath) => Effect10.gen(function* () {
           return yield* scanDirectory(itemPath);
         }
         if (info.type === "File" && item.endsWith(".md")) {
-          return [pathToCommandName(itemPath, dirPath)];
+          const content = yield* fs.readFileString(itemPath);
+          const { description, argumentHint } = parseCommandFrontmatter(content);
+          const name = pathToCommandName(itemPath, dirPath);
+          return [{ name, description, argumentHint }];
         }
         return [];
       }),
@@ -1118,7 +1137,7 @@ var scanCommandFilesRecursively = (dirPath) => Effect10.gen(function* () {
     })
   );
 });
-var scanSkillFilesRecursively = (dirPath) => Effect10.gen(function* () {
+var scanSkillFilesWithMetadata = (dirPath) => Effect10.gen(function* () {
   const fs = yield* FileSystem5.FileSystem;
   const path = yield* Path6.Path;
   const scanDirectory = (currentPath, relativePath) => Effect10.gen(function* () {
@@ -1128,11 +1147,13 @@ var scanSkillFilesRecursively = (dirPath) => Effect10.gen(function* () {
     }
     const skillFilePath = path.join(currentPath, "SKILL.md");
     const skillFileExists = yield* fs.exists(skillFilePath);
-    const skillNames = [];
+    const skills = [];
     if (skillFileExists) {
       const skillName = relativePath.replace(/\//g, ":");
       if (skillName) {
-        skillNames.push(skillName);
+        const content = yield* fs.readFileString(skillFilePath);
+        const { description, argumentHint } = parseCommandFrontmatter(content);
+        skills.push({ name: skillName, description, argumentHint });
       }
     }
     const items = yield* fs.readDirectory(currentPath);
@@ -1152,7 +1173,7 @@ var scanSkillFilesRecursively = (dirPath) => Effect10.gen(function* () {
       }),
       { concurrency: "unbounded" }
     );
-    return [...skillNames, ...results.flat()];
+    return [...skills, ...results.flat()];
   });
   return yield* scanDirectory(dirPath, "").pipe(
     Effect10.match({
@@ -1203,9 +1224,15 @@ var parseMcpListOutput = (output) => {
     if (colonIndex > 0) {
       const name = line.substring(0, colonIndex).trim();
       const rest = line.substring(colonIndex + 1).trim();
+      let status = "unknown";
+      if (rest.includes("\u2713") || rest.toLowerCase().includes("connected")) {
+        status = "connected";
+      } else if (rest.includes("\u2717") || rest.toLowerCase().includes("failed")) {
+        status = "failed";
+      }
       const command = rest.replace(/\s*-\s*[✓✗].*$/, "").trim();
       if (name && command) {
-        servers.push({ name, command });
+        servers.push({ name, command, status });
       }
     }
   }
@@ -1437,25 +1464,55 @@ var LayerImpl9 = Effect13.gen(function* () {
     const { projectId } = options;
     const { project } = yield* projectRepository.getProject(projectId);
     const features = yield* claudeCodeService.getAvailableFeatures();
-    const globalCommands = yield* scanCommandFilesRecursively(
+    const globalCommands = yield* scanCommandFilesWithMetadata(
       (yield* context.claudeCodePaths).claudeCommandsDirPath
     );
-    const projectCommands = project.meta.projectPath === null ? [] : yield* scanCommandFilesRecursively(
+    const projectCommands = project.meta.projectPath === null ? [] : yield* scanCommandFilesWithMetadata(
       path.resolve(project.meta.projectPath, ".claude", "commands")
     );
-    const globalSkills = features.runSkillsDirectly ? yield* scanSkillFilesRecursively(
+    const globalSkills = features.runSkillsDirectly ? yield* scanSkillFilesWithMetadata(
       (yield* context.claudeCodePaths).claudeSkillsDirPath
     ) : [];
-    const projectSkills = features.runSkillsDirectly && project.meta.projectPath !== null ? yield* scanSkillFilesRecursively(
+    const projectSkills = features.runSkillsDirectly && project.meta.projectPath !== null ? yield* scanSkillFilesWithMetadata(
       path.resolve(project.meta.projectPath, ".claude", "skills")
     ) : [];
+    const defaultCommands = [
+      {
+        name: "init",
+        description: "Initialize Claude Code in current project",
+        argumentHint: null
+      },
+      {
+        name: "compact",
+        description: "Compact conversation history",
+        argumentHint: null
+      },
+      {
+        name: "security-review",
+        description: "Review code for security issues",
+        argumentHint: null
+      },
+      {
+        name: "review",
+        description: "Review code changes",
+        argumentHint: null
+      }
+    ];
+    const toNames = (commands) => commands.map((c) => c.name);
     return {
       response: {
+        // New format: CommandInfo[] with metadata
         globalCommands,
         projectCommands,
         globalSkills,
         projectSkills,
-        defaultCommands: ["init", "compact", "security-review", "review"]
+        defaultCommands,
+        // Legacy format: string[] for backward compatibility
+        globalCommandsLegacy: toNames(globalCommands),
+        projectCommandsLegacy: toNames(projectCommands),
+        globalSkillsLegacy: toNames(globalSkills),
+        projectSkillsLegacy: toNames(projectSkills),
+        defaultCommandsLegacy: toNames(defaultCommands)
       },
       status: 200
     };
@@ -1751,7 +1808,8 @@ var LayerImpl12 = Effect17.gen(function* () {
     permissionMode: "default",
     locale: DEFAULT_LOCALE,
     theme: "system",
-    searchHotkey: "command-k"
+    searchHotkey: "command-k",
+    autoScheduleContinueOnRateLimit: false
   });
   const setUserConfig = (newConfig) => Effect17.gen(function* () {
     yield* Ref5.update(configRef, () => newConfig);
@@ -5254,6 +5312,10 @@ var ProjectController = class extends Context28.Tag("ProjectController")() {
   }
 };
 
+// src/server/core/rate-limit/services/RateLimitAutoScheduleService.ts
+import { FileSystem as FileSystem14, Path as Path17 } from "@effect/platform";
+import { Context as Context31, Effect as Effect40, Layer as Layer33, Ref as Ref12 } from "effect";
+
 // src/server/core/scheduler/config.ts
 import { homedir as homedir4 } from "node:os";
 import { FileSystem as FileSystem12, Path as Path16 } from "@effect/platform";
@@ -5675,18 +5737,321 @@ 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()
+      })
+    )
+  })
+});
+
+// src/server/core/rate-limit/functions/detectRateLimitFromLastLine.ts
+var detectRateLimitFromLastLine = (jsonLine) => {
+  const trimmed = jsonLine.trim();
+  if (trimmed === "") {
+    return { detected: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { detected: false };
+  }
+  const validation = RateLimitEntrySchema.safeParse(parsed);
+  if (!validation.success) {
+    return { detected: false };
+  }
+  const entry = validation.data;
+  const firstTextContent = entry.message.content[0];
+  if (!firstTextContent) {
+    return { detected: false };
+  }
+  return {
+    detected: true,
+    sessionId: entry.sessionId,
+    resetTimeText: firstTextContent.text
+  };
+};
+
+// src/server/core/rate-limit/functions/parseRateLimitResetTime.ts
+var parseRateLimitResetTime = (resetTimeText) => {
+  const pattern = /resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm|AM|PM)\s*\(([^)]+)\)/i;
+  const match = pattern.exec(resetTimeText);
+  if (!match) {
+    return getFallbackTime();
+  }
+  const hoursStr = match[1];
+  const minutesStr = match[2];
+  const meridiem = match[3];
+  const timezone = match[4];
+  if (hoursStr === void 0 || meridiem === void 0 || timezone === void 0) {
+    return getFallbackTime();
+  }
+  const hours = Number.parseInt(hoursStr, 10);
+  const minutes = minutesStr !== void 0 ? Number.parseInt(minutesStr, 10) : 0;
+  if (Number.isNaN(hours) || Number.isNaN(minutes)) {
+    return getFallbackTime();
+  }
+  const hours24 = convertTo24Hour(hours, meridiem.toLowerCase());
+  const resetDate = createDateInTimezone(hours24, minutes, timezone);
+  if (resetDate === null) {
+    return getFallbackTime();
+  }
+  resetDate.setMinutes(resetDate.getMinutes() + 1);
+  return resetDate.toISOString();
+};
+var convertTo24Hour = (hours, meridiem) => {
+  const isPM = meridiem === "pm";
+  if (hours === 12) {
+    return isPM ? 12 : 0;
+  }
+  return isPM ? hours + 12 : hours;
+};
+var getTimezoneOffsetMinutes = (timezone, date) => {
+  const utcFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: "UTC",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const tzFormatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const utcParts = utcFormatter.formatToParts(date);
+  const tzParts = tzFormatter.formatToParts(date);
+  const extractDateTime = (parts) => ({
+    day: Number.parseInt(parts.find((p) => p.type === "day")?.value ?? "0", 10),
+    hour: Number.parseInt(
+      parts.find((p) => p.type === "hour")?.value ?? "0",
+      10
+    ),
+    minute: Number.parseInt(
+      parts.find((p) => p.type === "minute")?.value ?? "0",
+      10
+    )
+  });
+  const utc = extractDateTime(utcParts);
+  const tz = extractDateTime(tzParts);
+  let dayDiff = tz.day - utc.day;
+  if (dayDiff > 15) dayDiff -= 31;
+  if (dayDiff < -15) dayDiff += 31;
+  const offsetMinutes = dayDiff * 24 * 60 + (tz.hour - utc.hour) * 60 + (tz.minute - utc.minute);
+  return offsetMinutes;
+};
+var createDateInTimezone = (hours, minutes, timezone) => {
+  const now = /* @__PURE__ */ new Date();
+  try {
+    const testFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone
+    });
+    testFormatter.format(now);
+    const offsetMinutes = getTimezoneOffsetMinutes(timezone, now);
+    const tzFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+    const parts = tzFormatter.formatToParts(now);
+    const year = parts.find((p) => p.type === "year")?.value;
+    const month = parts.find((p) => p.type === "month")?.value;
+    const day = parts.find((p) => p.type === "day")?.value;
+    if (!year || !month || !day) {
+      return null;
+    }
+    const totalTargetMinutes = hours * 60 + minutes;
+    const totalUtcMinutes = totalTargetMinutes - offsetMinutes;
+    const baseDate = /* @__PURE__ */ new Date(`${year}-${month}-${day}T00:00:00.000Z`);
+    const resetDate = new Date(
+      baseDate.getTime() + totalUtcMinutes * 60 * 1e3
+    );
+    if (resetDate.getTime() <= now.getTime()) {
+      resetDate.setTime(resetDate.getTime() + 24 * 60 * 60 * 1e3);
+    }
+    return resetDate;
+  } catch {
+    return null;
+  }
+};
+var getFallbackTime = () => {
+  const fallback = /* @__PURE__ */ new Date();
+  fallback.setMinutes(fallback.getMinutes() + 30);
+  return fallback.toISOString();
+};
+
+// src/server/core/rate-limit/functions/readLastLine.ts
+import { FileSystem as FileSystem13 } from "@effect/platform";
+import { Effect as Effect39 } from "effect";
+var extractLastNonEmptyLine = (content) => {
+  const lines = content.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (line !== void 0 && line.trim() !== "") {
+      return line;
+    }
+  }
+  return "";
+};
+var readLastLine = (filePath) => Effect39.gen(function* () {
+  const fs = yield* FileSystem13.FileSystem;
+  const content = yield* fs.readFileString(filePath);
+  return extractLastNonEmptyLine(content);
+});
+
+// src/server/core/rate-limit/services/RateLimitAutoScheduleService.ts
+var LayerImpl25 = Effect40.gen(function* () {
+  const eventBus = yield* EventBus;
+  const userConfigService = yield* UserConfigService;
+  const sessionProcessService = yield* ClaudeCodeSessionProcessService;
+  const schedulerService = yield* SchedulerService;
+  const fs = yield* FileSystem14.FileSystem;
+  const pathService = yield* Path17.Path;
+  const schedulerConfigBaseDir = yield* SchedulerConfigBaseDir;
+  const projectRepository = yield* ProjectRepository;
+  const lifeCycleService = yield* ClaudeCodeLifeCycleService;
+  const listenerRef = yield* Ref12.make(null);
+  const getSessionProcessProjectId = (sessionId) => Effect40.gen(function* () {
+    const processes = yield* sessionProcessService.getSessionProcesses();
+    const liveProcess = processes.find(
+      (process2) => process2.sessionId === sessionId && (process2.type === "initialized" || process2.type === "file_created" || process2.type === "paused")
+    );
+    return liveProcess?.def.projectId;
+  });
+  const hasExistingReservedJobForSession = (sessionId) => Effect40.gen(function* () {
+    const jobs = yield* schedulerService.getJobs().pipe(Effect40.catchAll(() => Effect40.succeed([])));
+    return jobs.some(
+      (job) => job.schedule.type === "reserved" && job.message.baseSessionId === sessionId && job.lastRunStatus === null
+      // Not yet executed
+    );
+  });
+  const handleSessionChanged = (event) => Effect40.gen(function* () {
+    const { projectId, sessionId } = event;
+    const config = yield* userConfigService.getUserConfig();
+    if (!config.autoScheduleContinueOnRateLimit) {
+      return;
+    }
+    const processProjectId = yield* getSessionProcessProjectId(sessionId);
+    if (processProjectId === void 0) {
+      return;
+    }
+    const hasExistingJob = yield* hasExistingReservedJobForSession(sessionId);
+    if (hasExistingJob) {
+      return;
+    }
+    const projectPath = decodeProjectId(projectId);
+    const sessionFilePath = pathService.join(
+      projectPath,
+      `${sessionId}.jsonl`
+    );
+    const lastLine = yield* readLastLine(sessionFilePath).pipe(
+      Effect40.catchAll(() => Effect40.succeed(""))
+    );
+    if (lastLine === "") {
+      return;
+    }
+    const detection = detectRateLimitFromLastLine(lastLine);
+    if (!detection.detected) {
+      return;
+    }
+    const resetTime = parseRateLimitResetTime(detection.resetTimeText);
+    yield* schedulerService.addJob({
+      name: `Rate limit auto-continue: ${sessionId.slice(0, 8)}...`,
+      schedule: {
+        type: "reserved",
+        reservedExecutionTime: resetTime
+      },
+      message: {
+        content: "continue",
+        projectId: processProjectId,
+        baseSessionId: sessionId
+      },
+      enabled: true
+    }).pipe(
+      Effect40.catchAll((error) => {
+        console.error(
+          `[RateLimitAutoScheduleService] Failed to add job for session ${sessionId}:`,
+          error
+        );
+        return Effect40.void;
+      })
+    );
+    console.log(
+      `[RateLimitAutoScheduleService] Scheduled continue task for session ${sessionId} at ${resetTime}`
+    );
+  });
+  const runtimeLayer = Layer33.mergeAll(
+    Layer33.succeed(FileSystem14.FileSystem, fs),
+    Layer33.succeed(Path17.Path, pathService),
+    Layer33.succeed(SchedulerConfigBaseDir, schedulerConfigBaseDir),
+    Layer33.succeed(ProjectRepository, projectRepository),
+    Layer33.succeed(UserConfigService, userConfigService),
+    Layer33.succeed(ClaudeCodeLifeCycleService, lifeCycleService)
+  );
+  const start = () => Effect40.gen(function* () {
+    const existingListener = yield* Ref12.get(listenerRef);
+    if (existingListener !== null) {
+      return;
+    }
+    const listener = (event) => {
+      Effect40.runFork(
+        handleSessionChanged(event).pipe(Effect40.provide(runtimeLayer))
+      );
+    };
+    yield* Ref12.set(listenerRef, listener);
+    yield* eventBus.on("sessionChanged", listener);
+    console.log("[RateLimitAutoScheduleService] Started");
+  });
+  const stop = () => Effect40.gen(function* () {
+    const listener = yield* Ref12.get(listenerRef);
+    if (listener !== null) {
+      yield* eventBus.off("sessionChanged", listener);
+      yield* Ref12.set(listenerRef, null);
+    }
+    console.log("[RateLimitAutoScheduleService] Stopped");
+  });
+  return {
+    start,
+    stop
+  };
+});
+var RateLimitAutoScheduleService = class extends Context31.Tag(
+  "RateLimitAutoScheduleService"
+)() {
+  static {
+    this.Live = Layer33.effect(this, LayerImpl25);
+  }
+};
+
 // src/server/core/scheduler/presentation/SchedulerController.ts
-import { Context as Context31, Effect as Effect39, Layer as Layer33 } from "effect";
-var LayerImpl25 = Effect39.gen(function* () {
+import { Context as Context32, Effect as Effect41, Layer as Layer34 } from "effect";
+var LayerImpl26 = Effect41.gen(function* () {
   const schedulerService = yield* SchedulerService;
-  const getJobs = () => Effect39.gen(function* () {
+  const getJobs = () => Effect41.gen(function* () {
     const jobs = yield* schedulerService.getJobs();
     return {
       response: jobs,
       status: 200
     };
   });
-  const addJob = (options) => Effect39.gen(function* () {
+  const addJob = (options) => Effect41.gen(function* () {
     const { job } = options;
     const result = yield* schedulerService.addJob(job);
     return {
@@ -5694,12 +6059,12 @@ var LayerImpl25 = Effect39.gen(function* () {
       status: 201
     };
   });
-  const updateJob = (options) => Effect39.gen(function* () {
+  const updateJob = (options) => Effect41.gen(function* () {
     const { id, job } = options;
     const result = yield* schedulerService.updateJob(id, job).pipe(
-      Effect39.catchTag(
+      Effect41.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect39.succeed(null)
+        () => Effect41.succeed(null)
       )
     );
     if (result === null) {
@@ -5713,14 +6078,14 @@ var LayerImpl25 = Effect39.gen(function* () {
       status: 200
     };
   });
-  const deleteJob = (options) => Effect39.gen(function* () {
+  const deleteJob = (options) => Effect41.gen(function* () {
     const { id } = options;
     const result = yield* schedulerService.deleteJob(id).pipe(
-      Effect39.catchTag(
+      Effect41.catchTag(
         "SchedulerJobNotFoundError",
-        () => Effect39.succeed(false)
+        () => Effect41.succeed(false)
       ),
-      Effect39.map(() => true)
+      Effect41.map(() => true)
     );
     if (!result) {
       return {
@@ -5740,18 +6105,18 @@ var LayerImpl25 = Effect39.gen(function* () {
     deleteJob
   };
 });
-var SchedulerController = class extends Context31.Tag("SchedulerController")() {
+var SchedulerController = class extends Context32.Tag("SchedulerController")() {
   static {
-    this.Live = Layer33.effect(this, LayerImpl25);
+    this.Live = Layer34.effect(this, LayerImpl26);
   }
 };
 
 // src/server/core/search/presentation/SearchController.ts
-import { Context as Context33, Effect as Effect41, Layer as Layer35 } from "effect";
+import { Context as Context34, Effect as Effect43, Layer as Layer36 } from "effect";
 
 // src/server/core/search/services/SearchService.ts
-import { FileSystem as FileSystem13, Path as Path17 } from "@effect/platform";
-import { Context as Context32, Effect as Effect40, Layer as Layer34, Ref as Ref12 } from "effect";
+import { FileSystem as FileSystem15, Path as Path18 } from "@effect/platform";
+import { Context as Context33, Effect as Effect42, Layer as Layer35, Ref as Ref13 } from "effect";
 import MiniSearch from "minisearch";
 
 // src/server/core/search/functions/extractSearchableText.ts
@@ -5797,12 +6162,12 @@ var createMiniSearchIndex = () => new MiniSearch({
     boost: { text: 1 }
   }
 });
-var LayerImpl26 = Effect40.gen(function* () {
-  const fs = yield* FileSystem13.FileSystem;
-  const path = yield* Path17.Path;
+var LayerImpl27 = Effect42.gen(function* () {
+  const fs = yield* FileSystem15.FileSystem;
+  const path = yield* Path18.Path;
   const context = yield* ApplicationContext;
-  const indexCacheRef = yield* Ref12.make(null);
-  const buildIndex = () => Effect40.gen(function* () {
+  const indexCacheRef = yield* Ref13.make(null);
+  const buildIndex = () => Effect42.gen(function* () {
     const { claudeProjectsDirPath } = yield* context.claudeCodePaths;
     const dirExists = yield* fs.exists(claudeProjectsDirPath);
     if (!dirExists) {
@@ -5811,22 +6176,22 @@ var LayerImpl26 = Effect40.gen(function* () {
     const projectEntries = yield* fs.readDirectory(claudeProjectsDirPath);
     const miniSearch = createMiniSearchIndex();
     const documentEffects = projectEntries.map(
-      (projectEntry) => Effect40.gen(function* () {
+      (projectEntry) => Effect42.gen(function* () {
         const projectPath = path.resolve(claudeProjectsDirPath, projectEntry);
-        const stat = yield* fs.stat(projectPath).pipe(Effect40.catchAll(() => Effect40.succeed(null)));
+        const stat = yield* fs.stat(projectPath).pipe(Effect42.catchAll(() => Effect42.succeed(null)));
         if (stat?.type !== "Directory") {
           return [];
         }
         const projectId = encodeProjectId(projectPath);
         const projectName = path.basename(projectPath);
-        const sessionEntries = yield* fs.readDirectory(projectPath).pipe(Effect40.catchAll(() => Effect40.succeed([])));
+        const sessionEntries = yield* fs.readDirectory(projectPath).pipe(Effect42.catchAll(() => Effect42.succeed([])));
         const sessionFiles = sessionEntries.filter(isRegularSessionFile);
-        const sessionDocuments = yield* Effect40.all(
+        const sessionDocuments = yield* Effect42.all(
           sessionFiles.map(
-            (sessionFile) => Effect40.gen(function* () {
+            (sessionFile) => Effect42.gen(function* () {
               const sessionPath = path.resolve(projectPath, sessionFile);
               const sessionId = encodeSessionId(sessionPath);
-              const content = yield* fs.readFileString(sessionPath).pipe(Effect40.catchAll(() => Effect40.succeed("")));
+              const content = yield* fs.readFileString(sessionPath).pipe(Effect42.catchAll(() => Effect42.succeed("")));
               if (!content) return [];
               const conversations = parseJsonl(content);
               const documents = [];
@@ -5861,7 +6226,7 @@ var LayerImpl26 = Effect40.gen(function* () {
         return sessionDocuments.flat();
       })
     );
-    const allDocuments = yield* Effect40.all(documentEffects, {
+    const allDocuments = yield* Effect42.all(documentEffects, {
       concurrency: 10
     });
     const flatDocuments = allDocuments.flat();
@@ -5872,17 +6237,17 @@ var LayerImpl26 = Effect40.gen(function* () {
     }
     return { index: miniSearch, documents: documentsMap };
   });
-  const getIndex = () => Effect40.gen(function* () {
-    const cached = yield* Ref12.get(indexCacheRef);
+  const getIndex = () => Effect42.gen(function* () {
+    const cached = yield* Ref13.get(indexCacheRef);
     const now = Date.now();
     if (cached && now - cached.builtAt < INDEX_TTL_MS) {
       return { index: cached.index, documents: cached.documents };
     }
     const { index, documents } = yield* buildIndex();
-    yield* Ref12.set(indexCacheRef, { index, documents, builtAt: now });
+    yield* Ref13.set(indexCacheRef, { index, documents, builtAt: now });
     return { index, documents };
   });
-  const search = (query4, limit = 20, projectId) => Effect40.gen(function* () {
+  const search = (query4, limit = 20, projectId) => Effect42.gen(function* () {
     const { claudeProjectsDirPath } = yield* context.claudeCodePaths;
     const dirExists = yield* fs.exists(claudeProjectsDirPath);
     if (!dirExists) {
@@ -5923,22 +6288,22 @@ var LayerImpl26 = Effect40.gen(function* () {
     }
     return { results };
   });
-  const invalidateIndex = () => Ref12.set(indexCacheRef, null);
+  const invalidateIndex = () => Ref13.set(indexCacheRef, null);
   return {
     search,
     invalidateIndex
   };
 });
-var SearchService = class extends Context32.Tag("SearchService")() {
+var SearchService = class extends Context33.Tag("SearchService")() {
   static {
-    this.Live = Layer34.effect(this, LayerImpl26);
+    this.Live = Layer35.effect(this, LayerImpl27);
   }
 };
 
 // src/server/core/search/presentation/SearchController.ts
-var LayerImpl27 = Effect41.gen(function* () {
+var LayerImpl28 = Effect43.gen(function* () {
   const searchService = yield* SearchService;
-  const search = (options) => Effect41.gen(function* () {
+  const search = (options) => Effect43.gen(function* () {
     const { query: query4, limit, projectId } = options;
     if (query4.trim().length < 2) {
       return {
@@ -5962,18 +6327,18 @@ var LayerImpl27 = Effect41.gen(function* () {
     search
   };
 });
-var SearchController = class extends Context33.Tag("SearchController")() {
+var SearchController = class extends Context34.Tag("SearchController")() {
   static {
-    this.Live = Layer35.effect(this, LayerImpl27);
+    this.Live = Layer36.effect(this, LayerImpl28);
   }
 };
 
 // src/server/core/session/presentation/SessionController.ts
-import { FileSystem as FileSystem14 } from "@effect/platform";
-import { Context as Context34, Effect as Effect43, Layer as Layer36 } from "effect";
+import { FileSystem as FileSystem16 } from "@effect/platform";
+import { Context as Context35, Effect as Effect45, Layer as Layer37 } from "effect";
 
 // src/server/core/session/services/ExportService.ts
-import { Effect as Effect42 } from "effect";
+import { Effect as Effect44 } from "effect";
 var escapeHtml = (text) => {
   const map = {
     "&": "&amp;",
@@ -6000,33 +6365,166 @@ var formatTimestamp = (timestamp) => {
   });
 };
 var renderMarkdown = (content) => {
-  let html = escapeHtml(content);
-  html = html.replace(
+  const codeBlocks = [];
+  let processedContent = content.replace(
     /```(\w+)?\n([\s\S]*?)```/g,
-    (_match, lang, code) => `
+    (_match, lang, code) => {
+      const placeholder = `__CODE_BLOCK_${codeBlocks.length}__`;
+      codeBlocks.push(`
     <div class="code-block">
       ${lang ? `<div class="code-header"><span class="code-lang">${escapeHtml(lang.toUpperCase())}</span></div>` : ""}
-      <pre><code class="language-${escapeHtml(lang || "text")}">${code.trim()}</code></pre>
+      <pre><code class="language-${escapeHtml(lang || "text")}">${escapeHtml(code.trim())}</code></pre>
     </div>
-  `
+  `);
+      return placeholder;
+    }
+  );
+  processedContent = processedContent.replace(
+    /(?:^\|.+\|$\n?)+/gm,
+    (tableBlock) => {
+      const rows = tableBlock.trim().split("\n");
+      if (rows.length < 2) return escapeHtml(tableBlock);
+      const headerRow = rows[0];
+      const separatorRow = rows[1];
+      if (!headerRow || !separatorRow || !/^\|[\s\-:|]+\|$/.test(separatorRow)) {
+        return escapeHtml(tableBlock);
+      }
+      const parseRow = (row) => row.split("|").slice(1, -1).map((cell) => cell.trim());
+      const headerCells = parseRow(headerRow);
+      const dataRows = rows.slice(2);
+      let tableHtml = '<table class="markdown-table"><thead><tr>';
+      for (const cell of headerCells) {
+        tableHtml += `<th>${escapeHtml(cell)}</th>`;
+      }
+      tableHtml += "</tr></thead><tbody>";
+      for (const row of dataRows) {
+        const cells = parseRow(row);
+        tableHtml += "<tr>";
+        for (const cell of cells) {
+          tableHtml += `<td>${escapeHtml(cell)}</td>`;
+        }
+        tableHtml += "</tr>";
+      }
+      tableHtml += "</tbody></table>";
+      return tableHtml;
+    }
+  );
+  processedContent = processedContent.split(
+    /(<table class="markdown-table">[\s\S]*?<\/table>|__CODE_BLOCK_\d+__)/
+  ).map((part) => {
+    if (part.startsWith('<table class="markdown-table">') || /^__CODE_BLOCK_\d+__$/.test(part)) {
+      return part;
+    }
+    return escapeHtml(part);
+  }).join("");
+  processedContent = processedContent.replace(
+    /(?:^&gt; .+$\n?)+/gm,
+    (quoteBlock) => {
+      const lines = quoteBlock.split("\n").filter((l) => l.trim()).map((l) => l.replace(/^&gt; /, "")).join("<br>");
+      return `<blockquote class="markdown-blockquote">${lines}</blockquote>`;
+    }
+  );
+  processedContent = processedContent.replace(
+    /^(\*{3,}|-{3,}|_{3,})$/gm,
+    '<hr class="markdown-hr">'
+  );
+  processedContent = processedContent.replace(
+    /(?:^- \[([ xX])\] .+$\n?)+/gm,
+    (listBlock) => {
+      const items = listBlock.trim().split("\n").map((line) => {
+        const match = line.match(/^- \[([ xX])\] (.+)$/);
+        if (match?.[1] !== void 0 && match[2] !== void 0) {
+          const checked = match[1].toLowerCase() === "x";
+          return `<li class="task-item"><input type="checkbox" class="task-checkbox" ${checked ? "checked" : ""} disabled>${match[2]}</li>`;
+        }
+        return "";
+      }).join("");
+      return `<ul class="markdown-task-list">${items}</ul>`;
+    }
+  );
+  processedContent = processedContent.replace(
+    /(?:^[-*+] .+$\n?)+/gm,
+    (listBlock) => {
+      const items = listBlock.trim().split("\n").map((line) => {
+        const match = line.match(/^[-*+] (.+)$/);
+        return match ? `<li>${match[1]}</li>` : "";
+      }).join("");
+      return `<ul class="markdown-ul">${items}</ul>`;
+    }
+  );
+  processedContent = processedContent.replace(
+    /(?:^\d+\. .+$\n?)+/gm,
+    (listBlock) => {
+      const items = listBlock.trim().split("\n").map((line) => {
+        const match = line.match(/^\d+\. (.+)$/);
+        return match ? `<li>${match[1]}</li>` : "";
+      }).join("");
+      return `<ol class="markdown-ol">${items}</ol>`;
+    }
+  );
+  processedContent = processedContent.replace(
+    /~~(.+?)~~/g,
+    '<del class="markdown-del">$1</del>'
+  );
+  processedContent = processedContent.replace(
+    /`([^`]+)`/g,
+    '<code class="inline-code">$1</code>'
   );
-  html = html.replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>');
-  html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
-  html = html.replace(/\*(.+?)\*/g, "<em>$1</em>");
-  html = html.replace(/^### (.+)$/gm, '<h3 class="markdown-h3">$1</h3>');
-  html = html.replace(/^## (.+)$/gm, '<h2 class="markdown-h2">$1</h2>');
-  html = html.replace(/^# (.+)$/gm, '<h1 class="markdown-h1">$1</h1>');
-  html = html.replace(
+  processedContent = processedContent.replace(
+    /\*\*(.+?)\*\*/g,
+    "<strong>$1</strong>"
+  );
+  processedContent = processedContent.replace(
+    /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g,
+    "<em>$1</em>"
+  );
+  processedContent = processedContent.replace(
+    /^### (.+)$/gm,
+    '<h3 class="markdown-h3">$1</h3>'
+  );
+  processedContent = processedContent.replace(
+    /^## (.+)$/gm,
+    '<h2 class="markdown-h2">$1</h2>'
+  );
+  processedContent = processedContent.replace(
+    /^# (.+)$/gm,
+    '<h1 class="markdown-h1">$1</h1>'
+  );
+  processedContent = processedContent.replace(
     /\[([^\]]+)\]\(([^)]+)\)/g,
     '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>'
   );
-  html = html.split("\n\n").map((para) => {
-    if (para.startsWith("<h") || para.startsWith("<div") || para.startsWith("<pre") || para.trim() === "") {
+  const blockElements = [
+    "<h1",
+    "<h2",
+    "<h3",
+    "<div",
+    "<pre",
+    "<table",
+    "<ul",
+    "<ol",
+    "<blockquote",
+    "<hr",
+    "__CODE_BLOCK_"
+  ];
+  processedContent = processedContent.split("\n\n").map((para) => {
+    const trimmed = para.trim();
+    if (trimmed === "") return "";
+    if (blockElements.some((tag) => trimmed.startsWith(tag))) {
       return para;
     }
     return `<p class="markdown-p">${para.replace(/\n/g, "<br>")}</p>`;
-  }).join("\n");
-  return html;
+  }).filter((p) => p !== "").join("\n");
+  for (let i = 0; i < codeBlocks.length; i++) {
+    const codeBlock = codeBlocks[i];
+    if (codeBlock !== void 0) {
+      processedContent = processedContent.replace(
+        `__CODE_BLOCK_${i}__`,
+        codeBlock
+      );
+    }
+  }
+  return processedContent;
 };
 var renderUserEntry = (entry) => {
   const contentArray = Array.isArray(entry.message.content) ? entry.message.content : [entry.message.content];
@@ -6063,7 +6561,289 @@ var renderUserEntry = (entry) => {
     </div>
   `;
 };
-var renderAssistantEntry = (entry) => {
+var renderToolResultContent = (result) => {
+  const isError = result.is_error === true;
+  const errorClass = isError ? " tool-result-error" : "";
+  let contentHtml;
+  if (typeof result.content === "string") {
+    contentHtml = `<pre class="tool-result-text">${escapeHtml(result.content)}</pre>`;
+  } else {
+    contentHtml = result.content.map((item) => {
+      if (item.type === "text") {
+        return `<pre class="tool-result-text">${escapeHtml(item.text)}</pre>`;
+      }
+      if (item.type === "image") {
+        return `<img src="data:${item.source.media_type};base64,${item.source.data}" alt="Tool result image" class="tool-result-image" />`;
+      }
+      return "";
+    }).join("");
+  }
+  return `
+    <div class="tool-result-block${errorClass}">
+      <div class="tool-result-header">
+        <svg class="icon-check" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          ${isError ? '<path d="M18 6L6 18M6 6l12 12"/>' : '<path d="M20 6L9 17l-5-5"/>'}
+        </svg>
+        <span class="tool-result-label">${isError ? "Error" : "Result"}</span>
+      </div>
+      <div class="tool-result-content">
+        ${contentHtml}
+      </div>
+    </div>
+  `;
+};
+var hasAgentId = (toolUseResult) => {
+  return typeof toolUseResult === "object" && toolUseResult !== null && "agentId" in toolUseResult && typeof toolUseResult.agentId === "string";
+};
+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
+  );
+  const uuidMap = new Map(
+    sidechainConversations.map((conv) => [conv.uuid, conv])
+  );
+  const getRootConversation = (conv) => {
+    if (conv.parentUuid === null) {
+      return conv;
+    }
+    const parent = uuidMap.get(conv.parentUuid);
+    if (parent === void 0) {
+      return conv;
+    }
+    return getRootConversation(parent);
+  };
+  const groupsByRootUuid = /* @__PURE__ */ new Map();
+  for (const conv of sidechainConversations) {
+    const root = getRootConversation(conv);
+    const existing = groupsByRootUuid.get(root.uuid);
+    if (existing) {
+      existing.push(conv);
+    } else {
+      groupsByRootUuid.set(root.uuid, [conv]);
+    }
+  }
+  for (const [, convs] of groupsByRootUuid) {
+    convs.sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+  }
+  const promptToRoot = /* @__PURE__ */ new Map();
+  for (const conv of sidechainConversations) {
+    if (conv.type === "user" && conv.parentUuid === null && typeof conv.message.content === "string") {
+      promptToRoot.set(conv.message.content, conv);
+    }
+  }
+  const agentIdToRoot = /* @__PURE__ */ new Map();
+  for (const conv of sidechainConversations) {
+    if (conv.parentUuid === null && conv.agentId !== void 0) {
+      agentIdToRoot.set(conv.agentId, conv);
+    }
+  }
+  const toolUseIdToAgentId = /* @__PURE__ */ new Map();
+  for (const conv of conversations) {
+    if (conv.type === "summary" || conv.type === "file-history-snapshot" || conv.type === "queue-operation" || conv.type === "progress") {
+      continue;
+    }
+    if (conv.type !== "user") continue;
+    const messageContent = conv.message.content;
+    if (typeof messageContent === "string") continue;
+    for (const content of messageContent) {
+      if (typeof content === "string") continue;
+      if (content.type === "tool_result") {
+        const toolUseResult = conv.toolUseResult;
+        if (hasAgentId(toolUseResult)) {
+          toolUseIdToAgentId.set(content.tool_use_id, toolUseResult.agentId);
+        }
+      }
+    }
+  }
+  return { groupsByRootUuid, promptToRoot, agentIdToRoot, toolUseIdToAgentId };
+};
+var renderSidechainEntry = (entry, toolResultMap, sidechainData) => {
+  if (entry.type === "user") {
+    const contentArray = Array.isArray(entry.message.content) ? entry.message.content : [entry.message.content];
+    const contentHtml = contentArray.map((msg) => {
+      if (typeof msg === "string") {
+        return `<div class="markdown-content">${renderMarkdown(msg)}</div>`;
+      }
+      if (msg.type === "text") {
+        return `<div class="markdown-content">${renderMarkdown(msg.text)}</div>`;
+      }
+      if (msg.type === "tool_result") {
+        return "";
+      }
+      return "";
+    }).join("");
+    if (!contentHtml.trim()) return "";
+    return `
+      <div class="sidechain-entry sidechain-user-entry">
+        <div class="sidechain-entry-header">
+          <span class="sidechain-role">User</span>
+          <span class="sidechain-timestamp">${formatTimestamp(entry.timestamp)}</span>
+        </div>
+        <div class="sidechain-entry-content">${contentHtml}</div>
+      </div>
+    `;
+  }
+  if (entry.type === "assistant") {
+    const contentHtml = entry.message.content.map((msg) => {
+      if (msg.type === "text") {
+        return `<div class="markdown-content">${renderMarkdown(msg.text)}</div>`;
+      }
+      if (msg.type === "thinking") {
+        const charCount = msg.thinking.length;
+        return `
+            <div class="thinking-block collapsible collapsed">
+              <div class="thinking-header collapsible-trigger">
+                <svg class="icon-lightbulb" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <path d="M12 2v1m0 18v1m9-10h1M2 12H1m17.66-7.66l.71.71M3.63 20.37l.71.71m0-14.14l-.71.71m17.02 12.73l-.71.71M12 7a5 5 0 0 1 5 5 5 5 0 0 1-1.47 3.53c-.6.6-.94 1.42-.94 2.27V18a1 1 0 0 1-1 1h-3a1 1 0 0 1-1-1v-.2c0-.85-.34-1.67-.94-2.27A5 5 0 0 1 7 12a5 5 0 0 1 5-5Z"/>
+                </svg>
+                <span class="thinking-title">Thinking</span>
+                <span class="expand-hint">(${charCount} chars)</span>
+                <svg class="icon-chevron" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <polyline points="6 9 12 15 18 9"></polyline>
+                </svg>
+              </div>
+              <div class="thinking-content collapsible-content">
+                <pre class="thinking-text">${escapeHtml(msg.thinking)}</pre>
+              </div>
+            </div>
+          `;
+      }
+      if (msg.type === "tool_use") {
+        const toolResult = toolResultMap.get(msg.id);
+        if (msg.name === "Task") {
+          return renderTaskTool(
+            msg.id,
+            msg.input,
+            toolResult,
+            sidechainData,
+            toolResultMap
+          );
+        }
+        const inputKeys = Object.keys(msg.input).length;
+        const toolResultHtml = toolResult ? renderToolResultContent(toolResult) : "";
+        return `
+            <div class="tool-use-block collapsible collapsed">
+              <div class="tool-use-header collapsible-trigger">
+                <svg class="icon-wrench" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/>
+                </svg>
+                <span class="tool-name">${escapeHtml(msg.name)}</span>
+                <span class="expand-hint">(${inputKeys} params)</span>
+                <svg class="icon-chevron" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <polyline points="6 9 12 15 18 9"></polyline>
+                </svg>
+              </div>
+              <div class="tool-use-content collapsible-content">
+                <div class="tool-id"><strong>Tool ID:</strong> <code>${escapeHtml(msg.id)}</code></div>
+                <div class="tool-input">
+                  <strong>Input:</strong>
+                  <pre class="json-input">${escapeHtml(formatJsonWithNewlines(msg.input))}</pre>
+                </div>
+                ${toolResultHtml}
+              </div>
+            </div>
+          `;
+      }
+      return "";
+    }).join("");
+    return `
+      <div class="sidechain-entry sidechain-assistant-entry">
+        <div class="sidechain-entry-header">
+          <span class="sidechain-role">Subagent</span>
+          <span class="sidechain-timestamp">${formatTimestamp(entry.timestamp)}</span>
+        </div>
+        <div class="sidechain-entry-content">${contentHtml}</div>
+      </div>
+    `;
+  }
+  if (entry.type === "system") {
+    const content = "content" in entry && typeof entry.content === "string" ? entry.content : "System message";
+    return `
+      <div class="sidechain-entry sidechain-system-entry">
+        <div class="sidechain-entry-header">
+          <span class="sidechain-role">System</span>
+          <span class="sidechain-timestamp">${formatTimestamp(entry.timestamp)}</span>
+        </div>
+        <div class="sidechain-entry-content">
+          <div class="system-message">${escapeHtml(content)}</div>
+        </div>
+      </div>
+    `;
+  }
+  return "";
+};
+var renderTaskTool = (toolId, input, toolResult, sidechainData, toolResultMap) => {
+  const prompt = typeof input.prompt === "string" ? input.prompt : "";
+  const truncatedPrompt = prompt.length > 200 ? `${prompt.slice(0, 200)}...` : prompt;
+  let sidechainConversations = [];
+  const agentId = sidechainData.toolUseIdToAgentId.get(toolId);
+  if (agentId) {
+    const rootByAgentId = sidechainData.agentIdToRoot.get(agentId);
+    if (rootByAgentId) {
+      const convs = sidechainData.groupsByRootUuid.get(rootByAgentId.uuid);
+      if (convs) {
+        sidechainConversations = convs;
+      }
+    }
+  }
+  if (sidechainConversations.length === 0) {
+    const rootConversation = sidechainData.promptToRoot.get(prompt);
+    if (rootConversation) {
+      const convs = sidechainData.groupsByRootUuid.get(rootConversation.uuid);
+      if (convs) {
+        sidechainConversations = convs;
+      }
+    }
+  }
+  const hasSidechain = sidechainConversations.length > 0;
+  const sidechainHtml = hasSidechain ? `
+      <div class="sidechain-container collapsible">
+        <div class="sidechain-header collapsible-trigger">
+          <svg class="icon-layers" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polygon points="12 2 2 7 12 12 22 7 12 2"/>
+            <polyline points="2 17 12 22 22 17"/>
+            <polyline points="2 12 12 17 22 12"/>
+          </svg>
+          <span>Subagent Work Log (${sidechainConversations.length} entries)</span>
+          <svg class="icon-chevron" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <polyline points="6 9 12 15 18 9"></polyline>
+          </svg>
+        </div>
+        <div class="sidechain-content collapsible-content">
+          ${sidechainConversations.map(
+    (conv) => renderSidechainEntry(conv, toolResultMap, sidechainData)
+  ).filter((html) => html !== "").join("\n")}
+        </div>
+      </div>
+    ` : "";
+  return `
+    <div class="task-tool-block collapsible">
+      <div class="task-tool-header collapsible-trigger">
+        <svg class="icon-task" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/>
+          <path d="M9 12l2 2 4-4"/>
+        </svg>
+        <span class="task-tool-name">Task${hasSidechain ? ` (${sidechainConversations.length} steps)` : ""}</span>
+        <span class="task-prompt-preview">${escapeHtml(truncatedPrompt)}</span>
+        <svg class="icon-chevron" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <polyline points="6 9 12 15 18 9"></polyline>
+        </svg>
+      </div>
+      <div class="task-tool-content collapsible-content">
+        <div class="task-tool-id"><strong>Task ID:</strong> <code>${escapeHtml(toolId)}</code></div>
+        <div class="task-prompt">
+          <strong>Prompt:</strong>
+          <div class="task-prompt-text">${renderMarkdown(prompt)}</div>
+        </div>
+        ${toolResult ? renderToolResultContent(toolResult) : ""}
+        ${sidechainHtml}
+      </div>
+    </div>
+  `;
+};
+var renderAssistantEntry = (entry, toolResultMap, sidechainData) => {
   const contentHtml = entry.message.content.map((msg) => {
     if (msg.type === "text") {
       return `<div class="markdown-content">${renderMarkdown(msg.text)}</div>`;
@@ -6089,7 +6869,18 @@ var renderAssistantEntry = (entry) => {
         `;
     }
     if (msg.type === "tool_use") {
+      const toolResult = toolResultMap.get(msg.id);
+      if (msg.name === "Task") {
+        return renderTaskTool(
+          msg.id,
+          msg.input,
+          toolResult,
+          sidechainData,
+          toolResultMap
+        );
+      }
       const inputKeys = Object.keys(msg.input).length;
+      const toolResultHtml = toolResult ? renderToolResultContent(toolResult) : "";
       return `
           <div class="tool-use-block collapsible">
             <div class="tool-use-header collapsible-trigger">
@@ -6108,6 +6899,7 @@ var renderAssistantEntry = (entry) => {
                 <strong>Input Parameters:</strong>
                 <pre class="json-input">${escapeHtml(formatJsonWithNewlines(msg.input))}</pre>
               </div>
+              ${toolResultHtml}
             </div>
           </div>
         `;
@@ -6175,7 +6967,7 @@ var groupConsecutiveAssistantMessages = (conversations) => {
   }
   return grouped;
 };
-var renderGroupedAssistantEntries = (entries) => {
+var renderGroupedAssistantEntries = (entries, toolResultMap, sidechainData) => {
   const allContent = entries.flatMap((entry) => entry.message.content);
   const firstEntry = entries[0];
   if (!firstEntry) {
@@ -6206,7 +6998,18 @@ var renderGroupedAssistantEntries = (entries) => {
         `;
     }
     if (msg.type === "tool_use") {
+      const toolResult = toolResultMap.get(msg.id);
+      if (msg.name === "Task") {
+        return renderTaskTool(
+          msg.id,
+          msg.input,
+          toolResult,
+          sidechainData,
+          toolResultMap
+        );
+      }
       const inputKeys = Object.keys(msg.input).length;
+      const toolResultHtml = toolResult ? renderToolResultContent(toolResult) : "";
       return `
           <div class="tool-use-block collapsible">
             <div class="tool-use-header collapsible-trigger">
@@ -6225,6 +7028,7 @@ var renderGroupedAssistantEntries = (entries) => {
                 <strong>Input Parameters:</strong>
                 <pre class="json-input">${escapeHtml(formatJsonWithNewlines(msg.input))}</pre>
               </div>
+              ${toolResultHtml}
             </div>
           </div>
         `;
@@ -6243,12 +7047,88 @@ var renderGroupedAssistantEntries = (entries) => {
     </div>
   `;
 };
-var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
+var generateSessionHtml = (session, projectId, agentSessionRepo) => Effect44.gen(function* () {
+  const agentIds = /* @__PURE__ */ new Set();
+  for (const conv of session.conversations) {
+    if (conv.type !== "user" || typeof conv.message.content === "string") {
+      continue;
+    }
+    for (const content of conv.message.content) {
+      if (typeof content === "string") continue;
+      if (content.type === "tool_result") {
+        const toolUseResult = conv.toolUseResult;
+        if (hasAgentId(toolUseResult)) {
+          agentIds.add(toolUseResult.agentId);
+        }
+      }
+    }
+  }
+  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) {
+      existingAgentIds.add(conv.agentId);
+    }
+  }
+  const missingAgentIds = Array.from(agentIds).filter(
+    (id) => !existingAgentIds.has(id)
+  );
+  const loadedConversations = [];
+  if (missingAgentIds.length > 0) {
+    const loadedSessions = yield* Effect44.all(
+      missingAgentIds.map(
+        (agentId) => agentSessionRepo.getAgentSessionByAgentId(
+          projectId,
+          agentId,
+          session.id
+        )
+      ),
+      { concurrency: 5 }
+    );
+    for (const sess of loadedSessions) {
+      if (sess) {
+        const validConvs = sess.filter(
+          (c) => c.type === "user" || c.type === "assistant" || c.type === "system"
+        );
+        loadedConversations.push(
+          ...validConvs.map((c) => ({
+            ...c,
+            isSidechain: true
+            // Ensure they are marked as sidechain
+          }))
+        );
+      }
+    }
+  }
+  const allConversations = [
+    ...session.conversations.filter(
+      (conv) => conv.type !== "x-error"
+    ),
+    ...loadedConversations
+  ];
+  const sidechainData = buildSidechainData(allConversations);
+  const toolResultMap = /* @__PURE__ */ new Map();
+  for (const conv of allConversations) {
+    if (conv.type === "summary" || conv.type === "file-history-snapshot" || conv.type === "queue-operation" || conv.type === "progress") {
+      continue;
+    }
+    if (conv.type !== "user") continue;
+    const content = conv.message.content;
+    if (typeof content === "string") continue;
+    for (const msg of content) {
+      if (typeof msg === "string") continue;
+      if (msg.type === "tool_result") {
+        toolResultMap.set(msg.tool_use_id, msg);
+      }
+    }
+  }
   const grouped = groupConsecutiveAssistantMessages(session.conversations);
   const conversationsHtml = grouped.map((group) => {
     if (group.type === "grouped") {
       return renderGroupedAssistantEntries(
-        group.entries
+        group.entries,
+        toolResultMap,
+        sidechainData
       );
     }
     const conv = group.entries[0];
@@ -6259,7 +7139,7 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
       return renderUserEntry(conv);
     }
     if (conv.type === "assistant") {
-      return renderAssistantEntry(conv);
+      return renderAssistantEntry(conv, toolResultMap, sidechainData);
     }
     if (conv.type === "system") {
       return renderSystemEntry(conv);
@@ -6422,7 +7302,7 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
     .markdown-p {
       margin-bottom: 1rem;
       line-height: 1.75;
-      word-break: break-all;
+      word-break: break-word;
     }
 
     .inline-code {
@@ -6536,7 +7416,6 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
     }
 
     .collapsible-content {
-      max-height: 1000px;
       overflow: hidden;
       transition: max-height 0.3s ease-out, opacity 0.2s ease-out;
     }
@@ -6692,9 +7571,328 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
       color: hsl(var(--muted-foreground));
       font-size: 0.875rem;
     }
-  </style>
-</head>
-<body>
+
+    /* Enhanced Markdown Styles */
+    .markdown-table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 1rem 0;
+      font-size: 0.875rem;
+    }
+
+    .markdown-table th,
+    .markdown-table td {
+      border: 1px solid hsl(var(--border));
+      padding: 0.5rem 0.75rem;
+      text-align: left;
+    }
+
+    .markdown-table th {
+      background: hsl(var(--muted) / 0.5);
+      font-weight: 600;
+    }
+
+    .markdown-table tr:nth-child(even) {
+      background: hsl(var(--muted) / 0.2);
+    }
+
+    .markdown-blockquote {
+      border-left: 4px solid hsl(var(--blue-600));
+      padding: 0.75rem 1rem;
+      margin: 1rem 0;
+      background: hsl(var(--muted) / 0.3);
+      color: hsl(var(--muted-foreground));
+      font-style: italic;
+    }
+
+    .markdown-ul,
+    .markdown-ol {
+      margin: 1rem 0;
+      padding-left: 1.5rem;
+    }
+
+    .markdown-ul li,
+    .markdown-ol li {
+      margin-bottom: 0.25rem;
+      line-height: 1.6;
+    }
+
+    .markdown-task-list {
+      list-style: none;
+      padding-left: 0;
+      margin: 1rem 0;
+    }
+
+    .task-item {
+      display: flex;
+      align-items: flex-start;
+      gap: 0.5rem;
+      margin-bottom: 0.25rem;
+    }
+
+    .task-checkbox {
+      margin-top: 0.25rem;
+      width: 1rem;
+      height: 1rem;
+      accent-color: hsl(var(--blue-600));
+    }
+
+    .markdown-hr {
+      border: none;
+      border-top: 2px solid hsl(var(--border));
+      margin: 2rem 0;
+    }
+
+    .markdown-del {
+      text-decoration: line-through;
+      color: hsl(var(--muted-foreground));
+    }
+
+    /* Tool Result Styles */
+    .tool-result-block {
+      margin-top: 0.75rem;
+      border: 1px solid hsl(var(--border));
+      border-radius: 0.375rem;
+      overflow: scroll;
+    }
+
+    .tool-result-error {
+      border-color: hsl(0 84% 60%);
+    }
+
+    .tool-result-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.375rem 0.75rem;
+      background: hsl(var(--muted) / 0.3);
+      font-size: 0.75rem;
+      font-weight: 500;
+    }
+
+    .tool-result-error .tool-result-header {
+      background: hsl(0 84% 60% / 0.1);
+      color: hsl(0 84% 40%);
+    }
+
+    .icon-check {
+      flex-shrink: 0;
+      color: hsl(142 76% 36%);
+    }
+
+    .tool-result-error .icon-check {
+      color: hsl(0 84% 60%);
+    }
+
+    .tool-result-label {
+      font-weight: 500;
+    }
+
+    .tool-result-content {
+      padding: 0.75rem;
+      background: hsl(var(--background));
+    }
+
+    .tool-result-text {
+      font-family: monospace;
+      font-size: 0.75rem;
+      white-space: pre-wrap;
+      word-break: break-word;
+      overflow-wrap: break-word;
+      margin: 0;
+    }
+
+    .tool-result-image {
+      max-width: 100%;
+      height: auto;
+      border-radius: 0.25rem;
+    }
+
+    /* Task Tool Styles */
+    .task-tool-block {
+      border: 1px solid hsl(142 76% 36% / 0.3);
+      background: hsl(142 76% 36% / 0.05);
+      border-radius: 0.5rem;
+      margin-bottom: 0.5rem;
+      overflow: hidden;
+    }
+
+    .task-tool-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem 0.75rem;
+      cursor: pointer;
+      background: hsl(142 76% 36% / 0.1);
+      transition: background 0.2s;
+    }
+
+    .task-tool-header:hover {
+      background: hsl(142 76% 36% / 0.15);
+    }
+
+    .icon-task {
+      color: hsl(142 76% 36%);
+      flex-shrink: 0;
+    }
+
+    .task-tool-name {
+      font-size: 0.875rem;
+      font-weight: 600;
+      color: hsl(142 76% 30%);
+    }
+
+    .task-prompt-preview {
+      flex: 1;
+      font-size: 0.75rem;
+      color: hsl(var(--muted-foreground));
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .task-tool-content {
+      padding: 0.75rem 1rem;
+      border-top: 1px solid hsl(142 76% 36% / 0.2);
+      display: flex;
+      flex-direction: column;
+      gap: 0.75rem;
+    }
+
+    .task-tool-id {
+      font-size: 0.75rem;
+    }
+
+    .task-tool-id code {
+      background: hsl(var(--background) / 0.5);
+      padding: 0.25rem 0.5rem;
+      border-radius: 0.25rem;
+      border: 1px solid hsl(142 76% 36% / 0.2);
+      font-family: monospace;
+      font-size: 0.75rem;
+    }
+
+    .task-prompt {
+      font-size: 0.875rem;
+    }
+
+    .task-prompt-text {
+      background: hsl(var(--background));
+      border: 1px solid hsl(var(--border));
+      border-radius: 0.375rem;
+      padding: 0.75rem;
+      margin-top: 0.5rem;
+    }
+
+    /* Sidechain / Subagent Styles */
+    .sidechain-container {
+      margin-top: 1rem;
+      border: 1px solid hsl(217 91% 60% / 0.3);
+      border-radius: 0.5rem;
+      overflow: hidden;
+    }
+
+    .sidechain-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem 0.75rem;
+      background: hsl(217 91% 60% / 0.1);
+      color: hsl(217 91% 40%);
+      font-size: 0.8rem;
+      font-weight: 500;
+      cursor: pointer;
+    }
+
+    .sidechain-header:hover {
+      background: hsl(217 91% 60% / 0.15);
+    }
+
+    .icon-layers {
+      flex-shrink: 0;
+    }
+
+    .sidechain-content {
+      padding: 0.75rem;
+      background: hsl(217 91% 60% / 0.02);
+      border-top: 1px solid hsl(217 91% 60% / 0.2);
+    }
+
+    .sidechain-entry {
+      margin-left: 1rem;
+      padding: 0.5rem 0.75rem;
+      border-left: 2px solid hsl(217 91% 60% / 0.3);
+      margin-bottom: 0.5rem;
+    }
+
+    .sidechain-entry:last-child {
+      margin-bottom: 0;
+    }
+
+    .sidechain-entry-header {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-bottom: 0.25rem;
+      font-size: 0.75rem;
+    }
+
+    .sidechain-role {
+      font-weight: 600;
+      padding: 0.125rem 0.375rem;
+      border-radius: 0.25rem;
+    }
+
+    .sidechain-user-entry .sidechain-role {
+      background: hsl(var(--muted));
+      color: hsl(var(--foreground));
+    }
+
+    .sidechain-assistant-entry .sidechain-role {
+      background: hsl(217 91% 60% / 0.1);
+      color: hsl(217 91% 40%);
+    }
+
+    .sidechain-system-entry .sidechain-role {
+      background: hsl(var(--muted) / 0.5);
+      color: hsl(var(--muted-foreground));
+    }
+
+    .sidechain-timestamp {
+      color: hsl(var(--muted-foreground));
+    }
+
+    .sidechain-entry-content {
+      font-size: 0.875rem;
+    }
+
+    .sidechain-entry .thinking-block,
+    .sidechain-entry .tool-use-block {
+      margin: 0.5rem 0;
+      font-size: 0.8rem;
+    }
+
+    .sidechain-entry .thinking-header,
+    .sidechain-entry .tool-use-header {
+      padding: 0.375rem 0.5rem;
+    }
+
+    .sidechain-entry .thinking-content,
+    .sidechain-entry .tool-use-content {
+      padding: 0.5rem;
+    }
+
+    /* Optimize content display */
+    .entry-content > *:first-child {
+      margin-top: 0;
+    }
+
+    .entry-content > *:last-child {
+      margin-bottom: 0;
+    }
+  </style>
+</head>
+<body>
   <div class="header">
     <div class="header-top">
       <h1>Claude Code Session Export</h1>
@@ -6763,11 +7961,12 @@ var generateSessionHtml = (session, projectId) => Effect42.gen(function* () {
 });
 
 // src/server/core/session/presentation/SessionController.ts
-var LayerImpl28 = Effect43.gen(function* () {
+var LayerImpl29 = Effect45.gen(function* () {
   const sessionRepository = yield* SessionRepository;
-  const fs = yield* FileSystem14.FileSystem;
+  const agentSessionRepository = yield* AgentSessionRepository;
+  const fs = yield* FileSystem16.FileSystem;
   const eventBus = yield* EventBus;
-  const getSession = (options) => Effect43.gen(function* () {
+  const getSession = (options) => Effect45.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -6778,7 +7977,7 @@ var LayerImpl28 = Effect43.gen(function* () {
       response: { session }
     };
   });
-  const exportSessionHtml = (options) => Effect43.gen(function* () {
+  const exportSessionHtml = (options) => Effect45.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -6790,13 +7989,17 @@ var LayerImpl28 = Effect43.gen(function* () {
         response: { error: "Session not found" }
       };
     }
-    const html = yield* generateSessionHtml(session, projectId);
+    const html = yield* generateSessionHtml(
+      session,
+      projectId,
+      agentSessionRepository
+    );
     return {
       status: 200,
       response: { html }
     };
   });
-  const deleteSession = (options) => Effect43.gen(function* () {
+  const deleteSession = (options) => Effect45.gen(function* () {
     const { projectId, sessionId } = options;
     const sessionPath = decodeSessionId(projectId, sessionId);
     const exists = yield* fs.exists(sessionPath);
@@ -6807,9 +8010,9 @@ var LayerImpl28 = Effect43.gen(function* () {
       };
     }
     const deleteResult = yield* fs.remove(sessionPath).pipe(
-      Effect43.map(() => ({ success: true, error: null })),
-      Effect43.catchAll(
-        (error) => Effect43.succeed({
+      Effect45.map(() => ({ success: true, error: null })),
+      Effect45.catchAll(
+        (error) => Effect45.succeed({
           success: false,
           error: `Failed to delete session: ${error.message}`
         })
@@ -6833,9 +8036,347 @@ var LayerImpl28 = Effect43.gen(function* () {
     deleteSession
   };
 });
-var SessionController = class extends Context34.Tag("SessionController")() {
+var SessionController = class extends Context35.Tag("SessionController")() {
   static {
-    this.Live = Layer36.effect(this, LayerImpl28);
+    this.Live = Layer37.effect(this, LayerImpl29);
+  }
+};
+
+// src/server/core/tasks/presentation/TasksController.ts
+import { Context as Context37, Effect as Effect47, Layer as Layer39 } from "effect";
+
+// src/server/core/tasks/services/TasksService.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join3 } from "node:path";
+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([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed"
+]);
+var TaskSchema = z26.object({
+  id: z26.string(),
+  subject: z26.string(),
+  description: z26.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()
+});
+var TaskCreateSchema = z26.object({
+  subject: z26.string(),
+  description: z26.string().optional(),
+  activeForm: z26.string().optional(),
+  metadata: z26.record(z26.string(), z26.any()).optional()
+});
+var TaskUpdateSchema = z26.object({
+  taskId: z26.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()
+});
+
+// src/server/core/tasks/services/TasksService.ts
+var TASKS_DIR_NAME = "tasks";
+var PROJECTS_DIR_NAME = "projects";
+var CLAUDE_DIR_NAME = ".claude";
+var TasksService = class extends Context36.Tag("TasksService")() {
+  static {
+    this.Live = Layer38.effect(
+      this,
+      Effect46.gen(function* () {
+        const fs = yield* FileSystem17.FileSystem;
+        const path = yield* Path19.Path;
+        const getClaudeDir = () => Effect46.succeed(join3(homedir5(), CLAUDE_DIR_NAME));
+        const normalizeProjectPath = (projectPath) => {
+          const normalized = projectPath.replaceAll(path.sep, "-");
+          return normalized.startsWith("-") ? normalized : `-${normalized}`;
+        };
+        const resolveProjectUuid = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          if (specificSessionId) {
+            const sessionTasksDir = path.join(
+              claudeDir,
+              TASKS_DIR_NAME,
+              specificSessionId
+            );
+            if (yield* fs.exists(sessionTasksDir)) {
+              return Option4.some(specificSessionId);
+            }
+            return Option4.none();
+          }
+          const isMetadataPath = projectPath.includes(join3(CLAUDE_DIR_NAME, PROJECTS_DIR_NAME)) && projectPath.split(path.sep).pop()?.startsWith("-");
+          let projectMetaDir;
+          if (isMetadataPath && (yield* fs.exists(projectPath))) {
+            projectMetaDir = projectPath;
+          } else {
+            const identifier = normalizeProjectPath(projectPath);
+            projectMetaDir = path.join(
+              claudeDir,
+              PROJECTS_DIR_NAME,
+              identifier
+            );
+          }
+          const exists = yield* fs.exists(projectMetaDir);
+          if (!exists) {
+            return Option4.none();
+          }
+          const files = yield* fs.readDirectory(projectMetaDir);
+          const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+          const candidates = files.filter((f) => uuidPattern.test(f));
+          if (candidates.length === 0) {
+            return Option4.none();
+          }
+          const candidateInfo = yield* Effect46.all(
+            candidates.map(
+              (file) => Effect46.gen(function* () {
+                const fullPath = path.join(projectMetaDir, file);
+                const stat = yield* fs.stat(fullPath);
+                const match = file.match(uuidPattern);
+                const uuid = match ? match[0] : file;
+                const tasksPath = path.join(claudeDir, TASKS_DIR_NAME, uuid);
+                const hasTasks = yield* fs.exists(tasksPath);
+                return {
+                  file,
+                  uuid,
+                  mtime: Option4.getOrElse(stat.mtime, () => /* @__PURE__ */ new Date(0)),
+                  hasTasks
+                };
+              })
+            ),
+            { concurrency: "unbounded" }
+          );
+          const sorted = candidateInfo.sort((a, b) => {
+            if (a.hasTasks && !b.hasTasks) return -1;
+            if (!a.hasTasks && b.hasTasks) return 1;
+            return b.mtime.getTime() - a.mtime.getTime();
+          });
+          const best = sorted[0];
+          if (!best) {
+            return Option4.none();
+          }
+          return Option4.some(best.uuid);
+        });
+        const resolveProjectUuidOrFail = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const uuidOption = yield* resolveProjectUuid(
+            projectPath,
+            specificSessionId
+          );
+          if (Option4.isNone(uuidOption)) {
+            if (specificSessionId) {
+              return yield* Effect46.fail(
+                new Error(
+                  `Requested session ${specificSessionId} has no tasks directory`
+                )
+              );
+            }
+            const claudeDir = yield* getClaudeDir();
+            const identifier = normalizeProjectPath(projectPath);
+            const projectMetaDir = path.join(
+              claudeDir,
+              PROJECTS_DIR_NAME,
+              identifier
+            );
+            return yield* Effect46.fail(
+              new Error(
+                `Project metadata directory not found or no UUID: ${projectMetaDir}`
+              )
+            );
+          }
+          return uuidOption.value;
+        });
+        const getTasksDir = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          const uuidOption = yield* resolveProjectUuid(
+            projectPath,
+            specificSessionId
+          );
+          return Option4.map(
+            uuidOption,
+            (uuid) => path.join(claudeDir, TASKS_DIR_NAME, uuid)
+          );
+        });
+        const getTasksDirOrFail = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const claudeDir = yield* getClaudeDir();
+          const uuid = yield* resolveProjectUuidOrFail(
+            projectPath,
+            specificSessionId
+          );
+          return path.join(claudeDir, TASKS_DIR_NAME, uuid);
+        });
+        const listTasks = (projectPath, specificSessionId) => Effect46.gen(function* () {
+          const tasksDirOption = yield* getTasksDir(
+            projectPath,
+            specificSessionId
+          );
+          if (Option4.isNone(tasksDirOption)) {
+            return [];
+          }
+          const tasksDir = tasksDirOption.value;
+          const exists = yield* fs.exists(tasksDir);
+          if (!exists) {
+            return [];
+          }
+          const files = yield* fs.readDirectory(tasksDir);
+          const tasks = [];
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            const content = yield* fs.readFileString(path.join(tasksDir, file));
+            try {
+              const task = JSON.parse(content);
+              const parsed = TaskSchema.safeParse(task);
+              if (parsed.success) {
+                tasks.push(parsed.data);
+              } else {
+                console.warn(`Invalid task file ${file}:`, parsed.error);
+                const fallbackTask = {
+                  id: typeof task === "object" && task !== null && "id" in task && typeof task.id === "string" ? task.id : file.replace(".json", ""),
+                  subject: typeof task === "object" && task !== null && "subject" in task && typeof task.subject === "string" ? task.subject : typeof task === "object" && task !== null && "title" in task && typeof task.title === "string" ? task.title : "Invalid Task Schema",
+                  description: `Validation Error: ${JSON.stringify(parsed.error.format())}. Raw: ${JSON.stringify(task)}`,
+                  status: typeof task === "object" && task !== null && "status" in task && typeof task.status === "string" && (task.status === "pending" || task.status === "in_progress" || task.status === "completed" || task.status === "failed") ? task.status : "failed",
+                  blocks: [],
+                  blockedBy: []
+                };
+                tasks.push(fallbackTask);
+              }
+            } catch (e) {
+              console.error(`Failed to parse task file ${file}`, e);
+              const fallbackTask = {
+                id: file.replace(".json", ""),
+                subject: "Corrupted Task File",
+                description: String(e),
+                status: "failed",
+                blocks: [],
+                blockedBy: []
+              };
+              tasks.push(fallbackTask);
+            }
+          }
+          return tasks.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+        });
+        const getTask = (projectPath, taskId, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const taskFile = path.join(tasksDir, `${taskId}.json`);
+          const exists = yield* fs.exists(taskFile);
+          if (!exists) {
+            return yield* Effect46.fail(new Error(`Task ${taskId} not found`));
+          }
+          const content = yield* fs.readFileString(taskFile);
+          const task = JSON.parse(content);
+          return yield* Effect46.try(() => TaskSchema.parse(task));
+        });
+        const createTask = (projectPath, taskDef, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const dirExists = yield* fs.exists(tasksDir);
+          if (!dirExists) {
+            yield* fs.makeDirectory(tasksDir, { recursive: true });
+          }
+          const files = yield* fs.readDirectory(tasksDir);
+          let maxId = 0;
+          for (const file of files) {
+            if (file.endsWith(".json")) {
+              const idPart = file.replace(".json", "");
+              const idNum = parseInt(idPart, 10);
+              if (!Number.isNaN(idNum) && idNum > maxId) {
+                maxId = idNum;
+              }
+            }
+          }
+          const newId = (maxId + 1).toString();
+          const newTask = {
+            id: newId,
+            status: "pending",
+            blocks: [],
+            blockedBy: [],
+            ...taskDef
+          };
+          const filePath = path.join(tasksDir, `${newId}.json`);
+          yield* fs.writeFileString(filePath, JSON.stringify(newTask, null, 2));
+          return newTask;
+        });
+        const updateTask = (projectPath, update, specificSessionId) => Effect46.gen(function* () {
+          const tasksDir = yield* getTasksDirOrFail(
+            projectPath,
+            specificSessionId
+          );
+          const filePath = path.join(tasksDir, `${update.taskId}.json`);
+          const exists = yield* fs.exists(filePath);
+          if (!exists) {
+            return yield* Effect46.fail(
+              new Error(`Task ${update.taskId} not found`)
+            );
+          }
+          const content = yield* fs.readFileString(filePath);
+          const currentTask = TaskSchema.parse(JSON.parse(content));
+          const updatedTask = {
+            ...currentTask,
+            // User cannot update status via Viewer, it is managed by Claude Agent
+            status: currentTask.status,
+            subject: update.subject ?? currentTask.subject,
+            description: update.description ?? currentTask.description,
+            activeForm: update.activeForm ?? currentTask.activeForm,
+            owner: update.owner ?? currentTask.owner,
+            blockedBy: update.addBlockedBy ? [...currentTask.blockedBy || [], ...update.addBlockedBy] : currentTask.blockedBy,
+            blocks: update.addBlocks ? [...currentTask.blocks || [], ...update.addBlocks] : currentTask.blocks,
+            metadata: update.metadata ? { ...currentTask.metadata, ...update.metadata } : currentTask.metadata
+          };
+          if (updatedTask.metadata) {
+            for (const key in updatedTask.metadata) {
+              if (updatedTask.metadata[key] === null) {
+                delete updatedTask.metadata[key];
+              }
+            }
+          }
+          yield* fs.writeFileString(
+            filePath,
+            JSON.stringify(updatedTask, null, 2)
+          );
+          return updatedTask;
+        });
+        return {
+          listTasks,
+          getTask,
+          createTask,
+          updateTask
+        };
+      })
+    );
+  }
+};
+
+// src/server/core/tasks/presentation/TasksController.ts
+var make = Effect47.gen(function* () {
+  const service = yield* TasksService;
+  const listTasks = (projectPath, specificSessionId) => service.listTasks(projectPath, specificSessionId);
+  const createTask = (projectPath, task, specificSessionId) => service.createTask(projectPath, task, specificSessionId);
+  const updateTask = (projectPath, task, specificSessionId) => service.updateTask(projectPath, task, specificSessionId);
+  return {
+    listTasks,
+    createTask,
+    updateTask
+  };
+});
+var TasksController = class extends Context37.Tag("TasksController")() {
+  static {
+    this.Live = Layer39.effect(this, make);
   }
 };
 
@@ -6844,12 +8385,12 @@ import { Hono } from "hono";
 var honoApp = new Hono();
 
 // src/server/hono/initialize.ts
-import { Context as Context35, Effect as Effect44, Layer as Layer37, Ref as Ref13, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context35.Tag("InitializeService")() {
+import { Context as Context38, Effect as Effect48, Layer as Layer40, Ref as Ref14, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context38.Tag("InitializeService")() {
   static {
-    this.Live = Layer37.effect(
+    this.Live = Layer40.effect(
       this,
-      Effect44.gen(function* () {
+      Effect48.gen(function* () {
         const eventBus = yield* EventBus;
         const fileWatcher = yield* FileWatcherService;
         const projectRepository = yield* ProjectRepository;
@@ -6857,22 +8398,24 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
         const projectMetaService = yield* ProjectMetaService;
         const sessionMetaService = yield* SessionMetaService;
         const virtualConversationDatabase = yield* VirtualConversationDatabase;
-        const listenersRef = yield* Ref13.make({});
+        const rateLimitAutoScheduleService = yield* RateLimitAutoScheduleService;
+        const listenersRef = yield* Ref14.make({});
         const startInitialization = () => {
-          return Effect44.gen(function* () {
+          return Effect48.gen(function* () {
             yield* fileWatcher.startWatching();
-            const daemon = Effect44.repeat(
+            yield* rateLimitAutoScheduleService.start();
+            const daemon = Effect48.repeat(
               eventBus.emit("heartbeat", {}),
               Schedule2.fixed("10 seconds")
             );
             console.log("start heartbeat");
-            yield* Effect44.forkDaemon(daemon);
+            yield* Effect48.forkDaemon(daemon);
             console.log("after starting heartbeat fork");
             const onSessionChanged = (event) => {
-              Effect44.runFork(
+              Effect48.runFork(
                 projectMetaService.invalidateProject(event.projectId)
               );
-              Effect44.runFork(
+              Effect48.runFork(
                 sessionMetaService.invalidateSession(
                   event.projectId,
                   event.sessionId
@@ -6881,7 +8424,7 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
             };
             const onSessionProcessChanged = (event) => {
               if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect44.runFork(
+                Effect48.runFork(
                   virtualConversationDatabase.deleteVirtualConversations(
                     event.changed.sessionId
                   )
@@ -6889,18 +8432,18 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
                 return;
               }
             };
-            yield* Ref13.set(listenersRef, {
+            yield* Ref14.set(listenersRef, {
               sessionChanged: onSessionChanged,
               sessionProcessChanged: onSessionProcessChanged
             });
             yield* eventBus.on("sessionChanged", onSessionChanged);
             yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect44.gen(function* () {
+            yield* Effect48.gen(function* () {
               console.log("Initializing projects cache");
               const { projects } = yield* projectRepository.getProjects();
               console.log(`${projects.length} projects cache initialized`);
               console.log("Initializing sessions cache");
-              const results = yield* Effect44.all(
+              const results = yield* Effect48.all(
                 projects.map(
                   (project) => sessionRepository.getSessions(project.id)
                 ),
@@ -6912,13 +8455,13 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
               );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect44.catchAll(() => Effect44.void),
-              Effect44.withSpan("initialize-cache")
+              Effect48.catchAll(() => Effect48.void),
+              Effect48.withSpan("initialize-cache")
             );
-          }).pipe(Effect44.withSpan("start-initialization"));
+          }).pipe(Effect48.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect44.gen(function* () {
-          const listeners = yield* Ref13.get(listenersRef);
+        const stopCleanup = () => Effect48.gen(function* () {
+          const listeners = yield* Ref14.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
           }
@@ -6928,7 +8471,8 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
               listeners.sessionProcessChanged
             );
           }
-          yield* Ref13.set(listenersRef, {});
+          yield* Ref14.set(listenersRef, {});
+          yield* rateLimitAutoScheduleService.stop();
           yield* fileWatcher.stop();
         });
         return {
@@ -6941,7 +8485,7 @@ var InitializeService = class extends Context35.Tag("InitializeService")() {
 };
 
 // src/server/hono/middleware/auth.middleware.ts
-import { Context as Context36, Effect as Effect45, Layer as Layer38 } from "effect";
+import { Context as Context39, Effect as Effect49, Layer as Layer41 } from "effect";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 var generateSessionToken = (password) => {
@@ -6956,9 +8500,9 @@ var PUBLIC_API_ROUTES = [
   // Allow config access for theme/locale loading
   "/api/version"
 ];
-var LayerImpl29 = Effect45.gen(function* () {
+var LayerImpl30 = Effect49.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
-  return Effect45.gen(function* () {
+  return Effect49.gen(function* () {
     const anthPassword = yield* ccvOptionsService.getCcvOptions("password");
     const authEnabled = anthPassword !== void 0;
     const validSessionToken = generateSessionToken(anthPassword);
@@ -6986,77 +8530,77 @@ var LayerImpl29 = Effect45.gen(function* () {
     };
   });
 });
-var AuthMiddleware = class extends Context36.Tag("AuthMiddleware")() {
+var AuthMiddleware = class extends Context39.Tag("AuthMiddleware")() {
   static {
-    this.Live = Layer38.effect(this, LayerImpl29);
+    this.Live = Layer41.effect(this, LayerImpl30);
   }
 };
 
 // src/server/hono/route.ts
 import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect47, Runtime as Runtime3 } from "effect";
+import { Effect as Effect51, Runtime as Runtime3 } from "effect";
 import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 
 // src/server/core/claude-code/schema.ts
-import { z as z25 } from "zod";
-var mediaTypeSchema = z25.enum([
+import { z as z27 } from "zod";
+var mediaTypeSchema = z27.enum([
   "image/png",
   "image/jpeg",
   "image/gif",
   "image/webp"
 ]);
-var imageBlockSchema = z25.object({
-  type: z25.literal("image"),
-  source: z25.object({
-    type: z25.literal("base64"),
+var imageBlockSchema = z27.object({
+  type: z27.literal("image"),
+  source: z27.object({
+    type: z27.literal("base64"),
     media_type: mediaTypeSchema,
-    data: z25.string()
+    data: z27.string()
   })
 });
-var documentBlockSchema = z25.object({
-  type: z25.literal("document"),
-  source: z25.union([
-    z25.object({
-      type: z25.literal("text"),
-      media_type: z25.enum(["text/plain"]),
-      data: z25.string()
+var documentBlockSchema = z27.object({
+  type: z27.literal("document"),
+  source: z27.union([
+    z27.object({
+      type: z27.literal("text"),
+      media_type: z27.enum(["text/plain"]),
+      data: z27.string()
     }),
-    z25.object({
-      type: z25.literal("base64"),
-      media_type: z25.enum(["application/pdf"]),
-      data: z25.string()
+    z27.object({
+      type: z27.literal("base64"),
+      media_type: z27.enum(["application/pdf"]),
+      data: z27.string()
     })
   ])
 });
-var userMessageInputSchema = z25.object({
-  text: z25.string().min(1),
-  images: z25.array(imageBlockSchema).optional(),
-  documents: z25.array(documentBlockSchema).optional()
+var userMessageInputSchema = z27.object({
+  text: z27.string().min(1),
+  images: z27.array(imageBlockSchema).optional(),
+  documents: z27.array(documentBlockSchema).optional()
 });
 
 // src/server/core/git/schema.ts
-import { z as z26 } from "zod";
-var CommitRequestSchema = z26.object({
-  projectId: z26.string().min(1),
-  files: z26.array(z26.string().min(1)).min(1),
-  message: z26.string().trim().min(1)
+import { z as z28 } from "zod";
+var CommitRequestSchema = z28.object({
+  projectId: z28.string().min(1),
+  files: z28.array(z28.string().min(1)).min(1),
+  message: z28.string().trim().min(1)
 });
-var PushRequestSchema = z26.object({
-  projectId: z26.string().min(1)
+var PushRequestSchema = z28.object({
+  projectId: z28.string().min(1)
 });
-var CommitResultSuccessSchema = z26.object({
-  success: z26.literal(true),
-  commitSha: z26.string().length(40),
-  filesCommitted: z26.number().int().positive(),
-  message: z26.string()
+var CommitResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  commitSha: z28.string().length(40),
+  filesCommitted: z28.number().int().positive(),
+  message: z28.string()
 });
-var CommitResultErrorSchema = z26.object({
-  success: z26.literal(false),
-  error: z26.string(),
-  errorCode: z26.enum([
+var CommitResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  error: z28.string(),
+  errorCode: z28.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -7064,22 +8608,22 @@ var CommitResultErrorSchema = z26.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z26.string().optional()
+  details: z28.string().optional()
 });
-var CommitResultSchema = z26.discriminatedUnion("success", [
+var CommitResultSchema = z28.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z26.object({
-  success: z26.literal(true),
-  remote: z26.string(),
-  branch: z26.string(),
-  objectsPushed: z26.number().int().optional()
+var PushResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  remote: z28.string(),
+  branch: z28.string(),
+  objectsPushed: z28.number().int().optional()
 });
-var PushResultErrorSchema = z26.object({
-  success: z26.literal(false),
-  error: z26.string(),
-  errorCode: z26.enum([
+var PushResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  error: z28.string(),
+  errorCode: z28.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -7089,26 +8633,26 @@ var PushResultErrorSchema = z26.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z26.string().optional()
+  details: z28.string().optional()
 });
-var PushResultSchema = z26.discriminatedUnion("success", [
+var PushResultSchema = z28.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z26.object({
-  success: z26.literal(true),
-  commitSha: z26.string().length(40),
-  filesCommitted: z26.number().int().positive(),
-  message: z26.string(),
-  remote: z26.string(),
-  branch: z26.string()
+var CommitAndPushResultSuccessSchema = z28.object({
+  success: z28.literal(true),
+  commitSha: z28.string().length(40),
+  filesCommitted: z28.number().int().positive(),
+  message: z28.string(),
+  remote: z28.string(),
+  branch: z28.string()
 });
-var CommitAndPushResultErrorSchema = z26.object({
-  success: z26.literal(false),
-  commitSucceeded: z26.boolean(),
-  commitSha: z26.string().length(40).optional(),
-  error: z26.string(),
-  errorCode: z26.enum([
+var CommitAndPushResultErrorSchema = z28.object({
+  success: z28.literal(false),
+  commitSucceeded: z28.boolean(),
+  commitSha: z28.string().length(40).optional(),
+  error: z28.string(),
+  errorCode: z28.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -7121,36 +8665,37 @@ var CommitAndPushResultErrorSchema = z26.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z26.string().optional()
+  details: z28.string().optional()
 });
-var CommitAndPushResultSchema = z26.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z28.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
 
 // 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")
+  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({});
 
 // src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect46 } from "effect";
+import { Effect as Effect50 } from "effect";
 var effectToResponse = async (ctx, effect) => {
-  const result = await Effect46.runPromise(effect);
+  const result = await Effect50.runPromise(effect);
   const result2 = ctx.json(result.response, result.status);
   return result2;
 };
@@ -7193,7 +8738,7 @@ var configMiddleware = createMiddleware2(
 );
 
 // src/server/hono/route.ts
-var routes = (app, options) => Effect47.gen(function* () {
+var routes = (app, options) => Effect51.gen(function* () {
   const ccvOptionsService = yield* CcvOptionsService;
   yield* ccvOptionsService.loadCliOptions(options);
   const envService = yield* EnvService;
@@ -7212,9 +8757,10 @@ var routes = (app, options) => Effect47.gen(function* () {
   const schedulerController = yield* SchedulerController;
   const featureFlagController = yield* FeatureFlagController;
   const searchController = yield* SearchController;
+  const tasksController = yield* TasksController;
   const authMiddlewareService = yield* AuthMiddleware;
   const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* authMiddlewareService;
-  const runtime = yield* Effect47.runtime();
+  const runtime = yield* Effect51.runtime();
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
     prexit(async () => {
@@ -7222,7 +8768,7 @@ var routes = (app, options) => Effect47.gen(function* () {
     });
   }
   return app.use(configMiddleware).use(authMiddleware).use(async (c, next) => {
-    await Effect47.runPromise(
+    await Effect51.runPromise(
       userConfigService.setUserConfig({
         ...c.get("userConfig")
       })
@@ -7230,7 +8776,7 @@ var routes = (app, options) => Effect47.gen(function* () {
     await next();
   }).post(
     "/api/auth/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) {
@@ -7284,14 +8830,14 @@ var routes = (app, options) => Effect47.gen(function* () {
     return response;
   }).get(
     "/api/projects/:projectId",
-    zValidator("query", z29.object({ cursor: z29.string().optional() })),
+    zValidator("query", z31.object({ cursor: z31.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
         projectController.getProject({
           ...c.req.param(),
           ...c.req.valid("query")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7299,8 +8845,8 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/projects",
     zValidator(
       "json",
-      z29.object({
-        projectPath: z29.string().min(1, "Project path is required")
+      z31.object({
+        projectPath: z31.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -7308,7 +8854,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         c,
         projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7317,13 +8863,13 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect47.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect47.provide(runtime))
+      sessionController.getSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
@@ -7331,19 +8877,19 @@ var routes = (app, options) => Effect47.gen(function* () {
     async (c) => {
       const response = await effectToResponse(
         c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect47.provide(runtime))
+        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).delete("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.deleteSession({ ...c.req.param() }).pipe(Effect47.provide(runtime))
+      sessionController.deleteSession({ ...c.req.param() }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
     "/api/projects/:projectId/agent-sessions/:agentId",
-    zValidator("query", z29.object({ sessionId: z29.string().optional() })),
+    zValidator("query", z31.object({ sessionId: z31.string().optional() })),
     async (c) => {
       const { projectId, agentId } = c.req.param();
       const { sessionId } = c.req.valid("query");
@@ -7353,7 +8899,7 @@ var routes = (app, options) => Effect47.gen(function* () {
           projectId,
           agentId,
           sessionId
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7362,16 +8908,16 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       gitController.getCurrentRevisions({
         ...c.req.param()
-      }).pipe(Effect47.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).post(
     "/api/projects/:projectId/git/diff",
     zValidator(
       "json",
-      z29.object({
-        fromRef: z29.string().min(1, "fromRef is required"),
-        toRef: z29.string().min(1, "toRef is required")
+      z31.object({
+        fromRef: z31.string().min(1, "fromRef is required"),
+        toRef: z31.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -7380,7 +8926,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         gitController.getGitDiff({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7393,7 +8939,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         gitController.commitFiles({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7406,7 +8952,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         gitController.pushCommits({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7419,7 +8965,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         gitController.commitAndPush({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7428,7 +8974,7 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       claudeCodeController.getClaudeCommands({
         ...c.req.param()
-      }).pipe(Effect47.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/mcp/list", async (c) => {
@@ -7436,19 +8982,19 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       claudeCodeController.getMcpListRoute({
         ...c.req.param()
-      }).pipe(Effect47.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect47.provide(runtime))
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/features", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect47.provide(runtime))
+      claudeCodeController.getAvailableFeatures().pipe(Effect51.provide(runtime))
     );
     return response;
   }).get("/api/cc/session-processes", async (c) => {
@@ -7461,10 +9007,10 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/session-processes",
     zValidator(
       "json",
-      z29.object({
-        projectId: z29.string(),
+      z31.object({
+        projectId: z31.string(),
         input: userMessageInputSchema,
-        baseSessionId: z29.string().optional()
+        baseSessionId: z31.string().optional()
       })
     ),
     async (c) => {
@@ -7480,10 +9026,10 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/session-processes/:sessionProcessId/continue",
     zValidator(
       "json",
-      z29.object({
-        projectId: z29.string(),
+      z31.object({
+        projectId: z31.string(),
         input: userMessageInputSchema,
-        baseSessionId: z29.string()
+        baseSessionId: z31.string()
       })
     ),
     async (c) => {
@@ -7492,16 +9038,16 @@ var routes = (app, options) => Effect47.gen(function* () {
         claudeCodeSessionProcessController.continueSessionProcess({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).post(
     "/api/cc/session-processes/:sessionProcessId/abort",
-    zValidator("json", z29.object({ projectId: z29.string() })),
+    zValidator("json", z31.object({ projectId: z31.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
-      void Effect47.runFork(
+      void Effect51.runFork(
         claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
       return c.json({ message: "Task aborted" });
@@ -7510,9 +9056,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/cc/permission-response",
     zValidator(
       "json",
-      z29.object({
-        permissionRequestId: z29.string(),
-        decision: z29.enum(["allow", "deny"])
+      z31.object({
+        permissionRequestId: z31.string(),
+        decision: z31.enum(["allow", "deny"])
       })
     ),
     async (c) => {
@@ -7529,7 +9075,7 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       async (rawStream) => {
         await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect47.provide(TypeSafeSSE.make(rawStream)))
+          sseController.handleSSE(rawStream).pipe(Effect51.provide(TypeSafeSSE.make(rawStream)))
         );
       },
       async (err) => {
@@ -7539,7 +9085,7 @@ var routes = (app, options) => Effect47.gen(function* () {
   }).get("/api/scheduler/jobs", async (c) => {
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect47.provide(runtime))
+      schedulerController.getJobs().pipe(Effect51.provide(runtime))
     );
     return response;
   }).post(
@@ -7550,7 +9096,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         c,
         schedulerController.addJob({
           job: c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7563,7 +9109,7 @@ var routes = (app, options) => Effect47.gen(function* () {
         schedulerController.updateJob({
           id: c.req.param("id"),
           job: c.req.valid("json")
-        }).pipe(Effect47.provide(runtime))
+        }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
@@ -7572,16 +9118,16 @@ var routes = (app, options) => Effect47.gen(function* () {
       c,
       schedulerController.deleteJob({
         id: c.req.param("id")
-      }).pipe(Effect47.provide(runtime))
+      }).pipe(Effect51.provide(runtime))
     );
     return response;
   }).get(
     "/api/fs/file-completion",
     zValidator(
       "query",
-      z29.object({
-        projectId: z29.string(),
-        basePath: z29.string().optional().default("/api/")
+      z31.object({
+        projectId: z31.string(),
+        basePath: z31.string().optional().default("/api/")
       })
     ),
     async (c) => {
@@ -7597,9 +9143,9 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/fs/directory-browser",
     zValidator(
       "query",
-      z29.object({
-        currentPath: z29.string().optional(),
-        showHidden: z29.string().optional().transform((val) => val === "true")
+      z31.object({
+        currentPath: z31.string().optional(),
+        showHidden: z31.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {
@@ -7615,42 +9161,119 @@ var routes = (app, options) => Effect47.gen(function* () {
     "/api/search",
     zValidator(
       "query",
-      z29.object({
-        q: z29.string().min(2),
-        limit: z29.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
-        projectId: z29.string().optional()
+      z31.object({
+        q: z31.string().min(2),
+        limit: z31.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z31.string().optional()
       })
     ),
     async (c) => {
       const { q, limit, projectId } = c.req.valid("query");
       const response = await effectToResponse(
         c,
-        searchController.search({ query: q, limit, projectId }).pipe(Effect47.provide(runtime))
+        searchController.search({ query: q, limit, projectId }).pipe(Effect51.provide(runtime))
       );
       return response;
     }
   ).get("/api/flags", async (c) => {
     const response = await effectToResponse(
       c,
-      featureFlagController.getFlags().pipe(Effect47.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect51.provide(runtime))
     );
     return response;
-  });
+  }).get(
+    "/api/tasks",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    async (c) => {
+      const { projectId, sessionId } = c.req.valid("query");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.listTasks(projectPath, sessionId).pipe(
+          Effect51.map((tasks) => ({
+            status: 200,
+            response: tasks
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  ).post(
+    "/api/tasks",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    zValidator("json", TaskCreateSchema),
+    async (c) => {
+      const { projectId, sessionId } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.createTask(projectPath, body, sessionId).pipe(
+          Effect51.map((task) => ({
+            status: 200,
+            response: task
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  ).patch(
+    "/api/tasks/:id",
+    zValidator(
+      "query",
+      z31.object({
+        projectId: z31.string(),
+        sessionId: z31.string().optional()
+      })
+    ),
+    zValidator("json", TaskUpdateSchema.omit({ taskId: true })),
+    async (c) => {
+      const { id } = c.req.param();
+      const { projectId, sessionId } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const projectPath = decodeProjectId(projectId);
+      const response = await effectToResponse(
+        c,
+        tasksController.updateTask(projectPath, { ...body, taskId: id }, sessionId).pipe(
+          Effect51.map((task) => ({
+            status: 200,
+            response: task
+          })),
+          Effect51.provide(runtime)
+        )
+      );
+      return response;
+    }
+  );
 });
 
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer39 } from "effect";
-var platformLayer = Layer39.mergeAll(
+import { Layer as Layer42 } from "effect";
+var platformLayer = Layer42.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
   EnvService.Live,
   CcvOptionsService.Live
 ).pipe(
-  Layer39.provide(EnvService.Live),
-  Layer39.provide(CcvOptionsService.Live),
-  Layer39.provide(NodeContext.layer)
+  Layer42.provide(EnvService.Live),
+  Layer42.provide(CcvOptionsService.Live),
+  Layer42.provide(NodeContext.layer)
 );
 
 // src/server/startServer.ts
@@ -7673,49 +9296,8 @@ var startServer = async (options) => {
       return c.html(html);
     });
   }
-  const program2 = routes(honoApp, options).pipe(
-    /** Presentation */
-    Effect48.provide(ProjectController.Live),
-    Effect48.provide(SessionController.Live),
-    Effect48.provide(AgentSessionController.Live),
-    Effect48.provide(GitController.Live),
-    Effect48.provide(ClaudeCodeController.Live),
-    Effect48.provide(ClaudeCodeSessionProcessController.Live),
-    Effect48.provide(ClaudeCodePermissionController.Live),
-    Effect48.provide(FileSystemController.Live),
-    Effect48.provide(SSEController.Live),
-    Effect48.provide(SchedulerController.Live),
-    Effect48.provide(FeatureFlagController.Live),
-    Effect48.provide(SearchController.Live)
-  ).pipe(
-    /** Application */
-    Effect48.provide(InitializeService.Live),
-    Effect48.provide(FileWatcherService.Live),
-    Effect48.provide(AuthMiddleware.Live)
-  ).pipe(
-    /** Domain */
-    Effect48.provide(ClaudeCodeLifeCycleService.Live),
-    Effect48.provide(ClaudeCodePermissionService.Live),
-    Effect48.provide(ClaudeCodeSessionProcessService.Live),
-    Effect48.provide(ClaudeCodeService.Live),
-    Effect48.provide(GitService.Live),
-    Effect48.provide(SchedulerService.Live),
-    Effect48.provide(SchedulerConfigBaseDir.Live),
-    Effect48.provide(SearchService.Live)
-  ).pipe(
-    /** Infrastructure */
-    Effect48.provide(ProjectRepository.Live),
-    Effect48.provide(SessionRepository.Live),
-    Effect48.provide(ProjectMetaService.Live),
-    Effect48.provide(SessionMetaService.Live),
-    Effect48.provide(VirtualConversationDatabase.Live),
-    Effect48.provide(AgentSessionLayer)
-  ).pipe(
-    /** Platform */
-    Effect48.provide(platformLayer),
-    Effect48.provide(NodeContext2.layer)
-  );
-  await Effect48.runPromise(program2);
+  const program2 = routes(honoApp, options).pipe(Effect52.provide(MainLayer));
+  await Effect52.runPromise(program2);
   const port = isDevelopment ? (
     // biome-ignore lint/style/noProcessEnv: allow only here
     process.env.DEV_BE_PORT ?? "3401"
@@ -7735,12 +9317,65 @@ var startServer = async (options) => {
     }
   );
 };
+var PlatformLayer = Layer43.mergeAll(platformLayer, NodeContext2.layer);
+var InfraBasics = Layer43.mergeAll(
+  VirtualConversationDatabase.Live,
+  ProjectMetaService.Live,
+  SessionMetaService.Live
+);
+var InfraRepos = Layer43.mergeAll(
+  ProjectRepository.Live,
+  SessionRepository.Live
+).pipe(Layer43.provideMerge(InfraBasics));
+var InfraLayer = AgentSessionLayer.pipe(Layer43.provideMerge(InfraRepos));
+var DomainBase = Layer43.mergeAll(
+  ClaudeCodePermissionService.Live,
+  ClaudeCodeSessionProcessService.Live,
+  ClaudeCodeService.Live,
+  GitService.Live,
+  SchedulerService.Live,
+  SchedulerConfigBaseDir.Live,
+  SearchService.Live,
+  TasksService.Live
+);
+var DomainLayer = ClaudeCodeLifeCycleService.Live.pipe(
+  Layer43.provideMerge(DomainBase)
+);
+var AppServices = Layer43.mergeAll(
+  FileWatcherService.Live,
+  RateLimitAutoScheduleService.Live,
+  AuthMiddleware.Live
+);
+var ApplicationLayer = InitializeService.Live.pipe(
+  Layer43.provideMerge(AppServices)
+);
+var PresentationLayer = Layer43.mergeAll(
+  ProjectController.Live,
+  SessionController.Live,
+  AgentSessionController.Live,
+  GitController.Live,
+  ClaudeCodeController.Live,
+  ClaudeCodeSessionProcessController.Live,
+  ClaudeCodePermissionController.Live,
+  FileSystemController.Live,
+  SSEController.Live,
+  SchedulerController.Live,
+  FeatureFlagController.Live,
+  SearchController.Live,
+  TasksController.Live
+);
+var MainLayer = PresentationLayer.pipe(
+  Layer43.provideMerge(ApplicationLayer),
+  Layer43.provideMerge(DomainLayer),
+  Layer43.provideMerge(InfraLayer),
+  Layer43.provideMerge(PlatformLayer)
+);
 
 // src/server/main.ts
 var program = new Command3();
 program.name(package_default.name).version(package_default.version).description(package_default.description);
 program.option("-p, --port <port>", "port to listen on").option("-h, --hostname <hostname>", "hostname to listen on").option("-P, --password <password>", "password to authenticate").option("-e, --executable <executable>", "path to claude code executable").option("--claude-dir <claude-dir>", "path to claude directory").action(async (options) => {
-  await Effect49.runPromise(checkDeprecatedEnvs);
+  await Effect53.runPromise(checkDeprecatedEnvs);
   await startServer(options);
 });
 var main = async () => {