@oar-sh/oar 0.9.5 → 0.9.7

package/server/relay-tools.md

@@ -30,4 +30,16 @@ If you have a `preview` tool, use it. Otherwise use the authenticated localhost
 
 ## Remote relays
 
-If you have a `remote_relay` tool, this relay is paired with other OAR relays and the tool works on them: list and read their sessions, prompt a session, start a new one and wait for its reply. Use it only when the user asks for work on another relay or mentions one, and start with `{"action":"list_relays"}`. A relay stays locked until the user mentions it in this conversation (`@name` or its plain name); a locked relay refuses everything except `list_relays`, so ask the user to mention it rather than retrying. Write actions may first wait for the user's approval. If a result lists `pendingQuestions`, the remote agent is waiting for an answer: ask the user (unless they told you to decide), then pass it on with `answer_question`. Always tell the user which relay and session you worked on.
+If you have a `remote_relay` tool, it works with sessions on OAR relays: the other relays this relay is paired with and, when its owner allows it, this relay itself. It lists and reads sessions, prompts a session, starts a new one and waits for its reply. Start with `{"action":"list_relays"}`.
+
+A paired relay stays locked until the user mentions it in this conversation (`@name` or its plain name); a locked relay refuses everything except `list_relays`, so ask the user to mention it rather than retrying. Use a paired relay only when the user asks for work there or mentions it.
+
+This relay itself is listed with "self": true when its owner switched agent sessions on, and is addressed by its name or as "this"; it needs no mention. Use it to hand parts of your task to other sessions:
+
+- `create_session` starts a session with any provider that `relay_info` lists: a local one in a folder ("cwd"), or provider "claude-cloud" with "repo" (a GitHub URL or owner/repo) and an optional "branch". At most 4 sessions you started may work at the same time; a fifth is refused until one finishes.
+- The first `create_session` on this relay shows the user an approval card, once per conversation. A session that an agent created cannot create sessions itself (one level only).
+- A new session knows nothing of this conversation: write a self-contained prompt. A Claude Cloud session works on a fresh clone in a sandbox at Anthropic, so name the branch it should work on and push.
+- Follow each session with `wait` (the message id comes back from `create_session` and `send`) and `read_session`; "wait_seconds" is limited to the maximum set on the relay (default 600).
+- Sessions run on the relay owner's accounts and cost their usage: start only what the task needs.
+
+Write actions may first wait for the user's approval. If a result lists `pendingQuestions`, the other agent is waiting for an answer: ask the user (unless they told you to decide), then pass it on with `answer_question`. Always tell the user which relay and session you worked on.

package/server/repositories/message-repository.mjs

