@oar-sh/oar 0.9.5 → 0.9.7

package/server/public/app/agent-sessions-settings-ui.js

@@ -0,0 +1,197 @@
+// Settings → Relays → Agent sessions: the switch that lets agents start and use
+// sessions on this relay through the remote_relay tool, and the slider for the
+// longest wait of one tool call. The decisions live in
+// agent-sessions-settings.mjs; this file only moves them into the markup in
+// index.html. The static controls use inline handlers that bootstrap.js
+// exposes on window.
+//
+// The section ships hidden. It shows once the relay answered with settings and
+// stays hidden on a relay that does not know the route (404).
+
+import { loadAgentSessionsSettings, updateAgentSessionsSettings } from './api-client.js';
+import {
+  agentSessionsSavedText,
+  agentSessionsViewModel,
+  clampWaitSeconds,
+  classifyAgentSessionsLoad,
+  formatWaitMinutesLabel,
+  normalizeAgentSessionsSettings,
+} from './agent-sessions-settings.mjs';
+
+// null until the first successful read: "never answered" is not "off".
+let settingsState = null;
+let unsupported = false;
+let loadFailed = false;
+let saveInFlight = false;
+// What is being saved, drawn over the stored state until the relay answers so
+// the switch and the thumb stay where the user put them.
+let pendingChange = null;
+// A value from elsewhere arrived while the slider had focus; drawn on blur.
+let sliderRenderDeferred = false;
+let sliderBlurBound = false;
+
+function el(id) {
+  return document.getElementById(id);
+}
+
+export function getAgentSessionsSettings() {
+  return settingsState;
+}
+
+function setStatusLine(state, text) {
+  const line = el('agent-sessions-status');
+  if (!line) return;
+  line.textContent = text || '';
+  line.hidden = !text;
+  if (state) line.dataset.state = state;
+  else delete line.dataset.state;
+}
+
+function setSliderLabel(text) {
+  const label = el('agent-sessions-max-wait-value');
+  if (label) label.textContent = text;
+  // The value is in seconds; a screen reader hears the minutes.
+  el('agent-sessions-max-wait-slider')?.setAttribute('aria-valuetext', text);
+}
+
+function bindSliderBlur(slider) {
+  if (sliderBlurBound) return;
+  sliderBlurBound = true;
+  slider.addEventListener('blur', () => {
+    if (sliderRenderDeferred) renderAgentSessionsSection({ forceSlider: true });
+  });
+}
+
+/**
+ * Idempotent. A value that came from elsewhere (socket, refresh) never moves
+ * the thumb under the user's finger: it waits until focus leaves the slider.
+ * `forceSlider` is for this page's own saves.
+ */
+export function renderAgentSessionsSection({ forceSlider = false } = {}) {
+  const section = el('agent-sessions-section');
+  if (!section) return;
+  const view = agentSessionsViewModel({
+    settings: settingsState && pendingChange ? { ...settingsState, ...pendingChange } : settingsState,
+    unsupported,
+    loadFailed,
+    saving: saveInFlight,
+  });
+  section.hidden = view.hidden;
+
+  const toggle = el('agent-sessions-enabled-toggle');
+  if (toggle) {
+    toggle.checked = view.toggle.checked;
+    toggle.disabled = view.toggle.disabled;
+  }
+
+  const slider = el('agent-sessions-max-wait-slider');
+  if (slider) {
+    bindSliderBlur(slider);
+    slider.disabled = view.slider.disabled;
+    const held = !forceSlider && !view.slider.disabled && document.activeElement === slider;
+    sliderRenderDeferred = held;
+    if (!held) {
+      // Range first: a value outside the old range would be clamped by the input.
+      slider.min = String(view.slider.min);
+      slider.max = String(view.slider.max);
+      slider.step = String(view.slider.step);
+      slider.value = String(view.slider.value);
+      setSliderLabel(view.slider.label);
+    }
+  }
+
+  const cap = el('agent-sessions-cap');
+  if (cap) {
+    cap.textContent = view.capText;
+    cap.hidden = !view.capText;
+  }
+}
+
+// Single entry point for every payload (GET, POST answer, socket event).
+export function applyAgentSessionsSettingsState(payload, { forceSlider = false } = {}) {
+  if (!payload || typeof payload !== 'object') return settingsState;
+  settingsState = normalizeAgentSessionsSettings(payload, settingsState);
+  unsupported = false;
+  loadFailed = false;
+  renderAgentSessionsSection({ forceSlider });
+  return settingsState;
+}
+
+/** Called when the settings modal opens, and for a socket event without a body. */
+export async function refreshAgentSessionsSection() {
+  if (!saveInFlight) setStatusLine('', '');
+  renderAgentSessionsSection();
+  const result = await loadAgentSessionsSettings();
+  const outcome = classifyAgentSessionsLoad(result);
+  if (outcome === 'loaded') return applyAgentSessionsSettingsState(result);
+  if (outcome === 'unsupported') {
+    unsupported = true;
+    settingsState = null;
+  } else if (!settingsState) {
+    // Keep what an earlier read said: one failed refresh is not "gone".
+    loadFailed = true;
+    setStatusLine('error', 'Could not load the agent session settings from this relay.');
+  }
+  renderAgentSessionsSection();
+  return settingsState;
+}
+
+async function saveAgentSessionsChange(change, patch, failureText) {
+  saveInFlight = true;
+  pendingChange = patch;
+  setStatusLine('saved', 'Saving…');
+  renderAgentSessionsSection({ forceSlider: true });
+  let result = null;
+  try {
+    result = await updateAgentSessionsSettings(patch);
+  } finally {
+    saveInFlight = false;
+    pendingChange = null;
+  }
+  if (result?.ok) {
+    // The relay's answer is the truth (it may have clamped the wait).
+    applyAgentSessionsSettingsState({ ...patch, ...result }, { forceSlider: true });
+    setStatusLine('active', agentSessionsSavedText(change, settingsState));
+  } else {
+    // Back to what the relay has; the line says why.
+    setStatusLine('error', result?.error || failureText);
+    renderAgentSessionsSection({ forceSlider: true });
+  }
+}
+
+export async function toggleAgentSessions(checked) {
+  if (saveInFlight || !settingsState) {
+    renderAgentSessionsSection();
+    return;
+  }
+  await saveAgentSessionsChange('enabled', { enabled: checked === true }, 'Failed to update the setting.');
+}
+
+/** Live label feedback while dragging; nothing is saved until change fires. */
+export function previewAgentSessionsMaxWait(value) {
+  const seconds = clampWaitSeconds(value, settingsState?.limits, settingsState?.maxWaitSeconds);
+  setSliderLabel(formatWaitMinutesLabel(seconds));
+}
+
+export async function saveAgentSessionsMaxWait(value) {
+  if (saveInFlight || !settingsState) {
+    renderAgentSessionsSection({ forceSlider: true });
+    return;
+  }
+  const seconds = clampWaitSeconds(value, settingsState.limits, settingsState.maxWaitSeconds);
+  if (seconds === settingsState.maxWaitSeconds) {
+    renderAgentSessionsSection({ forceSlider: true });
+    return;
+  }
+  await saveAgentSessionsChange('maxWaitSeconds', { maxWaitSeconds: seconds }, 'Failed to save the longest wait.');
+}
+
+/** Test hook. */
+export function resetAgentSessionsSettingsForTests() {
+  settingsState = null;
+  unsupported = false;
+  loadFailed = false;
+  saveInFlight = false;
+  pendingChange = null;
+  sliderRenderDeferred = false;
+}

