@oar-sh/oar 0.9.6 → 0.9.7

package/server/repositories/remote-relay-repository.mjs

@@ -1,6 +1,6 @@
 'use strict';
 
-import { normalizeRemoteRelayOrigin } from '../../shared/remote-relay-contract.mjs';
+import { REMOTE_RELAY_LOCAL_ID, normalizeRemoteRelayOrigin } from '../../shared/remote-relay-contract.mjs';
 
 // Storage for remote relays that is not app settings: which remote relays a
 // conversation has unlocked (the user mentioned them), and the provenance of
@@ -10,6 +10,11 @@ import { normalizeRemoteRelayOrigin } from '../../shared/remote-relay-contract.m
 // A relay whose agent wrote to a conversation is open to that conversation as
 // well. That is read from the provenance, not stored as an unlock, so what the
 // user allowed and what another agent started stay apart.
+//
+// Agent sessions on this relay itself reuse both: the user's "Allow" for a
+// conversation's agent to start sessions here is an unlock under the local
+// target's id, and a conversation such an agent created carries an origin
+// with `local: true` that names the conversation it was created from.
 
 function parseOrigin(json) {
   if (!json) return null;
@@ -34,6 +39,18 @@ export function createRemoteRelayRepository(db) {
     SELECT DISTINCT origin_json FROM messages
     WHERE conversation_id = ? AND role = 'user' AND origin_json IS NOT NULL
   `);
+  // Conversations an agent of this relay created that have a turn queued or
+  // running. The origin is filtered in SQL only roughly (it is JSON text); the
+  // caller matches the creating conversation on the parsed value.
+  const listActiveLocalOrigins = db.prepare(`
+    SELECT c.id, c.origin_json FROM conversations c
+    WHERE c.origin_json LIKE '%"local":true%'
+      AND COALESCE(c.status, '') <> 'deleted'
+      AND EXISTS (
+        SELECT 1 FROM queue q
+        WHERE q.conversation_id = c.id AND q.status IN ('pending', 'processing', 'parked')
+      )
+  `);
   const getLatestHumanMessage = db.prepare(`
     SELECT id FROM messages
     WHERE conversation_id = ? AND role = 'user' AND origin_json IS NULL
@@ -59,6 +76,30 @@ export function createRemoteRelayRepository(db) {
       if (!conversation || !relay) return false;
       return insertUnlock.run(conversation, relay, messageId ? String(messageId) : null, nowIso).changes > 0;
     },
+    /** Did the user allow this conversation's agent to start sessions on this relay? */
+    hasLocalSessionApproval(conversationId) {
+      return !!hasUnlock.get(String(conversationId || ''), REMOTE_RELAY_LOCAL_ID);
+    },
+    /** Remembers that "Allow"; `messageId` is the turn it was given on. */
+    recordLocalSessionApproval(conversationId, messageId = null, nowIso = new Date().toISOString()) {
+      const conversation = String(conversationId || '').trim();
+      if (!conversation) return false;
+      return insertUnlock.run(conversation, REMOTE_RELAY_LOCAL_ID, messageId ? String(messageId) : null, nowIso).changes > 0;
+    },
+    /**
+     * The ids of the conversations this conversation's agent created on this
+     * relay that have a turn queued or running (pending, processing, parked).
+     */
+    listActiveLocalSessions(conversationId) {
+      const creator = String(conversationId || '').trim();
+      if (!creator) return [];
+      return listActiveLocalOrigins.all()
+        .filter((row) => {
+          const origin = parseOrigin(row.origin_json);
+          return origin?.local === true && origin.conversationId === creator;
+        })
+        .map((row) => String(row.id));
+    },
     forgetRelay(remoteRelayId) {
       return deleteUnlocksForRelay.run(String(remoteRelayId || '')).changes;
     },

package/server/repositories/session-repository.mjs

@@ -14,6 +14,16 @@ export function createSessionRepository(db) {
     const conversationsHaveOrigin = db.prepare(`PRAGMA table_info(conversations)`).all()
       .some((column) => String(column?.name || '').trim() === 'origin_json');
     const conversationOriginSelect = conversationsHaveOrigin ? 'c.origin_json' : 'NULL AS origin_json';
+    // Claude Cloud conversations (migration 0007): what the cloud session
+    // clones, and what it has cost. NULL on a schema that predates it.
+    const conversationsHaveCloudSource = db.prepare(`PRAGMA table_info(conversations)`).all()
+      .some((column) => String(column?.name || '').trim() === 'cloud_source_json');
+    const conversationCloudSelect = [
+      conversationsHaveCloudSource ? 'c.cloud_source_json' : 'NULL AS cloud_source_json',
+      runtimeSessionColumns.has('claude_cloud_cost_usd')
+        ? 'rs.claude_cloud_cost_usd AS runtime_claude_cloud_cost_usd'
+        : 'NULL AS runtime_claude_cloud_cost_usd',
+    ].join(', ');
     return {
         // conversations
         getConv:        db.prepare(`SELECT * FROM conversations WHERE id = ? AND status != 'deleted'`),
@@ -21,13 +31,22 @@ export function createSessionRepository(db) {
         getConvBySdkSessionId: db.prepare(`SELECT * FROM conversations WHERE sdk_session_id = ? AND status != 'deleted' ORDER BY updated_at DESC LIMIT 1`),
         listConvIdsMissingRuntimeSession: db.prepare(`SELECT c.id AS id FROM conversations c LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE rs.id IS NULL AND c.status != 'deleted'`),
         runtimeSessionsSupportProviders,
-        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = 0) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
+        listConvs:      db.prepare(`SELECT c.id, c.title, c.title_source, c.archived, c.compacted_into, c.compacted_from, c.sdk_session_id, c.preferred_relay_mode, c.preferred_model, c.preferred_reasoning_effort, c.configured_workspace_root_path, c.runtime_workspace_root_path, c.draft_text, c.draft_updated_at, c.draft_updated_by_client_id, c.draft_attachments, ${conversationOriginSelect}, ${conversationCloudSelect}, c.created_at, c.updated_at, rs.id AS runtime_session_id, rs.strategy AS runtime_strategy, rs.status AS runtime_status, rs.last_used_at AS runtime_last_used_at, ${runtimeProviderSelect}, COUNT(m.id) as message_count FROM conversations c LEFT JOIN messages m ON m.conversation_id = c.id LEFT JOIN runtime_sessions rs ON rs.conversation_id = c.id WHERE c.status != 'deleted' AND (? = 1 OR c.archived = ?) GROUP BY c.id ORDER BY CASE WHEN c.sdk_session_id IS NULL OR c.sdk_session_id = '' THEN 1 ELSE 0 END ASC, c.updated_at DESC`),
         insertConv:     db.prepare(`INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`),
         updateConvTime: db.prepare(`UPDATE conversations SET updated_at = ? WHERE id = ?`),
         updateConvTitle: db.prepare(`UPDATE conversations SET title = ?, title_source = 'manual' WHERE id = ?`),
         updateConvPreferences: db.prepare(`UPDATE conversations SET preferred_relay_mode = ?, preferred_model = ?, preferred_reasoning_effort = ?, updated_at = ? WHERE id = ?`),
         updateConvConfiguredWorkspaceRoot: db.prepare(`UPDATE conversations SET configured_workspace_root_path = ?, updated_at = ? WHERE id = ?`),
         updateConvRuntimeWorkspaceRoot: db.prepare(`UPDATE conversations SET runtime_workspace_root_path = ?, updated_at = ? WHERE id = ?`),
+        // Claude Cloud: the repository, branch and environment of the cloud session.
+        updateConvCloudSource: conversationsHaveCloudSource
+          ? db.prepare(`UPDATE conversations SET cloud_source_json = ? WHERE id = ?`)
+          : null,
+        // The repositories of earlier cloud chats, newest first: the suggestions
+        // of the New Chat repository picker.
+        listRecentCloudSources: conversationsHaveCloudSource
+          ? db.prepare(`SELECT cloud_source_json, updated_at FROM conversations WHERE cloud_source_json IS NOT NULL AND status != 'deleted' ORDER BY updated_at DESC LIMIT 200`)
+          : null,
         seedConvConfiguredWorkspaceRootIfMissing: db.prepare(`UPDATE conversations SET configured_workspace_root_path = ?, updated_at = ? WHERE id = ? AND (configured_workspace_root_path IS NULL OR configured_workspace_root_path = '')`),
         updateConvSeed: db.prepare(`UPDATE conversations SET summary_seed = ?, seed_pending = ?, compacted_from = ?, updated_at = ? WHERE id = ?`),
         markConvCompacted: db.prepare(`UPDATE conversations SET archived = 1, compacted_into = ?, updated_at = ? WHERE id = ?`),
@@ -36,6 +55,7 @@ export function createSessionRepository(db) {
         updateConvDraft: db.prepare(`UPDATE conversations SET draft_text = ?, draft_updated_at = ?, draft_updated_by_client_id = ? WHERE id = ?`),
         updateConvDraftAttachments: db.prepare(`UPDATE conversations SET draft_attachments = ?, draft_updated_at = ?, draft_updated_by_client_id = ? WHERE id = ?`),
         archiveConv:    db.prepare(`UPDATE conversations SET archived = 1, updated_at = ? WHERE id = ?`),
+        unarchiveConv:  db.prepare(`UPDATE conversations SET archived = 0, updated_at = ? WHERE id = ?`),
         deleteConv:     db.prepare(`DELETE FROM conversations WHERE id = ?`),
 
         // Queue and message statements live in message-repository.mjs — the
@@ -97,6 +117,19 @@ export function createSessionRepository(db) {
               WHERE conversation_id = ?
             `)
           : null,
+        // What a Claude Cloud worker reports: the cloud session id, the last
+        // handled event sequence and the cost so far. The caller merges a
+        // report with what is stored (claude-cloud-session-service.mjs).
+        updateRuntimeSessionClaudeCloudSession: runtimeSessionColumns.has('claude_cloud_session_id')
+          ? db.prepare(`
+              UPDATE runtime_sessions
+              SET claude_cloud_session_id = ?,
+                  claude_cloud_last_sequence = ?,
+                  claude_cloud_cost_usd = ?,
+                  last_used_at = ?
+              WHERE conversation_id = ?
+            `)
+          : null,
         updateRuntimeSessionContextUsage: runtimeSessionColumns.has('context_usage_json')
           ? db.prepare(`
               UPDATE runtime_sessions
@@ -146,6 +179,19 @@ export function createSessionRepository(db) {
         `),
         deleteRecentWorkspaceRoots: db.prepare(`DELETE FROM recent_workspace_roots`),
 
+        // per-folder settings (migration 0006): the commit attribution
+        // override of a repo folder; keyed like the recent roots
+        getWorkspaceRootSettings: db.prepare(`SELECT * FROM workspace_root_settings WHERE path_key = ?`),
+        upsertWorkspaceRootAttribution: db.prepare(`
+          INSERT INTO workspace_root_settings (path_key, path, attribution_mode, updated_at)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(path_key) DO UPDATE SET
+            path = excluded.path,
+            attribution_mode = excluded.attribution_mode,
+            updated_at = excluded.updated_at
+        `),
+        deleteWorkspaceRootSettings: db.prepare(`DELETE FROM workspace_root_settings WHERE path_key = ?`),
+
         // app settings
         getAppSetting: db.prepare(`
           SELECT key, value, updated_at

package/server/routes/claude-cloud-routes.mjs

@@ -0,0 +1,140 @@
+'use strict';
+
+// Routes of the Claude Cloud provider (`claude-cloud`):
+//
+//   GET  /api/settings/claude-cloud   the provider tab: switch, default model,
+//                                     environment, account, login state
+//   POST /api/settings/claude-cloud   { enabled?, defaultModel?, environmentId? }
+//   POST /api/claude-cloud-session    the worker's binding report
+//   GET  /api/claude-cloud/repos      the repositories New Chat may suggest
+//                                     (`?refresh=1` reads them afresh)
+//   GET  /api/claude-cloud/branches   `?repo=<owner/name or URL>` → its branches
+//   POST /api/claude-cloud/login-nudge  make the Claude CLI refresh its login
+//                                     (a cloud worker asks before giving up
+//                                     on an expired token); answers what the
+//                                     credentials reader says, never the token
+//
+// The Claude login never passes through here: the settings body carries where
+// it comes from and when it runs out, not the token.
+
+/** Whether a query flag such as `?refresh=1` is set. */
+function queryFlag(value) {
+  const text = Array.isArray(value) ? value[0] : value;
+  return ['1', 'true', 'yes'].includes(String(text ?? '').trim().toLowerCase());
+}
+
+export function registerClaudeCloudRoutes(app, deps = {}) {
+  const {
+    auth,
+    touchCli = () => {},
+    claudeCloudSettingsService = null,
+    claudeCloudSessionService = null,
+    claudeCloudRepoService = null,
+    // `{ describe() }` of the credentials reader and nothing more: no route
+    // can reach the login itself.
+    claudeCloudLoginStatus = null,
+    claudeAuthService = null,
+  } = deps;
+
+  if (claudeCloudSettingsService) {
+    app.get('/api/settings/claude-cloud', auth, async (_req, res) => {
+      try {
+        return res.json(await claudeCloudSettingsService.describe());
+      } catch (error) {
+        console.warn(`[claude-cloud] settings read failed: ${error?.code || 'error'}`);
+        return res.status(500).json({ error: 'Failed to read Claude Cloud settings' });
+      }
+    });
+
+    app.post('/api/settings/claude-cloud', auth, async (req, res) => {
+      let result;
+      try {
+        result = await claudeCloudSettingsService.update(req.body);
+      } catch (error) {
+        console.warn(`[claude-cloud] settings update failed: ${error?.code || 'error'}`);
+        return res.status(500).json({ error: 'Failed to update Claude Cloud settings' });
+      }
+      if (!result?.ok) {
+        return res.status(result?.statusCode || 400).json({
+          error: result?.error || 'Failed to update Claude Cloud settings',
+          ...(result?.code ? { code: result.code } : {}),
+        });
+      }
+      return res.json({ ok: true, ...result.settings });
+    });
+  }
+
+  if (claudeCloudSessionService) {
+    // POST /api/claude-cloud-session — the Claude Cloud worker reports the
+    // cloud session it created for a conversation and keeps the binding
+    // current: `{ conversationId, cloudSessionId, sessionUrl, lastSequence,
+    // pushedBranch?, costUsd?, model? }` after the session was created, after
+    // every result, and on a push. The stored sequence is where a restarted
+    // worker resumes the event stream.
+    app.post('/api/claude-cloud-session', auth, (req, res) => {
+      touchCli();
+      const result = claudeCloudSessionService.recordWorkerReport(req.body);
+      if (!result.ok) return res.status(result.statusCode || 400).json({ error: result.error });
+      return res.json({ ok: true, cloud: result.cloud });
+    });
+  }
+
+  if (claudeCloudLoginStatus) {
+    // The workers read the CLI's login file themselves and cannot run the
+    // CLI; the relay can, through the same probe the settings tab uses
+    // (`claude auth status`, which refreshes a login whose refresh token is
+    // still good). Serialised by the auth service; a failed probe is no
+    // error here: the file decides, and the answer says what it holds.
+    app.post('/api/claude-cloud/login-nudge', auth, async (_req, res) => {
+      let nudged = false;
+      try {
+        if (typeof claudeAuthService?.getStatus === 'function') {
+          await claudeAuthService.getStatus({ force: true });
+          nudged = true;
+        }
+      } catch (error) {
+        console.warn(`[claude-cloud] login nudge failed: ${error?.code || error?.message || 'error'}`);
+      }
+      let login = null;
+      try {
+        login = typeof claudeCloudLoginStatus.describe === 'function' ? claudeCloudLoginStatus.describe() : null;
+      } catch {
+        login = null;
+      }
+      return res.json({
+        ok: true,
+        nudged,
+        hasToken: login?.hasToken === true,
+        expiresAt: login?.expiresAt || null,
+        expired: login?.expired === true,
+      });
+    });
+  }
+
+  if (claudeCloudRepoService) {
+    // Every answer the service gives is 200, also an `ok: false` one: the
+    // browser shows the recent repositories with the error text beside them.
+    app.get('/api/claude-cloud/repos', auth, async (req, res) => {
+      try {
+        return res.json(await claudeCloudRepoService.listRepositories({ force: queryFlag(req.query?.refresh) }));
+      } catch (error) {
+        console.warn(`[claude-cloud] repository list failed: ${error?.code || 'error'}`);
+        return res.status(500).json({ error: 'Failed to list Claude Cloud repositories' });
+      }
+    });
+
+    app.get('/api/claude-cloud/branches', auth, async (req, res) => {
+      const repo = Array.isArray(req.query?.repo) ? req.query.repo[0] : req.query?.repo;
+      let result;
+      try {
+        result = await claudeCloudRepoService.listBranches(typeof repo === 'string' ? repo : '');
+      } catch (error) {
+        console.warn(`[claude-cloud] branch list failed: ${error?.code || 'error'}`);
+        return res.status(500).json({ error: 'Failed to list the repository branches' });
+      }
+      // A repository the service cannot even name is the caller's mistake.
+      if (!result?.ok && result?.error?.code === 'invalid_repo') return res.status(400).json(result);
+      return res.json(result);
+    });
+  }
+}

package/server/routes/git-routes.mjs

@@ -4,6 +4,8 @@
 // resolved server-side from the conversation scope (mirroring the file
 // preview routes) — the client never sends absolute paths.
 
+import { validateRequestedWorkspaceRoot } from '../services/workspace-root-path-policy.mjs';
+
 export function resolveGitScopedRootPath(req, {
   resolveConversationWorkspaceState,
   currentWorkspaceRootPath,
@@ -40,8 +42,43 @@ export function registerGitRoutes(app, deps) {
     currentWorkspaceRootPath,
     normalizeWorkspaceRelativePath,
     resolveWorkspaceFilePath,
+    gitRemoteService = null,
+    workspaceRootAllowList = [],
+    validateWorkspaceRoot = validateRequestedWorkspaceRoot,
   } = deps;
 
+  // GET /api/git/remote?root=<abs path> — where a folder lives on GitHub, for
+  // the New Chat modal (the repository and branch of a Claude Cloud chat).
+  // There is no conversation yet, so this is the one git route that takes a
+  // path from the client: it passes the same policy as a requested CWD (an
+  // existing directory, absolute, inside the workspace allow list).
+  if (gitRemoteService) {
+    app.get('/api/git/remote', auth, async (req, res) => {
+      res.setHeader?.('Cache-Control', 'no-store');
+      const validated = validateWorkspaceRoot(req.query?.root, { allowList: workspaceRootAllowList });
+      if (!validated.ok) {
+        return res.status(validated.code === 'root-path-not-allowed' ? 403 : 400)
+          .json({ ok: false, code: validated.code, error: validated.error });
+      }
+      const root = validated.realPath;
+      const payload = await gitRemoteService.describe(root);
+      if (!payload.ok) return res.status(500).json({ ok: false, error: payload.error || 'Failed to read the git remote' });
+      return res.json({
+        ok: true,
+        root,
+        hasGit: payload.hasGit,
+        remoteUrl: payload.remoteUrl,
+        repoUrl: payload.repoUrl,
+        slug: payload.slug,
+        branch: payload.branch,
+        upstream: payload.upstream,
+        ahead: payload.ahead,
+        behind: payload.behind,
+        dirty: payload.dirty,
+      });
+    });
+  }
+
   if (!gitChangesService) return;
 
   function requireRootPath(req, res) {

package/server/routes/messages-routes.mjs

@@ -43,6 +43,8 @@ import { ANSWERED_ELSEWHERE_KIND, STEER_FOLDED_TEXT } from '../../shared/steer-s
 import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
 import { stripRemotePromptHeader } from '../../shared/remote-relay-contract.mjs';
+import { stripModelTierSuffix } from '../../shared/claude-cloud/repo-url.mjs';
+import { buildClaudeCloudDelivery, isClaudeCloudProviderType } from '../services/claude-cloud-session-service.mjs';
 import {
   admitRemoteRelayRequest,
   findMentionedRemoteRelays,
@@ -114,6 +116,8 @@ function normalizeRequestedProviderType(value = '') {
   // "no provider stated" and the guards below could never fire.
   if (normalized === 'grok' || normalized === 'xai' || normalized === 'xai-grok') return 'grok';
   if (normalized === 'claude' || normalized === 'anthropic') return 'claude';
+  // Its own provider, never read as `claude`.
+  if (normalized === 'claude-cloud') return 'claude-cloud';
   return '';
 }
 
@@ -121,6 +125,7 @@ const BOOTSTRAP_ONLY_PROVIDER_LABELS = Object.freeze({
   cursor: 'Cursor',
   grok: 'Grok',
   claude: 'Claude',
+  'claude-cloud': 'Claude Cloud',
 });
 
 function deriveModelOrigin(model) {
@@ -589,9 +594,17 @@ async function resolveRelayResponseText({
   }
 }
 
-export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null } = {}) {
+/**
+ * `inferFromText`: whether a text shaped like a failure note counts as one
+ * when no record came with it. A session worker always sends the record
+ * (`terminalError`), so for its publishes (an `attemptId` names the attempt)
+ * the text is a reply whatever it says — a reply that names a code after
+ * fixing a failed test is a reply. Senders without an attempt (the Copilot
+ * extension, a note read from another relay) still report as text.
+ */
+export function resolveTerminalFailurePayload(payload = {}, { fallbackText = null, inferFromText = true } = {}) {
   const body = payload && typeof payload === 'object' ? payload : {};
-  const parsedTextFailure = parseTerminalFailureText(body.text);
+  const parsedTextFailure = inferFromText ? parseTerminalFailureText(body.text) : null;
   const direct = body.terminalError && typeof body.terminalError === 'object'
     ? body.terminalError
     : null;
@@ -1121,6 +1134,7 @@ export function buildDequeuedRelayMessage({
   defaultRelayMode,
   defaultModel,
   getCursorProviderSettings = () => null,
+  getClaudeCloudProviderSettings = () => null,
 } = {}) {
   if (!msg) return null;
   const attachments = parseAttachments(msg.attachments).map(hydrateAttachment).filter(Boolean);
@@ -1150,6 +1164,17 @@ export function buildDequeuedRelayMessage({
       .map((value) => String(value || '').trim())
       .filter(Boolean);
   }
+  // A Claude Cloud worker creates its session from the first delivered
+  // message and sends into it afterwards: the repository, the branch and the
+  // binding it reported ride on every message, so a restarted worker needs
+  // nothing but the delivery. Other providers never get the field.
+  const claudeCloud = isClaudeCloudProviderType(providerType)
+    ? buildClaudeCloudDelivery({
+        conversation: stmts.getConvAnyStatus?.get?.(msg.conversation_id) || null,
+        runtimeSession,
+        fallbackEnvironmentId: getClaudeCloudProviderSettings()?.environmentId || '',
+      })
+    : null;
   return {
     id: msg.id,
     conversationId: msg.conversation_id,
@@ -1163,6 +1188,7 @@ export function buildDequeuedRelayMessage({
     cursorAgentId: String(runtimeSession?.cursor_agent_id || '').trim() || null,
     cursorSubagentModels,
     grokNativeSessionId: String(runtimeSession?.grok_native_session_id || '').trim() || null,
+    ...(isClaudeCloudProviderType(providerType) ? { claudeCloud } : {}),
     reasoningEffort: String(msg.reasoning_effort || '').trim() || null,
     contextTier: String(msg.context_tier || '').trim() || 'default',
     quality: normalizeOpenAIImageQuality(msg.reasoning_effort),
@@ -1783,6 +1809,7 @@ export function registerMessagesRoutes(app, deps) {
     getClaudeProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getCursorProviderSettings = () => ({ enabled: false, model: '', models: [] }),
     getGrokProviderSettings = () => ({ enabled: false, model: '', models: [] }),
+    getClaudeCloudProviderSettings = () => ({ enabled: false, defaultModel: '', environmentId: '', models: [] }),
     rebindUnstartedOpenAIConversationModel = null,
     normalizeRelayMode,
     DEFAULT_RELAY_MODE,
@@ -4166,7 +4193,8 @@ export function registerMessagesRoutes(app, deps) {
     const runtimeBoundToExplicitProvider = runtimeProviderType === 'openai'
       || runtimeProviderType === 'claude'
       || runtimeProviderType === 'cursor'
-      || runtimeProviderType === 'grok';
+      || runtimeProviderType === 'grok'
+      || runtimeProviderType === 'claude-cloud';
     const configuredOpenAIModel = String(configuredOpenAI?.model || '').trim();
     const availableOpenAIModels = new Set(
       (Array.isArray(configuredOpenAI?.models) ? configuredOpenAI.models : [])
@@ -4290,6 +4318,17 @@ export function registerMessagesRoutes(app, deps) {
         });
       }
     }
+    // Claude Cloud conversations are bootstrap-created only as well: each
+    // carries the repository its cloud session clones. Only an explicit
+    // provider counts here — the cloud's model ids are the Claude provider's
+    // own, so an id alone never means "cloud".
+    const runtimeUsesClaudeCloud = runtimeProviderType === 'claude-cloud';
+    if (!shouldCreateConversation && !runtimeUsesClaudeCloud && requestedProviderType === 'claude-cloud') {
+      return res.status(409).json({
+        error: 'Claude Cloud requires creating a new Claude Cloud conversation',
+        code: 'CLAUDE_CLOUD_REQUIRES_NEW_CONVERSATION',
+      });
+    }
     if (
       useOpenAIProvider
       && requestedOpenAIModel
@@ -4422,6 +4461,32 @@ export function registerMessagesRoutes(app, deps) {
     const grokModel = runtimeUsesGrok
       ? (pinnedGrokModel || String(configuredGrok?.model || '').trim())
       : '';
+    // Claude Cloud conversations resolve models against the cloud provider's
+    // own list (plain ids, no "[1m]" tier). The model is part of the cloud
+    // session's configuration: it can still change before the first message
+    // creates that session, and is locked afterwards.
+    const configuredClaudeCloud = runtimeUsesClaudeCloud ? getClaudeCloudProviderSettings() : null;
+    const pinnedClaudeCloudModel = runtimeUsesClaudeCloud
+      ? stripModelTierSuffix(existingRuntimeSession?.provider_model)
+      : '';
+    const claudeCloudModelSelection = runtimeUsesClaudeCloud
+      ? resolveProviderModelSelection({
+          requestedModel: stripModelTierSuffix(model),
+          configuredModel: pinnedClaudeCloudModel || String(configuredClaudeCloud?.defaultModel || '').trim(),
+          availableModels: Array.isArray(configuredClaudeCloud?.models) ? configuredClaudeCloud.models : [],
+        })
+      : null;
+    if (claudeCloudModelSelection && !claudeCloudModelSelection.ok) {
+      return res.status(400).json({
+        error: `Claude Cloud model "${claudeCloudModelSelection.requestedModel}" is not available`,
+        code: 'CLAUDE_CLOUD_MODEL_UNAVAILABLE',
+        supportedModels: claudeCloudModelSelection.availableModels || [],
+      });
+    }
+    // A cloud session's model can be switched between turns (the worker
+    // sends set_model before the message), so a changed model is taken as
+    // for a local Claude chat.
+    const claudeCloudModel = claudeCloudModelSelection ? claudeCloudModelSelection.model : '';
     const modelResolution = useOpenAIProvider
       ? {
           ok: !!openAIModel,
@@ -4454,7 +4519,15 @@ export function registerMessagesRoutes(app, deps) {
                 reasoningEffort: null,
                 error: grokModel ? null : 'Grok model is not configured',
               }
-            : resolveRequestedModel(model))));
+            : (runtimeUsesClaudeCloud
+              ? {
+                  ok: !!claudeCloudModel,
+                  model: claudeCloudModel,
+                  modelVariantId: claudeCloudModel,
+                  reasoningEffort: null,
+                  error: claudeCloudModel ? null : 'Claude Cloud model is not configured',
+                }
+              : resolveRequestedModel(model)))));
     if (!modelResolution.ok) return res.status(400).json({ error: modelResolution.error, supportedModels: modelResolution.available || [] });
     const requestedModel = String(modelResolution.model || '').trim();
     const requestedAutoModel = requestedModel.toLowerCase() === AUTO_MODEL_SENTINEL;
@@ -4523,10 +4596,13 @@ export function registerMessagesRoutes(app, deps) {
           ? resolveCursorReasoningEffort()
           : (runtimeUsesGrok
             ? resolveGrokReasoningEffort()
-            : resolveRequestedReasoningEffort(
-                requestedModel,
-                explicitReasoningEffort || modelResolution.reasoningEffort || null,
-              ))));
+            // A cloud session takes no effort: whatever was asked, it is none.
+            : (runtimeUsesClaudeCloud
+              ? { ok: true, effort: 'none', supported: ['none'] }
+              : resolveRequestedReasoningEffort(
+                  requestedModel,
+                  explicitReasoningEffort || modelResolution.reasoningEffort || null,
+                )))));
     if (!reasoningResolution?.ok && !explicitReasoningEffort) {
       const supportedEfforts = Array.isArray(reasoningResolution?.supported)
         ? reasoningResolution.supported.map((value) => String(value || '').trim().toLowerCase()).filter(Boolean)
@@ -4553,6 +4629,9 @@ export function registerMessagesRoutes(app, deps) {
       }
     } else if (!['default', 'long_context'].includes(requestedContextTier)) {
       return res.status(400).json({ error: 'Unsupported context tier' });
+    } else if (runtimeUsesClaudeCloud) {
+      // The cloud has no long-context tier to pick.
+      normalizedContextTier = 'default';
     }
     if (!requestedRelayMode) return res.status(400).json({ error: 'Unsupported relay mode' });
     const conversationWorkspaceState = (!shouldCreateConversation && typeof resolveConversationWorkspaceState === 'function')
@@ -4784,6 +4863,17 @@ export function registerMessagesRoutes(app, deps) {
       ) {
         stmts.updateRuntimeSessionProvider.run('claude', claudeModel, claudeModel, now, runtimeSession.id);
       }
+      // A cloud conversation follows the composer like a Claude one: the
+      // worker switches the sandbox's model before the message.
+      if (
+        runtimeUsesClaudeCloud
+        && claudeCloudModel
+        && runtimeSession?.id
+        && claudeCloudModel !== String(existingRuntimeSession?.provider_model || '').trim()
+        && typeof stmts.updateRuntimeSessionProvider?.run === 'function'
+      ) {
+        stmts.updateRuntimeSessionProvider.run('claude-cloud', claudeCloudModel, claudeCloudModel, now, runtimeSession.id);
+      }
       // Another relay's agent picks the model and mode of its own turn; the
       // composer keeps restoring the user's choice for this conversation.
       conversationPreferences = remoteRequest.remote && !shouldCreateConversation
@@ -5285,7 +5375,10 @@ export function registerMessagesRoutes(app, deps) {
     if (!runtimeSession) {
       return res.status(404).json({ error: 'Runtime session not found for conversation' });
     }
-    if (String(runtimeSession.provider_type || 'github').trim().toLowerCase() !== 'claude') {
+    // The Claude Cloud worker reports the same shape (the cloud session's
+    // context and token usage), so both providers are taken here.
+    const contextUsageProvider = String(runtimeSession.provider_type || 'github').trim().toLowerCase();
+    if (contextUsageProvider !== 'claude' && contextUsageProvider !== 'claude-cloud') {
       return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
     }
     if (typeof stmts.updateRuntimeSessionContextUsage?.run !== 'function') {
@@ -5345,13 +5438,17 @@ export function registerMessagesRoutes(app, deps) {
     // Claude-bound conversation's worker may write the Claude card. The
     // snapshot itself is global, so a misrouted poster would corrupt it for
     // everyone.
+    // A Claude Cloud worker posts here too; its report is kept under its own
+    // snapshot key, so the Claude card stays what the Claude workers wrote.
     const conversationId = String(req.body?.conversationId || '').trim();
+    let snapshotProvider = 'claude';
     if (conversationId) {
       const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
       const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
-      if (runtimeSession && boundProvider !== 'claude') {
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
         return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
       }
+      if (runtimeSession && boundProvider === 'claude-cloud') snapshotProvider = 'claude-cloud';
     }
     const usage = normalizeClaudePlanUsage(req.body?.usage)
       || claudePlanUsageFromResult({
@@ -5359,7 +5456,7 @@ export function registerMessagesRoutes(app, deps) {
         totalCostUsd: req.body?.totalCostUsd,
       });
     if (!usage) return res.status(400).json({ error: 'Missing usable usage payload' });
-    planUsageService.saveSnapshot('claude', usage, {
+    planUsageService.saveSnapshot(snapshotProvider, usage, {
       source: 'worker',
       error: String(req.body?.error || '').trim() || null,
     });
@@ -5373,12 +5470,13 @@ export function registerMessagesRoutes(app, deps) {
     touchCli();
     if (!usageLimitPauseService) return res.status(501).json({ error: 'Usage limit handling is unavailable' });
     // The report is the account's, so only a Claude-bound conversation's
-    // worker may write it (same validation as the plan usage card).
+    // worker may write it (same validation as the plan usage card); a Claude
+    // Cloud chat runs on the same account and reports the same limit.
     const conversationId = String(req.body?.conversationId || '').trim();
     if (conversationId) {
       const runtimeSession = stmts.getRuntimeSessionByConversation?.get?.(conversationId) || null;
       const boundProvider = String(runtimeSession?.provider_type || 'github').trim().toLowerCase();
-      if (runtimeSession && boundProvider !== 'claude') {
+      if (runtimeSession && boundProvider !== 'claude' && boundProvider !== 'claude-cloud') {
         return res.status(409).json({ error: 'Conversation is not bound to the Claude provider' });
       }
     }
@@ -5982,6 +6080,7 @@ export function registerMessagesRoutes(app, deps) {
         defaultRelayMode: DEFAULT_RELAY_MODE,
         defaultModel: DEFAULT_MODEL,
         getCursorProviderSettings,
+        getClaudeCloudProviderSettings,
       });
       
       if (out.attachments.length) {
@@ -6576,7 +6675,10 @@ export function registerMessagesRoutes(app, deps) {
       }
     };
     let trimmedText = String(text || '').trim();
-    let terminalFailure = resolveTerminalFailurePayload(req.body, { fallbackText: trimmedText });
+    let terminalFailure = resolveTerminalFailurePayload(req.body, {
+      fallbackText: trimmedText,
+      inferFromText: !String(req.body?.attemptId || '').trim(),
+    });
     // Final digests of background workflows that settled during this turn —
     // the transcript's "Finished background task" cards. Same structural
     // sanitizer as the live panel rows; junk entries drop silently (this
@@ -7106,7 +7208,10 @@ export function registerMessagesRoutes(app, deps) {
   // Providers whose workers turn runtime-initiated activity into continuation
   // rows: the Claude worker (background tasks/agents) and the Copilot SDK
   // worker (detached background shells) serving both Copilot-CLI providers.
-  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai']);
+  // A Claude Cloud session can take a turn of its own too: one the agent
+  // starts when its background work reports back, or one started on
+  // claude.ai; the cloud worker follows it and registers it here.
+  const CONTINUATION_PROVIDER_TYPES = new Set(['claude', 'github', 'openai', 'claude-cloud']);
 
   // POST /api/continuation-turn — a session worker's CLI started a turn on its
   // own (a background task's notification). The synthetic queue row gives that