@@ -7,6 +7,14 @@ export function createMessageRepository(db) {
     const shareVisibility = createShareVisibilityStatements(db);
     const queueHasImageOperationId = db.prepare(`PRAGMA table_info(queue)`).all()
         .some((column) => column.name === 'image_operation_id');
+    // A turn paused at the Claude usage limit (usage-limit-pause-service): a
+    // pending follow-up held until the reset. It is not work waiting for a
+    // worker, so it neither keeps one warm nor counts as queued.
+    const queueHasUsageLimitPause = db.prepare(`PRAGMA table_info(queue)`).all()
+        .some((column) => column.name === 'usage_limit_pause');
+    const notHeldForUsageLimit = (alias = '') => (queueHasUsageLimitPause
+        ? `AND NOT (${alias}usage_limit_pause IS NOT NULL AND ${alias}status = 'pending' AND ${alias}next_attempt_at IS NOT NULL AND ${alias}next_attempt_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`
+        : '');
     const messageColumns = new Set(db.prepare(`PRAGMA table_info(messages)`).all().map((column) => column.name));
     const messagesHaveSourceId = messageColumns.has('source_message_id');
     const messagesHaveResendOf = messageColumns.has('resend_of_message_id');
@@ -270,6 +278,7 @@ export function createMessageRepository(db) {
           LEFT JOIN conversations c
             ON c.id = q.conversation_id
           WHERE q.status = 'pending'
+            ${notHeldForUsageLimit('q.')}
             AND COALESCE(
               NULLIF(q.owner_sdk_session_id, ''),
               NULLIF(rs.sdk_session_id, ''),
@@ -283,7 +292,7 @@ export function createMessageRepository(db) {
           ORDER BY MIN(q.timestamp) ASC
           LIMIT ?
         `),
-        countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') GROUP BY status`),
+        countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') ${notHeldForUsageLimit()} GROUP BY status`),
         // Deferred host suspend: which conversations still hold live turns.
         listActiveQueueCountsByConversation: db.prepare(`
           SELECT q.conversation_id, COUNT(*) AS cnt, MAX(c.title) AS title

package/server/repositories/question-repository.mjs

@@ -174,6 +174,7 @@ export function createQuestionRepository(db) {
         insertBoard: db.prepare(`INSERT INTO relay_boards (id, queue_id, conversation_id, message_id, board_type, relay_mode, title, body, actions_json, recommended_action, context_json, status, selected_action, acted_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?)`),
         getBoard: db.prepare(`SELECT * FROM relay_boards WHERE id = ?`),
         findBoardByMessageType: db.prepare(`SELECT * FROM relay_boards WHERE message_id = ? AND board_type = ? ORDER BY created_at DESC LIMIT 1`),
+        listBoardsForConversation: db.prepare(`SELECT * FROM relay_boards WHERE conversation_id = ? ORDER BY created_at ASC`),
         listBoards: db.prepare(`SELECT * FROM relay_boards WHERE status = ? AND (? IS NULL OR conversation_id = ?) ORDER BY created_at ASC`),
         markBoardAction: db.prepare(`UPDATE relay_boards SET status = 'acted', selected_action = ?, acted_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`),
         dismissBoard: db.prepare(`UPDATE relay_boards SET status = 'dismissed', selected_action = ?, acted_at = ?, updated_at = ? WHERE id = ? AND status = 'pending'`),

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

@@ -1,11 +1,20 @@
 '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
 // messages and conversations another relay's agent created. Tables and
 // columns come from migrations/0005-remote-relays.mjs.
+//
+// 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;
@@ -26,6 +35,27 @@ export function createRemoteRelayRepository(db) {
   const getMessageOrigin = db.prepare(`SELECT origin_json FROM messages WHERE id = ?`);
   const setConversationOrigin = db.prepare(`UPDATE conversations SET origin_json = ? WHERE id = ?`);
   const getConversationOrigin = db.prepare(`SELECT origin_json FROM conversations WHERE id = ?`);
+  const listUserMessageOrigins = db.prepare(`
+    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
+    ORDER BY timestamp DESC LIMIT 1
+  `);
 
   return {
     hasUnlock(conversationId, remoteRelayId) {
@@ -46,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;
     },
@@ -66,6 +120,23 @@ export function createRemoteRelayRepository(db) {
     getConversationOrigin(conversationId) {
       return parseOrigin(getConversationOrigin.get(String(conversationId || ''))?.origin_json);
     },
+    /**
+     * Did an agent on the relay with this instance id (the `relayId` of an
+     * origin, not the local registry id) write to the conversation: by
+     * starting it, or with a prompt in it?
+     */
+    hasContactFrom(conversationId, remoteInstanceId) {
+      const conversation = String(conversationId || '').trim();
+      const instance = String(remoteInstanceId || '').trim();
+      if (!conversation || !instance) return false;
+      if (parseOrigin(getConversationOrigin.get(conversation)?.origin_json)?.relayId === instance) return true;
+      return listUserMessageOrigins.all(conversation)
+        .some((row) => parseOrigin(row.origin_json)?.relayId === instance);
+    },
+    /** The id of the latest message the user wrote themselves, or null. */
+    latestHumanMessageId(conversationId) {
+      return getLatestHumanMessage.get(String(conversationId || ''))?.id || null;
+    },
   };
 }
 

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) {