package/server/public/app/agent-sessions-settings.mjs

@@ -0,0 +1,134 @@
+// Pure helpers for Settings → Relays → Agent sessions: whether agents may
+// start and use sessions on this relay, and the longest time one remote_relay
+// call may wait. DOM-free on purpose, like claude-cloud-ui.mjs: the section
+// (agent-sessions-settings-ui.js) owns the elements, this module the decisions.
+//
+// One payload shape everywhere — GET and POST /api/settings/agent-sessions and
+// the `agent_sessions_settings_updated` socket event:
+//   { enabled, maxWaitSeconds, limits: { minWaitSeconds, maxWaitSeconds, stepSeconds }, maxActiveSessions }
+// The relay stores seconds; the slider works in seconds too and only its label
+// speaks minutes.
+
+export const AGENT_SESSIONS_SOCKET_EVENT = 'agent_sessions_settings_updated';
+
+// What the relay enforces when it says nothing else; the markup starts there.
+export const AGENT_SESSIONS_DEFAULT_WAIT_SECONDS = 600;
+export const AGENT_SESSIONS_DEFAULT_LIMITS = Object.freeze({
+  minWaitSeconds: 120,
+  maxWaitSeconds: 3600,
+  stepSeconds: 60,
+});
+
+function positiveNumber(value) {
+  // No coercion of null, '' or true into a number.
+  if (typeof value !== 'number' && (typeof value !== 'string' || !value.trim())) return null;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : null;
+}
+
+/** The slider's range and step in seconds; anything unusable falls back. */
+export function normalizeAgentSessionsLimits(raw, fallback = AGENT_SESSIONS_DEFAULT_LIMITS) {
+  const minWaitSeconds = positiveNumber(raw?.minWaitSeconds) ?? fallback.minWaitSeconds;
+  const maxCandidate = positiveNumber(raw?.maxWaitSeconds) ?? fallback.maxWaitSeconds;
+  return {
+    minWaitSeconds,
+    maxWaitSeconds: Math.max(minWaitSeconds, maxCandidate),
+    stepSeconds: positiveNumber(raw?.stepSeconds) ?? fallback.stepSeconds,
+  };
+}
+
+/**
+ * A wait the relay will accept: inside the limits and on a step counted from
+ * the minimum. Something that is not a number becomes `fallback`, clamped the
+ * same way.
+ */
+export function clampWaitSeconds(value, limits = AGENT_SESSIONS_DEFAULT_LIMITS, fallback = AGENT_SESSIONS_DEFAULT_WAIT_SECONDS) {
+  const { minWaitSeconds: min, maxWaitSeconds: max, stepSeconds: step } = normalizeAgentSessionsLimits(limits);
+  const wanted = positiveNumber(value) ?? positiveNumber(fallback) ?? min;
+  const bounded = Math.min(max, Math.max(min, wanted));
+  const stepped = min + Math.round((bounded - min) / step) * step;
+  // The last step may overshoot a maximum that is not on the grid.
+  return stepped > max ? min + Math.floor((max - min) / step) * step : stepped;
+}
+
+/** 600 → "10 min", 150 → "2.5 min"; '' for something that is not a duration. */
+export function formatWaitMinutesLabel(seconds) {
+  const value = positiveNumber(seconds);
+  if (value === null) return '';
+  return `${Math.round((value / 60) * 10) / 10} min`;
+}
+
+/**
+ * The section's state from a payload. A field the payload does not carry keeps
+ * what `previous` had (the first payload falls back to "off" and the defaults).
+ */
+export function normalizeAgentSessionsSettings(payload, previous = null) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return previous;
+  const limits = payload.limits && typeof payload.limits === 'object'
+    ? normalizeAgentSessionsLimits(payload.limits)
+    : (previous?.limits || { ...AGENT_SESSIONS_DEFAULT_LIMITS });
+  const maxActive = positiveNumber(payload.maxActiveSessions);
+  return {
+    enabled: typeof payload.enabled === 'boolean' ? payload.enabled : previous?.enabled === true,
+    maxWaitSeconds: positiveNumber(payload.maxWaitSeconds)
+      ?? previous?.maxWaitSeconds
+      ?? AGENT_SESSIONS_DEFAULT_WAIT_SECONDS,
+    limits,
+    maxActiveSessions: maxActive !== null ? Math.floor(maxActive) : (previous?.maxActiveSessions ?? null),
+  };
+}
+
+/**
+ * What an answer to the GET means for the section:
+ *   'loaded'      — the settings; show the section.
+ *   'unsupported' — an older relay without the route (404, or a 200 that is not
+ *                   the settings); hide the section.
+ *   'failed'      — the relay could not be asked (offline, paused, 5xx); keep
+ *                   what is shown.
+ */
+export function classifyAgentSessionsLoad(result) {
+  if (!result || typeof result !== 'object') return 'failed';
+  if (result.ok === true) return typeof result.enabled === 'boolean' ? 'loaded' : 'unsupported';
+  return Number(result.status) === 404 ? 'unsupported' : 'failed';
+}
+
+/**
+ * Everything the section draws, from its state. `settings` is null until the
+ * relay answered; `unsupported` hides the section for good; `loadFailed` shows
+ * it switched off with a note when the very first read failed.
+ */
+export function agentSessionsViewModel({ settings = null, unsupported = false, loadFailed = false, saving = false } = {}) {
+  const known = !!settings && !unsupported;
+  const limits = normalizeAgentSessionsLimits(settings?.limits);
+  const value = positiveNumber(settings?.maxWaitSeconds) ?? AGENT_SESSIONS_DEFAULT_WAIT_SECONDS;
+  const cap = positiveNumber(settings?.maxActiveSessions);
+  return {
+    hidden: unsupported || (!settings && !loadFailed),
+    toggle: {
+      checked: known && settings.enabled === true,
+      disabled: !known || saving,
+    },
+    slider: {
+      min: limits.minWaitSeconds,
+      max: limits.maxWaitSeconds,
+      step: limits.stepSeconds,
+      value,
+      label: formatWaitMinutesLabel(value),
+      // Not tied to the switch: the limit also governs waits on paired relays.
+      disabled: !known || saving,
+    },
+    capText: known && cap !== null
+      ? `At most ${Math.floor(cap)} of them work at the same time per conversation.`
+      : '',
+  };
+}
+
+/** The status line after a save the relay accepted. */
+export function agentSessionsSavedText(change, settings) {
+  if (change === 'enabled') {
+    return settings?.enabled === true
+      ? 'Agents may start and use sessions on this relay now.'
+      : 'Agents can no longer start or use sessions on this relay.';
+  }
+  return `Agents may wait up to ${formatWaitMinutesLabel(settings?.maxWaitSeconds)} per tool call.`;
+}

