@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

package/server/modules/providers/list/claude/claude-sessions.provider.ts

@@ -4,17 +4,41 @@ import path from 'node:path';
 import readline from 'node:readline';
 
 import type { IProviderSessions } from '@/shared/interfaces.js';
-import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import type {
+  AnyRecord,
+  FetchHistoryOptions,
+  FetchHistoryResult,
+  NormalizedMessage,
+  SubagentActivity,
+  SubagentInfo,
+} from '@/shared/types.js';
 import { parseFilesInputTag } from '@/shared/image-attachments.js';
-import { createNormalizedMessage, generateMessageId, readObjectRecord, sliceTailPage } from '@/shared/utils.js';
+import { prepareTranscriptMessages } from '@/shared/message-unification.js';
+import {
+  createNormalizedMessage,
+  generateMessageId,
+  readObjectRecord,
+  sliceTailPage,
+  truncateSubagentActivity,
+} from '@/shared/utils.js';
 import { sessionsDb } from '@/modules/database/index.js';
+import { summarizeClaudeTokenUsage } from '@/modules/providers/services/provider-token-usage.service.js';
 
 const PROVIDER = 'claude';
 
+/**
+ * Upper bound on how much of a subagent's timeline is sent to the client. A
+ * long-running agent can record hundreds of tool calls, and the transcript only
+ * ever shows them behind a collapsed header, so shipping the whole history on
+ * every load costs far more than it shows.
+ */
+const MAX_TRANSMITTED_SUBAGENT_ACTIVITIES = 200;
+
 type ClaudeToolResult = {
   content: unknown;
   isError: boolean;
-  subagentTools?: unknown;
+  subagentTools?: SubagentActivity[];
+  subagent?: SubagentInfo;
   toolUseResult?: unknown;
 };
 
@@ -36,8 +60,27 @@ type ClaudeHistoryMessagesResult =
     limit?: number | null;
   };
 
