@oar-sh/oar 0.9.6 → 0.9.8

package/server/public/manifest.webmanifest

@@ -7,11 +7,11 @@
   "scope": "./",
   "display_override": ["standalone"],
   "display": "standalone",
-  "background_color": "#161b22",
-  "theme_color": "#161b22",
+  "background_color": "#0d1117",
+  "theme_color": "#0d1117",
   "icons": [
     {
-      "src": "app-icon.svg?v=25",
+      "src": "app-icon.svg?v=26",
       "sizes": "any",
       "type": "image/svg+xml",
       "purpose": "any"
@@ -27,6 +27,12 @@
       "sizes": "512x512",
       "type": "image/png",
       "purpose": "any"
+    },
+    {
+      "src": "app-icon-maskable-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
     }
   ]
 }

package/server/public/sw.js

@@ -13,6 +13,11 @@ const STATIC_ASSETS = [
   'app-icon-512.png',
   'favicon.ico',
   'app-icon.svg',
+  'app-icon-light-192.png',
+  'app-icon-light-512.png',
+  'app-icon-light.svg',
+  'app-icon-maskable-512.png',
+  'app-icon-light-maskable-512.png',
 ];
 
 function sameOrigin(url) {
@@ -26,7 +31,7 @@ function isApiRequest(url) {
 function isPwaMetadataRequest(url) {
   if (!url.pathname.startsWith(REGISTRATION_SCOPE_PATH)) return false;
   const relativePath = url.pathname.slice(REGISTRATION_SCOPE_PATH.length);
-  return /^(?:manifest\.webmanifest|app-icon(?:-\d+)?\.png|app-icon\.svg|favicon\.ico)$/.test(relativePath);
+  return /^(?:manifest\.webmanifest|app-icon(?:-light)?(?:-maskable)?(?:-\d+)?\.(?:png|svg)|favicon\.ico)$/.test(relativePath);
 }
 
 function isApplicationModuleRequest(url) {

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