package/server/public/app/api-client.js

@@ -273,11 +273,13 @@ export async function updateClaudeSettings({
   enabled = undefined,
   model = undefined,
   enabledModels = undefined,
+  attributionMode = undefined,
 } = {}) {
   const payload = {};
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (typeof attributionMode === 'string' && attributionMode.trim()) payload.attributionMode = attributionMode.trim();
   return settingsRequest('/api/settings/claude', payload, 'Failed to update Claude settings');
 }
 
@@ -370,6 +372,65 @@ export async function updateGrokSettings({
   return settingsRequest('/api/settings/grok', payload, 'Failed to update Grok settings');
 }
 
+// Claude Cloud (provider `claude-cloud`). A relay without these routes answers
+// 404, and a folder outside the workspace roots is refused: both must read as
+// "nothing to show" (the New Chat option stays hidden, the fields stay empty),
+// so these reads skip apiFetch's error logging.
+async function quietGet(path) {
+  if (!networkRequestsEnabled) return null;
+  try {
+    const response = await fetch(`${BASE}${path}`, {
+      signal: requestTimeoutSignal(),
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+    });
+    if (!response.ok) return null;
+    noteFetchSuccess();
+    return await response.json().catch(() => null);
+  } catch (error) {
+    noteFetchFailure(path, error);
+    return null;
+  }
+}
+
+export async function loadClaudeCloudSettings() {
+  return quietGet('/api/settings/claude-cloud');
+}
+
+export async function updateClaudeCloudSettings({
+  enabled = undefined,
+  defaultModel = undefined,
+  environmentId = undefined,
+} = {}) {
+  const payload = {};
+  if (typeof enabled === 'boolean') payload.enabled = enabled;
+  if (typeof defaultModel === 'string' && defaultModel.trim()) payload.defaultModel = defaultModel.trim();
+  if (typeof environmentId === 'string' && environmentId.trim()) payload.environmentId = environmentId.trim();
+  return settingsRequest('/api/settings/claude-cloud', payload, 'Failed to update Claude Cloud settings');
+}
+
+// origin + current branch of a folder on the relay host, for the New Chat
+// Repository and Branch fields. null when the relay could not say.
+export async function loadGitRemote(rootPath) {
+  const root = String(rootPath || '').trim();
+  if (!root) return null;
+  return quietGet(`/api/git/remote?root=${encodeURIComponent(root)}`);
+}
+
+// The repositories the Claude GitHub app can reach, plus the ones used in
+// earlier cloud chats here, for the New Chat Repository suggestions. null
+// when the relay could not say (the field is then typed, as before).
+export async function loadClaudeCloudRepos({ refresh = false } = {}) {
+  return quietGet(`/api/claude-cloud/repos${refresh ? '?refresh=1' : ''}`);
+}
+
+// The branches of a GitHub repository as the relay host's git sees them, for
+// the New Chat Branch suggestions. null when the relay could not say.
+export async function loadClaudeCloudBranches(repo) {
+  const text = String(repo || '').trim();
+  if (!text) return null;
+  return quietGet(`/api/claude-cloud/branches?repo=${encodeURIComponent(text)}`);
+}
+
 export async function updateOpenAISettings({
   apiKey = '',
   model = 'gpt-4o',
@@ -542,6 +603,23 @@ export async function updateRemoteRelaySettings(patch = {}) {
   return remoteRelayRequest('/api/settings/remote-relays', { method: 'POST', body });
 }
 
+// ─── Agent sessions (Settings → Relays) ──────────────────────────────────────
+// `{ enabled, maxWaitSeconds, limits, maxActiveSessions }`, with `ok` and
+// `status` as above. A relay without the feature answers 404, which the
+// section reads as "do not show me", so the status has to travel with the
+// answer instead of apiFetch's bare null.
+
+export async function loadAgentSessionsSettings() {
+  return remoteRelayRequest('/api/settings/agent-sessions');
+}
+
+export async function updateAgentSessionsSettings(patch = {}) {
+  const body = {};
+  if (typeof patch.enabled === 'boolean') body.enabled = patch.enabled;
+  if (Number.isFinite(patch.maxWaitSeconds)) body.maxWaitSeconds = patch.maxWaitSeconds;
+  return remoteRelayRequest('/api/settings/agent-sessions', { method: 'POST', body });
+}
+
 export async function loadUpdateState() {
   return apiFetch('/api/update/state');
 }
@@ -607,8 +685,18 @@ export async function relaunchSessionWorkerWithWorkspaceRoot(conversationId, roo
   });
 }
 
-export async function loadUsageSummary() {
-  return apiFetch('/api/usage');
+export async function loadUsageSummary({ providers = null } = {}) {
+  // The conversation the modal was opened from: the Claude Cloud card shows
+  // that conversation's own cost next to the totals. `providers` names the
+  // cards to read live (the rest come from the relay's last live answer);
+  // none means everything live.
+  const conversationId = String(currentConvId || '').trim();
+  const query = new URLSearchParams();
+  if (conversationId) query.set('conversationId', conversationId);
+  const ids = (Array.isArray(providers) ? providers : []).map((id) => String(id || '').trim()).filter(Boolean);
+  if (ids.length) query.set('providers', ids.join(','));
+  const text = query.toString();
+  return apiFetch(text ? `/api/usage?${text}` : '/api/usage');
 }
 
 export async function loadCursorAllowanceSettings() {
@@ -690,8 +778,9 @@ export async function loadConversations(options = {}) {
   if (beforeConversationId) params.set('beforeConversationId', beforeConversationId);
   const beforeUpdatedAt = String(options.beforeUpdatedAt || '').trim();
   if (beforeUpdatedAt) params.set('beforeUpdatedAt', beforeUpdatedAt);
-  const includeArchived = String(options.archived || '').trim().toLowerCase();
-  if (includeArchived === 'true') params.set('archived', 'true');
+  // 'true' lists live and archived chats, 'only' the archived ones.
+  const archivedMode = String(options.archived || '').trim().toLowerCase();
+  if (archivedMode === 'true' || archivedMode === 'only') params.set('archived', archivedMode);
   const query = params.toString();
   return apiFetch(`/api/conversations${query ? `?${query}` : ''}`);
 }
@@ -743,6 +832,39 @@ export async function searchMessages(options = {}) {
 // Raw fetch instead of apiFetch: a refused delete (the conversation is still
 // working, or its session would not stop) must surface the server's reason.
 // The long timeout covers stopping the session and deleting its CLI session.
+// Archive and unarchive answer `{ ok }`, or `{ ok: false, message }` when the
+// relay refuses (a chat still working on a reply is not archived).
+export async function archiveConversation(id) {
+  const convId = String(id || '').trim();
+  if (!convId) return null;
+  return conversationActionRequest(`/api/conversation/${encodeURIComponent(convId)}/archive`);
+}
+
+export async function unarchiveConversation(id) {
+  const convId = String(id || '').trim();
+  if (!convId) return null;
+  return conversationActionRequest(`/api/conversation/${encodeURIComponent(convId)}/unarchive`);
+}
+
+async function conversationActionRequest(url) {
+  if (!areNetworkRequestsEnabled()) return null;
+  try {
+    const response = await fetch(`${BASE}${url}`, {
+      signal: requestTimeoutSignal(LONG_REQUEST_TIMEOUT_MS),
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+      body: '{}',
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) return { ...(payload || {}), ok: false, status: response.status };
+    noteFetchSuccess();
+    return payload || { ok: true };
+  } catch (error) {
+    noteFetchFailure(url, error);
+    return null;
+  }
+}
+
 export async function deleteConversation(id) {
   const convId = String(id || '').trim();
   if (!convId || !areNetworkRequestsEnabled()) return null;
@@ -785,6 +907,23 @@ export async function updateConversationTitle(id, title) {
   });
 }
 
+// The commit attribution a repo folder's Claude sessions use (null = the
+// provider setting). Keyed by the workspace root path.
+export async function loadWorkspaceRootAttribution(path) {
+  const root = String(path || '').trim();
+  if (!root) return null;
+  return apiFetch(`/api/workspace-root/attribution?path=${encodeURIComponent(root)}`);
+}
+
+export async function updateWorkspaceRootAttribution(path, attributionMode) {
+  const root = String(path || '').trim();
+  if (!root) return null;
+  return apiFetch('/api/workspace-root/attribution', {
+    method: 'POST',
+    body: JSON.stringify({ path: root, attributionMode: attributionMode || null }),
+  });
+}
+
 export async function updateConversationPreferences(id, preferences = {}) {
   const convId = String(id || '').trim();
   if (!convId) return null;
@@ -972,6 +1111,20 @@ export async function cancelHostSuspend(body = {}) {
   });
 }
 
+export async function resumeUsageLimitPause(conversationId) {
+  return apiFetch('/api/usage-limit/resume', {
+    method: 'POST',
+    body: JSON.stringify({ conversationId }),
+  });
+}
+
+export async function cancelUsageLimitPause(conversationId) {
+  return apiFetch('/api/usage-limit/cancel', {
+    method: 'POST',
+    body: JSON.stringify({ conversationId }),
+  });
+}
+
 export async function cancelRelayRestart(body = {}) {
   return apiFetch('/api/relay/shutdown/cancel', {
     method: 'POST',
@@ -1091,8 +1244,9 @@ export async function answerRelayQuestionStructured(questionId, structuredAnswer
   }
 }
 
-export async function loadRelayBoards(status = 'pending') {
-  return apiFetch(`/api/relay-boards?status=${encodeURIComponent(status)}`);
+export async function loadRelayBoards(status = 'pending', conversationId = '') {
+  const conversation = String(conversationId || '').trim();
+  return apiFetch(`/api/relay-boards?status=${encodeURIComponent(status)}${conversation ? `&conversationId=${encodeURIComponent(conversation)}` : ''}`);
 }
 
 export async function loadRelayBoard(boardId) {

package/server/public/app/attachments-view.js

@@ -13,6 +13,7 @@ import {
   showTransientRelayNotice,
   getConversationCurrentWorkspaceRootPath,
   IS_SHARED_VIEW,
+  conversations,
 } from './store.js';
 import { openAnnotateEditor } from './annotate-editor.js';
 import {
@@ -61,6 +62,11 @@ import {
   writeRepoBrowserHiddenPreference,
 } from './repo-browser-preferences.mjs';
 import { joinLaunchCwdPath } from './launch-cwd-path.mjs';
+import {
+  cloudAttachmentRejectionNotice,
+  isClaudeCloudConversation,
+  partitionCloudAttachments,
+} from './claude-cloud-ui.mjs';
 
 function currentConversationId() {
   return String(currentConvId || '').trim();
@@ -509,7 +515,7 @@ export async function ingestFiles(files, { source = 'picker' } = {}) {
   // conversations, and the result must never land in the wrong composer.
   const ownerConversationId = currentConversationId();
   const now = new Date();
-  const prepared = [];
+  let prepared = [];
   for (let index = 0; index < inputFiles.length; index += 1) {
     prepared.push(await prepareIncomingFile(inputFiles[index], { source, now, index }));
   }
@@ -519,6 +525,19 @@ export async function ingestFiles(files, { source = 'picker' } = {}) {
     return [];
   }
 
+  // A Claude Cloud session takes inline images only; anything else would be
+  // refused by its worker with the whole turn. Checked after the re-encode
+  // above, which is what brings a large photo under the size limit.
+  if (isClaudeCloudConversation(conversations[ownerConversationId])) {
+    const { accepted, rejected } = partitionCloudAttachments(prepared);
+    if (rejected.length) {
+      for (const { attachment } of rejected) releaseAttachmentPreviewUrl(attachment);
+      showTransientRelayNotice(cloudAttachmentRejectionNotice(rejected), 7000);
+      prepared = accepted;
+      if (!prepared.length) return [];
+    }
+  }
+
   const plan = planAttachmentMerge(selectedAttachments, prepared, MAX_UPLOAD_ATTACHMENTS);
   const rejected = prepared.filter((item) => !plan.acceptedAdditions.includes(item));
   for (const item of rejected) {

package/server/public/app/attribution-control.mjs

@@ -0,0 +1,46 @@
+// The commit-attribution row of the 🧠 context modal (Claude sessions only):
+// what this repo folder's commits say, and a select to override the provider
+// setting for the folder — the payload comes from /api/context (`attribution`).
+
+const MODE_LABELS = Object.freeze({
+  oar: 'OAR — Open Agent Relay (model)',
+  vanilla: 'Vanilla — Claude Code\'s own',
+  off: 'Off — none',
+});
+
+function esc(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+export function attributionEffectText({ effectiveMode, attributionExample } = {}) {
+  if (effectiveMode === 'vanilla') return 'Commits keep Claude Code\'s own attribution.';
+  if (effectiveMode === 'off') return 'Commits and pull requests carry no attribution line.';
+  const trailer = String(attributionExample || '').trim();
+  return trailer ? `Commits end with: ${trailer}` : 'Commits end with the Open Agent Relay trailer.';
+}
+
+/**
+ * @param {object|null} attribution the `attribution` field of an /api/context response
+ * @returns {string} the row's HTML, or '' when the payload has no folder to speak of
+ */
+export function renderAttributionControlHtml(attribution) {
+  if (!attribution || typeof attribution !== 'object') return '';
+  const path = String(attribution.path || '').trim();
+  if (!path) return '';
+  const folderMode = ['oar', 'vanilla', 'off'].includes(attribution.attributionMode) ? attribution.attributionMode : '';
+  const providerMode = ['oar', 'vanilla', 'off'].includes(attribution.providerMode) ? attribution.providerMode : 'oar';
+  const options = [
+    `<option value=""${folderMode === '' ? ' selected' : ''}>Inherit (provider: ${esc(MODE_LABELS[providerMode].split(' — ')[0])})</option>`,
+    ...['oar', 'vanilla', 'off'].map((mode) => `<option value="${mode}"${folderMode === mode ? ' selected' : ''}>${esc(MODE_LABELS[mode])}</option>`),
+  ].join('');
+  return `
+    <div class="ctx-attribution" data-workspace-root="${esc(path)}">
+      <div class="ctx-attribution-row">
+        <span class="ctx-attribution-label">Commit attribution:</span>
+        <select id="ctx-attribution-select" class="ctx-attribution-select" aria-label="Commit attribution for this folder" data-workspace-root="${esc(path)}">${options}</select>
+      </div>
+      <div class="ctx-attribution-note">For every Claude session in <code>${esc(path)}</code>. ${esc(attributionEffectText(attribution))} A change reaches running sessions with their next message.</div>
+    </div>
+  `;
+}