@cloudcli-ai/cloudcli 1.37.3 → 1.37.4

package/server/modules/providers/list/codex/codex-models.provider.ts

@@ -34,6 +34,37 @@ export const CODEX_PREDEFINED_MODELS: ProviderModelsDefinition = {
         ],
       },
     },
+    {
+      value: 'gpt-6-sol',
+      label: 'GPT-6 Sol',
+      description: 'Workhorse model for coding and everyday work.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
+    {
+      value: 'gpt-6-luna',
+      label: 'GPT-6 Luna',
+      description: 'Fast and affordable model for easier tasks.',
+      effort: {
+        default: 'medium',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+        ],
+      },
+    },
     {
       value: 'gpt-5.6-sol',
       label: 'GPT-5.6 Sol',

package/server/modules/providers/list/codex/codex-runtime.provider.ts

@@ -34,6 +34,10 @@ type ActiveCodexSession = {
 
 const activeCodexSessions = new Map<string, ActiveCodexSession>();
 
+// Codex CLI requires non-whitespace stdin even when --image arguments are
+// present, so attachment-only turns need a small text instruction.
+const CODEX_IMAGE_ONLY_PROMPT = 'Please analyze the attached image(s).';
+
 /**
  * Item types whose in-flight updates are worth showing. These are the ones a
  * user waits on — a shell command's output, an MCP call, and the running plan.
@@ -341,8 +345,12 @@ async function queryCodex(
     // Execute with streaming. Turns with image attachments send structured
     // input items so Codex reads the images from their local asset paths.
     const promptWithFiles = appendFilesInputTag(command, files);
-    const turnInput = normalizeImageDescriptors(images).length > 0
-      ? buildCodexInputItems(promptWithFiles, images, workingDirectory)
+    const normalizedImages = normalizeImageDescriptors(images);
+    const promptWithImageFallback = !promptWithFiles.trim() && normalizedImages.length > 0
+      ? CODEX_IMAGE_ONLY_PROMPT
+      : promptWithFiles;
+    const turnInput = normalizedImages.length > 0
+      ? buildCodexInputItems(promptWithImageFallback, normalizedImages, workingDirectory)
       : promptWithFiles;
     const streamedTurn = await thread.runStreamed(turnInput, {
       signal: abortController.signal
@@ -528,8 +536,8 @@ export const codexRuntime = {
  */
 function sendMessage(ws: ProviderRuntimeWriter, data: unknown) {
   try {
-    if (ws.isSSEStreamWriter || ws.isWebSocketWriter) {
-      // Writer handles stringification (SSEStreamWriter or WebSocketWriter)
+    if (ws.isWebSocketWriter) {
+      // The gateway writer handles stringification
       ws.send(data);
     } else if (typeof ws.send === 'function') {
       // Raw WebSocket - stringify here

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

@@ -220,6 +220,39 @@ function extractCodexTextContent(content: unknown): string {
     .join('\n');
 }
 
+/** Reads image inputs from a typed UserMessage item. */
+function extractCodexTypedUserImages(
+  content: unknown,
+): Array<{ path?: string; data?: string }> | undefined {
+  if (!Array.isArray(content)) {
+    return undefined;
+  }
+
+  const attachments: Array<{ path?: string; data?: string }> = [];
+  for (const rawEntry of content) {
+    const entry = readObjectRecord(rawEntry);
+    if (!entry) {
+      continue;
+    }
+
+    const value = entry.type === 'local_image'
+      ? readNonEmptyString(entry.path)
+      : entry.type === 'image'
+        ? readNonEmptyString(entry.image_url)
+        : undefined;
+    if (!value) {
+      continue;
+    }
+    if (value.startsWith('data:')) {
+      attachments.push({ data: value });
+    } else {
+      attachments.push(...toImageAttachments([value]));
+    }
+  }
+
+  return attachments.length > 0 ? attachments : undefined;
+}
+
 /**
  * Reads the markdown out of Codex's `<proposed_plan>` envelope.
  *
@@ -1312,6 +1345,36 @@ async function getCodexSessionMessages(sessionId: string): Promise<CodexHistoryR
         continue;
       }
 
+      // Paginated rollouts carry user prompts as `item_completed` /
+      // `UserMessage`; wire `response_item` user rows are internal, not prompts.
+      if (payload.type === 'item_completed') {
+        const item = readObjectRecord(payload.item);
+        if (item?.type === 'UserMessage') {
+          const content = extractCodexTextContent(item.content);
+          const images = extractCodexTypedUserImages(item.content);
+          if (content.trim() || images?.length) {
+            // Only the first prompt of a turn is anchored, matching the legacy
+            // `user_message` branch below: a turn can hold several prompts and
+            // the edit cut is per turn.
+            const turnId = readNonEmptyString(payload.turn_id)
+              ?? turns.getCurrentTurnId();
+            const isFirstPromptOfTurn = Boolean(turnId) && !anchoredTurnIds.has(turnId as string);
+            if (isFirstPromptOfTurn) {
+              anchoredTurnIds.add(turnId as string);
+            }
+            const row: AnyRecord = {
+              type: 'user',
+              timestamp,
+              message: { role: 'user', content },
+              ...(images ? { images } : {}),
+              ...(isFirstPromptOfTurn ? { turnId } : {}),
+            };
+            messages.push(row);
+          }
+        }
+        continue;
+      }
+
       if (isVisibleCodexUserMessage(payload)) {
         // Only the first prompt of a turn is anchored. A turn can hold more
         // than one — a follow-up queued while the turn was running is written

package/server/modules/providers/list/cursor/cursor-auth.provider.ts

@@ -10,6 +10,12 @@ type CursorLoginStatus = {
   error?: string;
 };
 
+// `cursor-agent status` decides "logged in" from the locally stored tokens, then fetches the
+// account details from Cursor's API. That request cannot change the verdict (on failure the CLI
+// still reports logged in), it only adds a network round trip to the CLI's startup (3-6 s on a
+// busy host even when logged out). A 5 s cap reported fresh logins as "Command timeout" (#551).
+const STATUS_TIMEOUT_MS = 20_000;
+
 export class CursorProviderAuth implements IProviderAuth {
   /**
    * Checks whether the cursor-agent CLI is available on this host.
@@ -71,7 +77,7 @@ export class CursorProviderAuth implements IProviderAuth {
             error: 'Command timeout',
           });
         }
-      }, 5000);
+      }, STATUS_TIMEOUT_MS);
 
       try {
         childProcess = spawn('cursor-agent', ['status']);
@@ -112,8 +118,10 @@ export class CursorProviderAuth implements IProviderAuth {
             return;
           }
 
+          // e.g. "Logged in (unable to fetch user details)" when the account request failed.
+          // There is no email to show, so the UI uses its own fallback label.
           if (stdout.includes('Logged in')) {
-            resolve({ authenticated: true, email: 'Logged in', method: 'cli' });
+            resolve({ authenticated: true, email: null, method: 'cli' });
             return;
           }
 

package/server/modules/providers/list/cursor/cursor-runtime.provider.js

@@ -6,7 +6,7 @@ import {
   normalizeAttachmentDescriptors
 } from '@/shared/image-attachments.js';
 import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
-import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell } from '@/shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell, stripAnsiSequences } from '@/shared/utils.js';
 
 // cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
 // child_process.spawn everywhere else.
@@ -277,7 +277,14 @@ async function spawnCursor(command, options = {}, ws, context) {
           return;
         }
 
-        ws.send(createNormalizedMessage({ kind: 'error', content: stderrText, sessionId: capturedSessionId || sessionId || null, provider: 'cursor' }));
+        // The CLI styles its stderr for a terminal; the chat renders plain
+        // text, so the escapes have to go before the text is surfaced.
+        const cleanedStderrText = stripAnsiSequences(stderrText);
+        if (!cleanedStderrText.trim()) {
+          return;
+        }
+
+        ws.send(createNormalizedMessage({ kind: 'error', content: cleanedStderrText, sessionId: capturedSessionId || sessionId || null, provider: 'cursor' }));
       });
 
       // Handle process completion

package/server/modules/providers/list/opencode/opencode-models.provider.ts

@@ -406,11 +406,26 @@ const parseOpenCodeSessionModelValue = (rawModel: unknown): string | null => {
     return null;
   }
 
-  return readOptionalString(record.id)
+  const modelId = readOptionalString(record.id)
     ?? readOptionalString(record.model)
     ?? readOptionalString(record.name)
-    ?? readOptionalString(record.value)
-    ?? null;
+    ?? readOptionalString(record.value);
+  if (!modelId) {
+    return null;
+  }
+
+  // OpenCode persists the provider and model id in separate fields (for
+  // example {"id":"z-ai/glm-5.3-flash","providerID":"openrouter"}), and its
+  // CLI's `--model` flag only accepts the composed `<providerID>/<modelID>`
+  // form. Compose it here so a resumed session resolves the same model
+  // instead of failing with an unknown-model error.
+  const providerId = readOptionalString(record.providerID)
+    ?? readOptionalString(record.providerId);
+  if (providerId && !modelId.startsWith(`${providerId}/`)) {
+    return `${providerId}/${modelId}`;
+  }
+
+  return modelId;
 };
 
 /** Provider registry model adapter for OpenCode predefined models and session metadata. */

package/server/modules/providers/list/opencode/opencode-runtime.provider.js

@@ -9,7 +9,7 @@ import {
   normalizeAttachmentDescriptors
 } from '@/shared/image-attachments.js';
 import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
-import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell, getOpenCodeDatabasePath } from '@/shared/utils.js';
+import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell, getOpenCodeDatabasePath, stripAnsiSequences } from '@/shared/utils.js';
 
 // cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
 // child_process.spawn everywhere else.
@@ -308,7 +308,10 @@ async function spawnOpenCode(command, options = {}, ws, context) {
       });
 
       opencodeProcess.stderr.on('data', (data) => {
-        const stderrText = data.toString();
+        // opencode styles its stderr for a terminal; the chat renders plain
+        // text, so the escapes have to go before the text is surfaced. A chunk
+        // that was styling only cleans down to nothing and is not an error.
+        const stderrText = stripAnsiSequences(data.toString());
         if (!stderrText.trim()) {
           return;
         }

package/server/modules/providers/list/opencode/opencode-session-synchronizer.provider.ts

@@ -28,17 +28,23 @@ type SynchronizeRowsResult = {
   firstSessionId: string | null;
 };
 
+type OpenCodeChildSessionRow = {
+  id: string;
+};
+
 /**
  * Session indexer for OpenCode's SQLite-backed session store.
  */
 export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer {
   private readonly provider = 'opencode' as const;
+  private childSessionsReconciled = false;
 
   /**
    * Scans OpenCode's shared opencode.db and upserts active sessions into DB.
    */
   async synchronize(since?: Date): Promise<number> {
-    const result = this.synchronizeRows(since);
+    // The first provider-wide scan also reconciles child rows indexed by older versions.
+    const result = this.synchronizeRows(since, undefined, !this.childSessionsReconciled);
     return result.processed;
   }
 
@@ -54,7 +60,11 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
     return result.firstSessionId;
   }
 
-  private synchronizeRows(since?: Date, limit?: number): SynchronizeRowsResult {
+  private synchronizeRows(
+    since?: Date,
+    limit?: number,
+    pruneChildSessions = false,
+  ): SynchronizeRowsResult {
     const dbPath = getOpenCodeDatabasePath();
     if (!fsSync.existsSync(dbPath)) {
       return { processed: 0, firstSessionId: null };
@@ -62,6 +72,11 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
 
     const db = new Database(dbPath, { readonly: true, fileMustExist: true });
     try {
+      if (pruneChildSessions) {
+        this.pruneChildSessions(db);
+        this.childSessionsReconciled = true;
+      }
+
       const sinceMillis = since?.getTime() ?? null;
       const limitClause = limit ? 'LIMIT ?' : '';
       const params = limit ? [sinceMillis, sinceMillis, limit] : [sinceMillis, sinceMillis];
@@ -76,6 +91,7 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
         FROM session s
         LEFT JOIN project p ON p.id = s.project_id
         WHERE s.time_archived IS NULL
+          AND s.parent_id IS NULL
           AND (? IS NULL OR COALESCE(s.time_updated, s.time_created, 0) >= ?)
         ORDER BY COALESCE(s.time_updated, s.time_created, 0) DESC, s.id DESC
         ${limitClause}
@@ -105,6 +121,18 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
     }
   }
 
+  private pruneChildSessions(db: Database.Database): void {
+    const childSessions = db.prepare(`
+      SELECT id
+      FROM session
+      WHERE parent_id IS NOT NULL
+    `).all() as OpenCodeChildSessionRow[];
+
+    for (const childSession of childSessions) {
+      sessionsDb.deleteSessionByProviderSessionId(childSession.id, this.provider);
+    }
+  }
+
   private upsertSession(db: Database.Database, row: OpenCodeSessionRow): string | null {
     const sessionId = readOptionalString(row.id);
     const projectPath = readOptionalString(row.directory) ?? readOptionalString(row.worktree);

package/server/modules/providers/provider.routes.ts

@@ -1,6 +1,7 @@
 import express, { type Request, type Response } from 'express';
 
 import { providerAuthService } from '@/modules/providers/services/provider-auth.service.js';
+import { claudeSettingsPermissionsService } from '@/modules/providers/services/claude-settings-permissions.service.js';
 import { providerCapabilitiesService } from '@/modules/providers/services/provider-capabilities.service.js';
 import { providerMcpService } from '@/modules/providers/services/mcp.service.js';
 import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
@@ -9,6 +10,7 @@ import { providerSkillsService } from '@/modules/providers/services/skills.servi
 import { sessionConversationsSearchService } from '@/modules/providers/services/session-conversations-search.service.js';
 import { sessionsService } from '@/modules/providers/services/sessions.service.js';
 import type {
+  CustomProviderModelEffort,
   CustomProviderModelInput,
   LLMProvider,
   McpScope,
@@ -53,6 +55,35 @@ const parseSessionId = (value: unknown): string => {
   return sessionId;
 };
 
+/** A workflow run id as the harness mints one (`wf_16fbf852-274`). */
+const WORKFLOW_RUN_ID_PATTERN = /^wf_[A-Za-z0-9-]+$/;
+/** A workflow agent id as the CLI mints one: `a` and sixteen hex digits. */
+const WORKFLOW_AGENT_ID_PATTERN = /^a[0-9a-f]{16}$/;
+
+// Both ids name a file under the session's transcript directory, so nothing
+// outside these shapes may reach the filesystem.
+const parseWorkflowRunId = (value: unknown): string => {
+  const runId = readPathParam(value, 'runId');
+  if (!WORKFLOW_RUN_ID_PATTERN.test(runId)) {
+    throw new AppError('Invalid workflow run id.', {
+      code: 'INVALID_WORKFLOW_RUN_ID',
+      statusCode: 400,
+    });
+  }
+  return runId;
+};
+
+const parseWorkflowAgentId = (value: unknown): string => {
+  const agentId = readPathParam(value, 'agentId');
+  if (!WORKFLOW_AGENT_ID_PATTERN.test(agentId)) {
+    throw new AppError('Invalid workflow agent id.', {
+      code: 'INVALID_WORKFLOW_AGENT_ID',
+      statusCode: 400,
+    });
+  }
+  return agentId;
+};
+
 const readOptionalQueryString = (value: unknown): string | undefined => {
   if (typeof value !== 'string') {
     return undefined;
@@ -465,6 +496,78 @@ const parseModelRecordId = (value: unknown): number => {
   return recordId;
 };
 
+const invalidModelEffort = (message: string): AppError => new AppError(message, {
+  code: 'INVALID_MODEL_EFFORT',
+  statusCode: 400,
+});
+
+/**
+ * Upper bound on declared effort levels, far above any provider's level set.
+ * Checked before the per-entry loop so an oversized body (the JSON parser
+ * accepts up to 50 MB) is rejected at once instead of being walked in full.
+ */
+const MAX_MODEL_EFFORT_LEVELS = 32;
+
+/**
+ * Parses the optional `effort` field of a custom-model payload.
+ *
+ * Only the shape is checked here (unique, trimmed, non-empty level ids and a
+ * default drawn from them); which levels a provider accepts is decided by the
+ * Providers service. `undefined` means "not sent" and `null` or an empty
+ * `values` list means "no effort levels".
+ */
+const parseCustomProviderModelEffort = (
+  value: unknown,
+): CustomProviderModelEffort | null | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw invalidModelEffort('effort must be an object with a values array.');
+  }
+
+  const effort = value as Record<string, unknown>;
+  if (!Array.isArray(effort.values)) {
+    throw invalidModelEffort('effort.values must be an array of effort levels.');
+  }
+  if (effort.values.length > MAX_MODEL_EFFORT_LEVELS) {
+    throw invalidModelEffort(`effort.values can list at most ${MAX_MODEL_EFFORT_LEVELS} effort levels.`);
+  }
+
+  const values: string[] = [];
+  const seenLevels = new Set<string>();
+  for (const entry of effort.values) {
+    const level = typeof entry === 'string' ? entry.trim() : '';
+    if (!level || level.length > 40) {
+      throw invalidModelEffort('effort.values must contain non-empty strings of 40 characters or fewer.');
+    }
+    if (seenLevels.has(level)) {
+      throw invalidModelEffort(`effort.values contains "${level}" more than once.`);
+    }
+    seenLevels.add(level);
+    values.push(level);
+  }
+
+  if (effort.default !== undefined && effort.default !== null && typeof effort.default !== 'string') {
+    throw invalidModelEffort('effort.default must be a string.');
+  }
+  const defaultLevel = readOptionalQueryString(effort.default);
+  if (values.length === 0) {
+    if (defaultLevel) {
+      throw invalidModelEffort('effort.default requires at least one effort level.');
+    }
+    return null;
+  }
+  if (defaultLevel && !values.includes(defaultLevel)) {
+    throw invalidModelEffort('effort.default must be one of effort.values.');
+  }
+
+  return defaultLevel ? { values, default: defaultLevel } : { values };
+};
+
 const parseCustomProviderModelPayload = (payload: unknown): CustomProviderModelInput => {
   if (!payload || typeof payload !== 'object') {
     throw new AppError('Request body must be an object.', {
@@ -501,7 +604,8 @@ const parseCustomProviderModelPayload = (payload: unknown): CustomProviderModelI
     });
   }
 
-  return { model, id };
+  const effort = parseCustomProviderModelEffort(body.effort);
+  return effort === undefined ? { model, id } : { model, id, effort };
 };
 
 router.get(
@@ -717,6 +821,15 @@ router.get(
   }),
 );
 
+// Read-only: the rules Claude's own settings files add on top of the UI's lists.
+router.get(
+  '/claude/settings-permissions',
+  asyncHandler(async (_req: Request, res: Response) => {
+    const sources = await claudeSettingsPermissionsService.listRuleSources();
+    res.json(createApiSuccessResponse({ sources }));
+  }),
+);
+
 // ----------------- Session routes -----------------
 /**
  * Session gateway entry point: allocates the stable app-facing session id for
@@ -739,7 +852,7 @@ router.post(
 router.get(
   '/sessions/running',
   asyncHandler(async (_req: Request, res: Response) => {
-    const sessions = sessionsService.listRunningSessions();
+    const sessions = await sessionsService.listRunningSessions();
     res.json(createApiSuccessResponse({ sessions }));
   }),
 );
@@ -848,6 +961,22 @@ router.get(
   }),
 );
 
+/**
+ * One workflow agent's timeline, read on demand when its row in the workflow
+ * card is opened. History does not carry it: a run can spawn a dozen agents
+ * with hundreds of tool calls each, and the card only lists them.
+ */
+router.get(
+  '/sessions/:sessionId/workflows/:runId/agents/:agentId',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const runId = parseWorkflowRunId(req.params.runId);
+    const agentId = parseWorkflowAgentId(req.params.agentId);
+    const result = await sessionsService.readWorkflowAgentActivity(sessionId, runId, agentId);
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
 router.get('/search/sessions', asyncHandler(async (req: Request, res: Response) => {
   const query = parseSessionSearchQuery(req.query.q);
   const limit = parseSessionSearchLimit(req.query.limit);

package/server/modules/providers/services/claude-cli-liveness.service.ts

@@ -0,0 +1,121 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * One Claude CLI process that is currently producing a response.
+ *
+ * `providerSessionId` is Claude's own session id, which is what the registry
+ * records; callers map it onto an app session themselves.
+ */
+type LiveClaudeCliSession = {
+  providerSessionId: string;
+  startedAt: number;
+};
+
+/**
+ * Claude Code keeps one file per running session here, named `<pid>.json`.
+ * The directory belongs to the CLI, not to CloudCLI: it is only ever read.
+ */
+const registryDirectory = () => path.join(os.homedir(), '.claude', 'sessions');
+
+/**
+ * Upper bound on registry files inspected per poll.
+ *
+ * The running-sessions endpoint is polled continuously, so a directory left
+ * full of stale files by repeated crashes must not turn every poll into
+ * unbounded filesystem work. Real installations hold a handful of entries.
+ */
+const MAX_REGISTRY_FILES = 256;
+
+/**
+ * Whether `pid` is still the process the registry recorded.
+ *
+ * A registry file outlives a crash, so its mere presence proves nothing. The
+ * signal-0 probe answers "does this pid exist" (EPERM means it exists but is
+ * owned by someone else, which still counts), and on Linux the recorded
+ * `procStart` is compared against the kernel's start-time for that pid so a
+ * reused pid cannot be mistaken for the original process.
+ */
+async function isRecordedProcessAlive(pid: number, procStart: unknown): Promise<boolean> {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code !== 'EPERM') {
+      return false;
+    }
+  }
+
+  if (process.platform !== 'linux' || typeof procStart !== 'string' || !procStart) {
+    return true;
+  }
+
+  try {
+    const stat = await fsp.readFile(`/proc/${pid}/stat`, 'utf8');
+    // The comm field is parenthesised and may itself contain spaces, so the
+    // fields are counted from the last ')'. starttime is the 22nd field
+    // overall, i.e. the 20th of what follows the comm field.
+    const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+    return fields[19] === procStart;
+  } catch {
+    // No procfs entry means the process is gone between the two checks.
+    return false;
+  }
+}
+
+/** Reads one registry file, returning null for anything that is not a live busy session. */
+async function readLiveBusySession(filePath: string): Promise<LiveClaudeCliSession | null> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await fsp.readFile(filePath, 'utf8'));
+  } catch {
+    // Unreadable, half-written or malformed entries are simply not evidence
+    // of a running session.
+    return null;
+  }
+
+  const record = parsed as Record<string, unknown> | null;
+  if (!record || typeof record !== 'object') {
+    return null;
+  }
+
+  const providerSessionId = typeof record.sessionId === 'string' ? record.sessionId : '';
+  const pid = typeof record.pid === 'number' ? record.pid : NaN;
+  if (!providerSessionId || !Number.isInteger(pid) || pid <= 0 || record.status !== 'busy') {
+    return null;
+  }
+
+  if (!(await isRecordedProcessAlive(pid, record.procStart))) {
+    return null;
+  }
+
+  const startedAt = typeof record.startedAt === 'number' ? record.startedAt : Date.now();
+  return { providerSessionId, startedAt };
+}
+
+/**
+ * Lists the Claude CLI sessions that are mid-turn right now.
+ *
+ * Used by the providers module's sessions service so the running-sessions poll
+ * also reports turns driven outside CloudCLI's own chat runs — including the
+ * `claude` processes CloudCLI itself spawns for the Shell view, which live in
+ * the PTY map rather than the chat-run registry. Liveness is ephemeral, so it
+ * is recomputed on every read instead of being cached or persisted.
+ */
+export async function listBusyClaudeCliSessions(): Promise<LiveClaudeCliSession[]> {
+  let entries: string[];
+  try {
+    entries = await fsp.readdir(registryDirectory());
+  } catch {
+    // No registry directory at all is the normal case for an install that has
+    // never run the CLI, and an unreadable one is not worth failing a poll for.
+    return [];
+  }
+
+  const registryFiles = entries.filter((entry) => entry.endsWith('.json')).slice(0, MAX_REGISTRY_FILES);
+  const sessions = await Promise.all(
+    registryFiles.map((entry) => readLiveBusySession(path.join(registryDirectory(), entry))),
+  );
+
+  return sessions.filter((session): session is LiveClaudeCliSession => session !== null);
+}