-async function parseAgentTools(filePath: string): Promise<AnyRecord[]> {
-  const tools: AnyRecord[] = [];
+type ClaudeSubagentTranscript = {
+  activity: SubagentActivity[];
+  model?: string;
+  /**
+   * True when the transcript's last tool call never received a result, which
+   * is the only evidence in the file that the agent stopped mid-flight.
+   */
+  endedMidToolCall: boolean;
+};
+
+/**
+ * Flattens one subagent transcript into the shared activity timeline.
+ *
+ * Assistant prose and reasoning are kept alongside the tool calls so the
+ * transcript can replay what the agent actually did rather than listing tool
+ * names with no narrative.
+ */
+async function readClaudeSubagentTranscript(filePath: string): Promise<ClaudeSubagentTranscript> {
+  const activity: SubagentActivity[] = [];
+  const transcript: ClaudeSubagentTranscript = { activity, endedMidToolCall: false };
+  const toolsById = new Map<string, SubagentActivity>();
 
   try {
     const fileStream = fs.createReadStream(filePath);
@@ -53,16 +96,34 @@ async function parseAgentTools(filePath: string): Promise<AnyRecord[]> {
 
       try {
         const entry = JSON.parse(line) as AnyRecord;
+        const timestamp = typeof entry.timestamp === 'string' ? entry.timestamp : undefined;
 
         if (entry.message?.role === 'assistant' && Array.isArray(entry.message?.content)) {
+          if (typeof entry.message.model === 'string') {
+            transcript.model = entry.message.model;
+          }
+
           for (const part of entry.message.content as AnyRecord[]) {
             if (part.type === 'tool_use') {
-              tools.push({
-                toolId: part.id,
-                toolName: part.name,
+              const tool: SubagentActivity = {
+                kind: 'tool',
+                toolId: String(part.id ?? ''),
+                toolName: String(part.name ?? 'Tool'),
                 toolInput: part.input,
-                timestamp: entry.timestamp,
-              });
+                timestamp,
+              };
+              activity.push(tool);
+              if (tool.toolId) {
+                toolsById.set(tool.toolId, tool);
+              }
+              continue;
+            }
+            if (part.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+              activity.push({ kind: 'text', content: part.text, timestamp });
+              continue;
+            }
+            if (part.type === 'thinking' && typeof part.thinking === 'string' && part.thinking.trim()) {
+              activity.push({ kind: 'thinking', content: part.thinking, timestamp });
             }
           }
         }
@@ -73,7 +134,7 @@ async function parseAgentTools(filePath: string): Promise<AnyRecord[]> {
               continue;
             }
 
-            const tool = tools.find((candidate) => candidate.toolId === part.tool_use_id);
+            const tool = toolsById.get(String(part.tool_use_id ?? ''));
             if (!tool) {
               continue;
             }
@@ -99,7 +160,249 @@ async function parseAgentTools(filePath: string): Promise<AnyRecord[]> {
     console.warn(`Error parsing agent file ${filePath}:`, message);
   }
 
-  return tools;
+  const lastActivity = activity[activity.length - 1];
+  transcript.endedMidToolCall = lastActivity?.kind === 'tool' && !lastActivity.toolResult;
+
+  return transcript;
+}
+
+type ClaudeSubagentMeta = {
+  agentType?: string;
+  description?: string;
+};
+
+/** Reads the sidecar `.meta.json` Claude writes next to a subagent transcript. */
+async function readClaudeSubagentMeta(metaPath: string): Promise<ClaudeSubagentMeta> {
+  try {
+    const parsed = JSON.parse(await fsp.readFile(metaPath, 'utf8')) as AnyRecord;
+    return {
+      agentType: typeof parsed.agentType === 'string' ? parsed.agentType : undefined,
+      description: typeof parsed.description === 'string' ? parsed.description : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Resolves where a subagent's transcript lives.
+ *
+ * Current Claude versions write it to
+ * `<projectDir>/<providerSessionId>/subagents/agent-<agentId>.jsonl`; older
+ * ones dropped it next to the parent transcript. Both are checked, newest
+ * layout first, because a project directory usually holds sessions from
+ * several CLI versions.
+ */
+async function findClaudeSubagentTranscript(
+  projectDirectory: string,
+  providerSessionId: string,
+  agentId: string,
+): Promise<{ transcriptPath: string; metaPath: string } | null> {
+  const candidates = [
+    path.join(projectDirectory, providerSessionId, 'subagents', `agent-${agentId}.jsonl`),
+    path.join(projectDirectory, `agent-${agentId}.jsonl`),
+  ];
+
+  for (const transcriptPath of candidates) {
+    try {
+      await fsp.access(transcriptPath);
+      return { transcriptPath, metaPath: transcriptPath.replace(/\.jsonl$/, '.meta.json') };
+    } catch {
+      // Try the next layout.
+    }
+  }
+
+  return null;
+}
+
+type ClaudeTaskNotification = {
+  /** `uuid` of the transcript row the notification came from, so it can be dropped. */
+  sourceUuid: string;
+  toolUseId: string;
+  status: string;
+  summary: string;
+  result: string;
+};
+
+function readTaggedValue(content: string, tagName: string): string {
+  const match = new RegExp(`<${tagName}>([\\s\\S]*?)<\\/${tagName}>`).exec(content);
+  return match ? match[1].trim() : '';
+}
+
+/**
+ * Collects every `<task-notification>` turn keyed by the tool call that
+ * spawned the agent it reports on.
+ *
+ * Only notifications that name a tool-use id are collected: without one there
+ * is no card to fold them into, and they must keep rendering on their own.
+ */
+function collectTaskNotifications(messages: AnyRecord[]): Map<string, ClaudeTaskNotification> {
+  const notifications = new Map<string, ClaudeTaskNotification>();
+
+  for (const message of messages) {
+    if (message.message?.role !== 'user') {
+      continue;
+    }
+
+    const content = message.message.content;
+    const texts: string[] = typeof content === 'string'
+      ? [content]
+      : Array.isArray(content)
+        ? content.filter((part: AnyRecord) => part?.type === 'text').map((part: AnyRecord) => String(part.text ?? ''))
+        : [];
+
+    for (const text of texts) {
+      if (!text.trimStart().startsWith('<task-notification>')) {
+        continue;
+      }
+
+      const toolUseId = readTaggedValue(text, 'tool-use-id');
+      if (!toolUseId) {
+        continue;
+      }
+
+      // A resumed agent notifies more than once; the last word wins.
+      notifications.set(toolUseId, {
+        sourceUuid: String(message.uuid ?? ''),
+        toolUseId,
+        status: readTaggedValue(text, 'status') || 'completed',
+        summary: readTaggedValue(text, 'summary'),
+        result: readTaggedValue(text, 'result'),
+      });
+    }
+  }
+
+  return notifications;
+}
+
+/** Reads the `tool_use_id` off the tool-result row that launched an agent. */
+function readAgentToolUseId(message: AnyRecord): string | null {
+  const content = message.message?.content;
+  if (!Array.isArray(content)) {
+    return null;
+  }
+
+  for (const part of content) {
+    if (part?.type === 'tool_result' && typeof part.tool_use_id === 'string') {
+      return part.tool_use_id;
+    }
+  }
+
+  return null;
+}
+
+/** Swaps an agent launch acknowledgement for the agent's actual answer. */
+function replaceAgentToolResultContent(message: AnyRecord, replacement: string): void {
+  const content = message.message?.content;
+  if (!Array.isArray(content)) {
+    return;
+  }
+
+  for (const part of content) {
+    if (part?.type === 'tool_result') {
+      part.content = replacement;
+    }
+  }
+}
+
+/**
+ * Reads a Claude transcript's rows as a graph keyed by `uuid`.
+ *
+ * The file is append-only and every row names its predecessor in `parentUuid`,
+ * so a conversation is a path through it rather than the whole file. Editing a
+ * sent message makes a second path appear alongside the first.
+ */
+async function readTranscriptRows(jsonlPath: string, providerSessionId: string): Promise<AnyRecord[]> {
+  const rows: AnyRecord[] = [];
+  const fileStream = fs.createReadStream(jsonlPath);
+  const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line) as AnyRecord;
+      if (entry.sessionId === providerSessionId) {
+        rows.push(entry);
+      }
+    } catch {
+      // A row can be half-written while the CLI is streaming into the file.
+    }
+  }
+
+  return rows;
+}
+
+/** True for a row the user typed, as opposed to a tool result or an injected note. */
+function isUserPromptRow(row: AnyRecord): boolean {
+  if (row.type !== 'user' || row.isMeta === true || row.isCompactSummary === true) {
+    return false;
+  }
+
+  const content = row.message?.content;
+  if (Array.isArray(content)) {
+    return content.some((part: AnyRecord) => part?.type === 'text' || part?.type === 'image');
+  }
+
+  return typeof content === 'string' && content.length > 0;
+}
+
+/**
+ * Drops the rows belonging to prompts that were replaced by an edit.
+ *
+ * When a message is edited, Claude resumes the conversation partway and appends
+ * the replacement, so two prompts end up sharing one parent and the file holds
+ * both the abandoned attempt and the live one. A flat read would show them
+ * stacked, which reads as the app having sent the message twice.
+ *
+ * Only sibling *prompts* are treated as a fork. Branch points made by parallel
+ * tool calls are extremely common — one assistant turn writes several chained
+ * rows and each tool result parents onto its own — and pruning those would
+ * delete tool output from every transcript in the app.
+ */
+function dropSupersededPromptBranches(rows: AnyRecord[]): AnyRecord[] {
+  const promptSiblings = new Map<string, AnyRecord[]>();
+  for (const row of rows) {
+    if (typeof row.parentUuid !== 'string' || !isUserPromptRow(row)) {
+      continue;
+    }
+    const siblings = promptSiblings.get(row.parentUuid);
+    if (siblings) {
+      siblings.push(row);
+    } else {
+      promptSiblings.set(row.parentUuid, [row]);
+    }
+  }
+
+  const supersededRoots = new Set<string>();
+  for (const siblings of promptSiblings.values()) {
+    if (siblings.length < 2) {
+      continue;
+    }
+    // The transcript is append-only, so the last prompt written under a parent
+    // is the one that replaced the others.
+    for (const row of siblings.slice(0, -1)) {
+      if (typeof row.uuid === 'string') {
+        supersededRoots.add(row.uuid);
+      }
+    }
+  }
+
+  if (supersededRoots.size === 0) {
+    return rows;
+  }
+
+  const abandoned = new Set(supersededRoots);
+  // Rows are appended in order, so one forward pass propagates each superseded
+  // root to its whole subtree.
+  for (const row of rows) {
+    if (typeof row.parentUuid === 'string' && abandoned.has(row.parentUuid) && typeof row.uuid === 'string') {
+      abandoned.add(row.uuid);
+    }
+  }
+
+  return rows.filter((row) => typeof row.uuid !== 'string' || !abandoned.has(row.uuid));
 }
 
 async function getSessionMessages(
@@ -118,32 +421,10 @@ async function getSessionMessages(
     }
 
     const projectDir = path.dirname(jsonLPath);
-    const files = await fsp.readdir(projectDir);
-    const agentFiles = files.filter((file) => file.endsWith('.jsonl') && file.startsWith('agent-'));
-
-    const messages: AnyRecord[] = [];
-    const agentToolsCache = new Map<string, AnyRecord[]>();
-
-    const fileStream = fs.createReadStream(jsonLPath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity,
-    });
-
-    for await (const line of rl) {
-      if (!line.trim()) {
-        continue;
-      }
 
-      try {
-        const entry = JSON.parse(line) as AnyRecord;
-        if (entry.sessionId === providerSessionId) {
-          messages.push(entry);
-        }
-      } catch {
-        // Skip malformed JSONL lines that can happen during concurrent writes.
-      }
-    }
+    const messages = dropSupersededPromptBranches(
+      await readTranscriptRows(jsonLPath, providerSessionId),
+    );
 
     const agentIds = new Set<string>();
     for (const message of messages) {
@@ -153,30 +434,97 @@ async function getSessionMessages(
       }
     }
 
+    // Read each spawned agent's own transcript once, then hang it off every
+    // row that references it.
+    const subagentsById = new Map<string, {
+      activity: SubagentActivity[];
+      info: SubagentInfo;
+      endedMidToolCall: boolean;
+    }>();
     for (const agentId of agentIds) {
-      const agentFileName = `agent-${agentId}.jsonl`;
-      if (!agentFiles.includes(agentFileName)) {
+      const located = await findClaudeSubagentTranscript(projectDir, providerSessionId, agentId);
+      if (!located) {
         continue;
       }
 
-      const agentFilePath = path.join(projectDir, agentFileName);
-      const tools = await parseAgentTools(agentFilePath);
-      agentToolsCache.set(agentId, tools);
+      const [transcript, meta] = await Promise.all([
+        readClaudeSubagentTranscript(located.transcriptPath),
+        readClaudeSubagentMeta(located.metaPath),
+      ]);
+
+      subagentsById.set(agentId, {
+        endedMidToolCall: transcript.endedMidToolCall,
+        activity: transcript.activity
+          .slice(0, MAX_TRANSMITTED_SUBAGENT_ACTIVITIES)
+          .map(truncateSubagentActivity),
+        info: {
+          id: agentId,
+          name: meta.agentType,
+          type: meta.agentType,
+          description: meta.description,
+          model: transcript.model,
+          status: 'completed',
+          activityCount: transcript.activity.length,
+        },
+      });
     }
 
+    // An async agent's launch result is internal bookkeeping ("Async agent
+    // launched successfully…"); its real answer arrives later as a separate
+    // `<task-notification>` turn. Folding the notification back onto the tool
+    // call that started the agent keeps one card per agent instead of a card,
+    // an unrelated status line, and a stray markdown reply.
+    const notificationsByToolUseId = collectTaskNotifications(messages);
+    const foldedNotificationUuids = new Set<string>();
+
     for (const message of messages) {
       const agentId = message.toolUseResult?.agentId;
       if (!agentId) {
         continue;
       }
 
-      const agentTools = agentToolsCache.get(String(agentId));
-      if (agentTools && agentTools.length > 0) {
-        message.subagentTools = agentTools;
+      const subagent = subagentsById.get(String(agentId));
+      const toolUseId = readAgentToolUseId(message);
+      const notification = toolUseId ? notificationsByToolUseId.get(toolUseId) : undefined;
+      // An async agent's launch row never tells you it finished — only the
+      // later notification does. When that notification is missing (a live run,
+      // or one compacted out of the transcript), the agent's own transcript is
+      // the evidence: a timeline that does not stop mid-tool-call is done.
+      const isAwaitingAsyncAgent = message.toolUseResult?.isAsync === true
+        && !notification
+        && (!subagent || subagent.endedMidToolCall);
+
+      if (subagent) {
+        if (subagent.activity.length > 0) {
+          message.subagentTools = subagent.activity;
+        }
+        message.subagent = {
+          ...subagent.info,
+          description: subagent.info.description
+            ?? (typeof message.toolUseResult?.description === 'string' ? message.toolUseResult.description : undefined),
+          model: subagent.info.model
+            ?? (typeof message.toolUseResult?.resolvedModel === 'string' ? message.toolUseResult.resolvedModel : undefined),
+          status: isAwaitingAsyncAgent
+            ? 'running'
+            : notification && notification.status !== 'completed'
+              ? 'failed'
+              : 'completed',
+        };
+      }
+
+      if (notification) {
+        replaceAgentToolResultContent(message, notification.result || notification.summary);
+        foldedNotificationUuids.add(notification.sourceUuid);
+      } else if (message.toolUseResult?.isAsync === true) {
+        // Without a notification there is no answer to show, and the launch
+        // acknowledgement is internal bookkeeping the user must never read.
+        replaceAgentToolResultContent(message, '');
       }
     }
 
-    const sortedMessages = messages.sort(
+    const sortedMessages = messages
+      .filter((message) => !foldedNotificationUuids.has(String(message.uuid ?? '')))
+      .sort(
       (a, b) => new Date(a.timestamp || 0).getTime() - new Date(b.timestamp || 0).getTime(),
     );
     const total = sortedMessages.length;
@@ -302,8 +650,31 @@ export class ClaudeSessionsProvider implements IProviderSessions {
   /**
    * Normalizes one Claude JSONL entry or live SDK stream event into the shared
    * message shape consumed by REST and WebSocket clients.
+   *
+   * Every user turn it produces is stamped with the transcript row's `uuid`,
+   * which is the anchor "edit this message" and "fork from here" address. It is
+   * applied here rather than at each `createNormalizedMessage` call because the
+   * row-shape branches below have several exits, and an anchor missing from one
+   * of them would show up as a message the user silently cannot edit.
    */
   normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
+    const messages = this.normalizeMessageRows(rawMessage, sessionId);
+    // A synthesized id is useless as an anchor — it changes on every read — so
+    // a row without its own uuid produces messages with no anchor at all.
+    const raw = readObjectRecord(rawMessage);
+    const anchorId = typeof raw?.uuid === 'string' && raw.uuid ? raw.uuid : null;
+    if (anchorId) {
+      for (const message of messages) {
+        if (message.role === 'user') {
+          message.transcriptAnchorId = anchorId;
+        }
+      }
+    }
+
+    return messages;
+  }
+
+  private normalizeMessageRows(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
     const raw = readObjectRecord(rawMessage);
     if (!raw) {
       return [];
@@ -347,7 +718,6 @@ export class ClaudeSessionsProvider implements IProviderSessions {
               toolId: part.tool_use_id,
               content: typeof part.content === 'string' ? part.content : JSON.stringify(part.content),
               isError: Boolean(part.is_error),
-              subagentTools: raw.subagentTools,
               toolUseResult: raw.toolUseResult,
             }));
           } else if (part.type === 'text') {
@@ -600,6 +970,56 @@ export class ClaudeSessionsProvider implements IProviderSessions {
     return messages;
   }
 
+  /**
+   * Finds the row to resume *through* so that `anchorId`'s turn is replaced.
+   *
+   * Walks up the `parentUuid` chain to the nearest assistant row, because the
+   * SDK's `resumeSessionAt` is documented against assistant message ids — the
+   * user row's immediate parent can be an attachment or an injected note.
+   * Returns `null` when nothing precedes the edited prompt, which means the
+   * conversation should start over rather than resume.
+   */
+  async resolveEditAnchor(
+    sessionId: string,
+    anchorId: string,
+  ): Promise<{ found: boolean; resumeThroughId: string | null }> {
+    const session = sessionsDb.getSessionById(sessionId);
+    const jsonlPath = session?.jsonl_path;
+    const providerSessionId = session?.provider_session_id;
+    if (!jsonlPath || !providerSessionId) {
+      return { found: false, resumeThroughId: null };
+    }
+
+    const rows = await readTranscriptRows(jsonlPath, providerSessionId);
+    const byUuid = new Map<string, AnyRecord>();
+    for (const row of rows) {
+      if (typeof row.uuid === 'string') {
+        byUuid.set(row.uuid, row);
+      }
+    }
+
+    const target = byUuid.get(anchorId);
+    if (!target) {
+      return { found: false, resumeThroughId: null };
+    }
+
+    const visited = new Set<string>([anchorId]);
+    let parentUuid: unknown = target.parentUuid;
+    while (typeof parentUuid === 'string' && !visited.has(parentUuid)) {
+      visited.add(parentUuid);
+      const parent = byUuid.get(parentUuid);
+      if (!parent) {
+        break;
+      }
+      if (parent.type === 'assistant') {
+        return { found: true, resumeThroughId: parentUuid };
+      }
+      parentUuid = parent.parentUuid;
+    }
+
+    return { found: true, resumeThroughId: null };
+  }
+
   /**
    * Loads Claude JSONL history for a project/session and returns normalized
    * messages, preserving the existing pagination behavior from projects.js.
@@ -633,6 +1053,7 @@ export class ClaudeSessionsProvider implements IProviderSessions {
               content: part.content,
               isError: Boolean(part.is_error),
               subagentTools: raw.subagentTools,
+              subagent: raw.subagent,
               toolUseResult: raw.toolUseResult,
             });
           }
@@ -660,18 +1081,17 @@ export class ClaudeSessionsProvider implements IProviderSessions {
           toolUseResult: toolResult.toolUseResult,
         };
         msg.subagentTools = toolResult.subagentTools;
+        msg.subagent = toolResult.subagent;
       }
     }
 
-    let total = 0;
-    for (const msg of normalized) {
-      if (msg.kind !== 'tool_result') {
-        total += 1;
-      }
-    }
+    // Everything the transcript draws, and nothing else — so a page of N rows
+    // is N rows the user sees, and `total` counts the same thing.
+    const transcript = prepareTranscriptMessages(normalized);
+    const total = transcript.length;
     const normalizedOffset = Math.max(0, offset);
     const normalizedLimit = limit === null ? null : Math.max(0, limit);
-    const { page, hasMore } = sliceTailPage(normalized, normalizedLimit, normalizedOffset);
+    const { page, hasMore } = sliceTailPage(transcript, normalizedLimit, normalizedOffset);
 
     return {
       messages: page,
@@ -679,6 +1099,10 @@ export class ClaudeSessionsProvider implements IProviderSessions {
       hasMore,
       offset: normalizedOffset,
       limit: normalizedLimit,
+      // Carried on every page, like the Codex and OpenCode readers do, so the
+      // composer's counter tracks the conversation instead of being frozen at
+      // whatever it was when the session was opened.
+      tokenUsage: summarizeClaudeTokenUsage(rawMessages),
     };
   }
 }

package/server/modules/providers/list/claude/claude-skills.provider.ts

@@ -158,12 +158,15 @@ export class ClaudeSkillsProvider extends SkillsProvider {
             continue;
           }
 
+          // A plugin may ship commands, skills, or both, and the CLI offers
+          // both halves. Reading only the first folder found hid every skill
+          // that sits beside a commands folder -- and hid the whole plugin when
+          // its commands are in a format this reader does not take.
           const commandsPath = path.join(pluginFolder, 'commands');
           if (await pathExistsAsDirectory(commandsPath)) {
             skills.push(
               ...(await this.listPluginCommandSkills(commandsPath, pluginId, pluginName)),
             );
-            continue;
           }
 
           const skillsPath = path.join(pluginFolder, 'skills');

package/server/modules/providers/list/claude/claude.provider.ts

@@ -2,12 +2,14 @@ import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provi
 import { ClaudeProviderAuth } from '@/modules/providers/list/claude/claude-auth.provider.js';
 import { ClaudeProviderModels } from '@/modules/providers/list/claude/claude-models.provider.js';
 import { claudeRuntime } from '@/modules/providers/list/claude/claude-runtime.provider.js';
+import { ClaudeForkProvider } from '@/modules/providers/list/claude/claude-fork.provider.js';
 import { ClaudeMcpProvider } from '@/modules/providers/list/claude/claude-mcp.provider.js';
 import { ClaudeSessionSynchronizer } from '@/modules/providers/list/claude/claude-session-synchronizer.provider.js';
 import { ClaudeSessionsProvider } from '@/modules/providers/list/claude/claude-sessions.provider.js';
 import { ClaudeSkillsProvider } from '@/modules/providers/list/claude/claude-skills.provider.js';
 import type {
   IProviderAuth,
+  IProviderFork,
   IProviderModels,
   IProviderRuntime,
   IProviderSessionSynchronizer,
@@ -23,6 +25,7 @@ export class ClaudeProvider extends AbstractProvider {
   readonly skills: IProviderSkills = new ClaudeSkillsProvider();
   readonly sessions: IProviderSessions = new ClaudeSessionsProvider();
   readonly sessionSynchronizer: IProviderSessionSynchronizer = new ClaudeSessionSynchronizer();
+  readonly fork: IProviderFork = new ClaudeForkProvider();
 
   constructor() {
     super('claude');