synabun 1.3.0 → 2.0.0

package/neural-interface/public/shared/automation-context.js

@@ -0,0 +1,75 @@
+// Model ids and context choices are separate in automation settings. Decode the
+// older selector formats at the boundary so they never reach a provider.
+const CLAUDE_ONE_M = /\[1m\]$/i;
+const CODEX_EXTENDED = /\[extended\]$/i;
+const NUMERIC_SUFFIX = /^(.+):(\d+)$/;
+
+export function normalizeAutomationSelection(profile, model, contextMode = null) {
+  let id = String(model || '').trim();
+  let mode = contextMode == null || contextMode === '' ? null : String(contextMode);
+  const isCodex = profile === 'codex' || (!profile && /^(?:gpt-|codex-|chat-latest)/i.test(id));
+  const isClaude = profile === 'claude-code' || (!profile && /^(?:claude-|opus|sonnet|haiku|default(?:\[1m\])?$)/i.test(id));
+  if (isCodex && CODEX_EXTENDED.test(id)) {
+    id = id.replace(CODEX_EXTENDED, '');
+    mode ??= 'extended';
+  } else if (isClaude && CLAUDE_ONE_M.test(id)) {
+    id = id.replace(CLAUDE_ONE_M, '');
+    mode ??= '1m';
+  } else if ((isCodex || isClaude) && NUMERIC_SUFFIX.test(id)) {
+    const [, base, size] = id.match(NUMERIC_SUFFIX);
+    id = base;
+    mode ??= isClaude && Number(size) > 200000 ? '1m' : 'default';
+  }
+  return { model: id || null, contextMode: mode };
+}
+
+export function validAutomationContextMode(profile, mode) {
+  if (mode == null || mode === '') return true;
+  if (mode === 'default') return true;
+  return profile === 'codex' ? mode === 'extended'
+    : profile === 'claude-code' ? mode === '1m' : false;
+}
+
+export function resolveAutomationOverrides(schedule = {}, group = {}, template = {}) {
+  return {
+    profile: schedule.profile || group?.profile || template?.profile || 'claude-code',
+    model: schedule.model || group?.model || template?.model || null,
+    contextMode: schedule.contextMode || group?.contextMode || template?.contextMode || null,
+    codexAccountId: schedule.codexAccountId || group?.codexAccountId || template?.codexAccountId || 'default',
+  };
+}
+
+export function contextSizeLabel(size) {
+  const n = Number(size);
+  if (!Number.isFinite(n) || n <= 0) return '';
+  return n >= 1000000 ? `${Number((n / 1000000).toFixed(2))}M` : `${Math.round(n / 1000)}K`;
+}
+
+export function automationModelOptions(profile, models = []) {
+  if (profile !== 'claude-code') return models;
+  return models.filter((model) => !CLAUDE_ONE_M.test(String(model?.id || '')));
+}
+
+// Mirrors the Assistant catalog's Claude eligibility rule. The installed CLI
+// often omits [1m] rows even though it accepts the suffix for these families.
+export function claudeAutomationSupportsOneMillion(model) {
+  if (!model || model.id === 'default' || model.catalogSource === 'fallback') return false;
+  const id = String(model.resolvedModel || model.id || '').toLowerCase();
+  if (!/(opus|sonnet|fable)/.test(id)) return false;
+  return !/(haiku|claude-3|opus-4-[0-5](?:-|$)|opus-4-\d{8}|opus-4$)/.test(id);
+}
+
+export function automationContextOptions(profile, modelId, models = []) {
+  const id = normalizeAutomationSelection(profile, modelId).model;
+  const model = models.find((entry) => entry?.id === id);
+  const baseSize = contextSizeLabel(model?.contextWindow);
+  const options = [{ id: 'default', label: baseSize ? `Default (${baseSize})` : 'Provider default' }];
+  if (profile === 'codex' && model?.supportsExtendedContext === true
+    && Number(model.maxContextWindow) > Number(model.contextWindow)) {
+    options.push({ id: 'extended', label: `Extended (${contextSizeLabel(model.maxContextWindow)})` });
+  } else if (profile === 'claude-code'
+    && (models.some((entry) => entry?.id === `${id}[1m]`) || claudeAutomationSupportsOneMillion(model))) {
+    options.push({ id: '1m', label: '1M' });
+  }
+  return options;
+}

package/neural-interface/public/shared/blob-store.js

@@ -0,0 +1,99 @@
+// ═══════════════════════════════════════════
+// BLOB STORE — Per-entry server storage for fat state
+// ═══════════════════════════════════════════
+//
+// Companion to storage.js for values too large for the ui-state PATCH cycle
+// (rendered transcript snapshots, graph node positions). Each entry persists
+// individually — a streaming session uploads only its own snapshot, not the
+// whole multi-MB map. Server side: /api/ui-blobs/:ns/:id (lib/ui-blob-store.js).
+
+const _putTimers = new Map();   // `${ns}/${id}` -> timeout id
+const _pendingPuts = new Map(); // `${ns}/${id}` -> { ns, id, value, opts }
+const DEFAULT_DEBOUNCE_MS = 500;
+
+export async function fetchBlobNamespace(ns) {
+  try {
+    const res = await fetch(`/api/ui-blobs/${encodeURIComponent(ns)}`);
+    if (!res.ok) return {};
+    const data = await res.json();
+    return (data && typeof data === 'object' && !Array.isArray(data)) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+async function _sendPut(key) {
+  const pending = _pendingPuts.get(key);
+  if (!pending) return;
+  _pendingPuts.delete(key);
+  _putTimers.delete(key);
+  const { ns, id, value, opts } = pending;
+  const params = new URLSearchParams();
+  if (opts.maxEntries) params.set('maxEntries', String(opts.maxEntries));
+  if (opts.maxChars) params.set('maxChars', String(opts.maxChars));
+  const qs = params.toString();
+  try {
+    const res = await fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}${qs ? '?' + qs : ''}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(value),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  } catch (err) {
+    console.warn(`[blob-store] PUT ${ns}/${id} failed:`, err.message, '— will retry');
+    // Re-queue unless a newer value superseded this one while in flight.
+    if (!_pendingPuts.has(key)) {
+      _pendingPuts.set(key, pending);
+      _putTimers.set(key, setTimeout(() => _sendPut(key), 2000));
+    }
+  }
+}
+
+// Debounced per-(ns,id), latest value wins.
+export function putBlob(ns, id, value, opts = {}) {
+  const key = `${ns}/${id}`;
+  const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  _pendingPuts.set(key, { ns, id, value, opts });
+  if (_putTimers.has(key)) clearTimeout(_putTimers.get(key));
+  _putTimers.set(key, setTimeout(() => _sendPut(key), debounceMs));
+}
+
+export function deleteBlob(ns, id) {
+  const key = `${ns}/${id}`;
+  if (_putTimers.has(key)) { clearTimeout(_putTimers.get(key)); _putTimers.delete(key); }
+  _pendingPuts.delete(key);
+  fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`, { method: 'DELETE' })
+    .catch(() => {});
+}
+
+// Flush all pending puts immediately. With useBeacon (pagehide path), bodies
+// under ~60KB go via sendBeacon (survives unload); larger ones use a best-
+// effort fetch — the last debounced PUT was at most a debounce window ago, so
+// little is lost if it doesn't complete.
+export function flushBlobs({ useBeacon = false } = {}) {
+  for (const [key, pending] of [..._pendingPuts.entries()]) {
+    if (_putTimers.has(key)) { clearTimeout(_putTimers.get(key)); _putTimers.delete(key); }
+    if (useBeacon) {
+      const { ns, id, value } = pending;
+      const body = JSON.stringify(value);
+      _pendingPuts.delete(key);
+      if (body.length < 60_000) {
+        navigator.sendBeacon(
+          `/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`,
+          new Blob([body], { type: 'application/json' })
+        );
+      } else {
+        fetch(`/api/ui-blobs/${encodeURIComponent(ns)}/${encodeURIComponent(id)}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body,
+          keepalive: body.length < 640_000, // keepalive caps at ~64KB-1MB per spec/impl
+        }).catch(() => {});
+      }
+    } else {
+      _sendPut(key);
+    }
+  }
+}
+
+window.addEventListener('pagehide', () => flushBlobs({ useBeacon: true }));

package/neural-interface/public/shared/cdx/cdx-capabilities.js

@@ -0,0 +1,118 @@
+// What the Codex runtime of one tab supports. The answer belongs to the tab's
+// account and connection (its epoch). An invalidation only marks it stale: the
+// last answer stays readable until the re-read lands, so nothing judges support
+// from an empty cache. DOM-free; the socket request is injected.
+import { capabilityAvailability } from './cdx-commands.js';
+
+// A runtime older than capabilities_read answers it with one of these.
+const UNSUPPORTED_READ = /unsupported|unknown|not found|method/i;
+
+const states = new WeakMap();
+
+function stateOf(tab) {
+  let state = states.get(tab);
+  if (!state) {
+    state = { stale: false, read: null };
+    states.set(tab, state);
+  }
+  return state;
+}
+
+export function codexCapabilityEpoch(tab) {
+  return `${tab?.accountId || 'default'}:${tab?.connectionEpoch || ''}`;
+}
+
+/** The last capabilities advertised for the tab's current epoch, fresh or stale. Another epoch's are never returned. */
+export function knownCodexCapabilities(tab) {
+  if (!tab?.codexCapabilities || tab.codexCapabilitiesEpoch !== codexCapabilityEpoch(tab)) return null;
+  return tab.codexCapabilities;
+}
+
+/** An answer from the runtime (ready packet, push or read) for the tab's current epoch. */
+export function storeCodexCapabilities(tab, capabilities, runtime) {
+  if (!tab) return null;
+  tab.codexCapabilities = capabilities || {};
+  if (runtime !== undefined) tab.codexRuntime = runtime || {};
+  tab.codexCapabilitiesEpoch = codexCapabilityEpoch(tab);
+  stateOf(tab).stale = false;
+  return tab.codexCapabilities;
+}
+
+/** The epoch changed (new connection, other account): the old answer must not be reused. */
+export function dropCodexCapabilities(tab) {
+  if (!tab) return;
+  tab.codexCapabilities = null;
+  tab.codexCapabilitiesEpoch = '';
+  stateOf(tab).stale = true;
+}
+
+/** Something happened that may change support. The last answer stays usable until the next read replaces it. */
+export function invalidateCodexCapabilities(tab) {
+  if (!tab) return;
+  if (tab.codexCapabilities && !knownCodexCapabilities(tab)) {
+    dropCodexCapabilities(tab);
+    return;
+  }
+  stateOf(tab).stale = true;
+}
+
+/**
+ * The capabilities current for the tab. A fresh answer resolves at once; a
+ * stale or missing one is re-read through `read()`, and every caller that
+ * arrives while that read is pending shares it. The socket delivers in order,
+ * so an answer that lands after an invalidation is newer than its cause: a
+ * storm of invalidations during one read costs no second read.
+ */
+export function currentCodexCapabilities(tab, read) {
+  const state = stateOf(tab);
+  const epoch = codexCapabilityEpoch(tab);
+  const known = knownCodexCapabilities(tab);
+  if (known && !state.stale) return Promise.resolve(known);
+  if (state.read?.epoch === epoch) return state.read.promise;
+  const pending = { epoch, promise: null };
+  pending.promise = (async () => {
+    try {
+      let result;
+      try {
+        result = await read();
+      } catch (error) {
+        if (codexCapabilityEpoch(tab) !== epoch) return currentCodexCapabilities(tab, read);
+        // The bridge enforces support on every request, so the last answer is
+        // still the best one to show while the read cannot be made.
+        const last = knownCodexCapabilities(tab);
+        if (last) return last;
+        if (!UNSUPPORTED_READ.test(error?.message || '')) throw error;
+        result = { capabilities: {} };
+      }
+      // The tab moved on while the read was out: this answer is another epoch's.
+      if (codexCapabilityEpoch(tab) !== epoch) return currentCodexCapabilities(tab, read);
+      return storeCodexCapabilities(tab, result?.capabilities, result?.runtime || {});
+    } finally {
+      if (state.read === pending) state.read = null;
+    }
+  })();
+  state.read = pending;
+  return pending.promise;
+}
+
+/**
+ * One capability-gated request. `capabilities()` resolves the tab's current
+ * capabilities, `changed()` returns why the tab is no longer the conversation
+ * the caller opened (asked again after the wait), `send()` makes the request.
+ */
+export async function requestWithCodexCapability({ type, capabilities, changed, send }) {
+  const before = changed?.();
+  if (before) throw new Error(before);
+  let current = null;
+  try {
+    current = await capabilities();
+  } catch (error) {
+    // Unreadable capabilities: only the actions every bridge has may go out.
+    if (!capabilityAvailability(null, type).supported) throw error;
+  }
+  const after = changed?.();
+  if (after) throw new Error(after);
+  const availability = capabilityAvailability(current, type);
+  if (!availability.supported) throw new Error(availability.reason || 'Unavailable in this runtime.');
+  return send();
+}

package/neural-interface/public/shared/cdx/cdx-cards.js

@@ -0,0 +1,37 @@
+// Shared expansion behavior for live and snapshot-restored transcript cards.
+const bindings = new WeakMap();
+const interactive = 'button, input, select, textarea, a, summary, [role="button"], [contenteditable]:not([contenteditable="false"])';
+
+export function setCardExpanded(card, expanded) {
+  if (!card) return;
+  const next = !!expanded;
+  card.classList.toggle('cxp-collapsed', !next);
+  card.dataset.expanded = next ? '1' : '0';
+  const head = card.querySelector(':scope > .cxp-card-head');
+  if (head?.getAttribute('role') === 'button') head.setAttribute('aria-expanded', String(next));
+}
+
+export function bindExpandableCard(card, onToggle = () => {}) {
+  const head = card?.querySelector(':scope > .cxp-card-head');
+  if (!head || !card.querySelector(':scope > .cxp-card-body') || !head.querySelector('.cxp-card-chevron')) return;
+  head.tabIndex = 0;
+  head.setAttribute('role', 'button');
+  setCardExpanded(card, !card.classList.contains('cxp-collapsed'));
+  // Rebinding after streaming updates refreshes the callback, never the listeners.
+  if (bindings.has(head)) { bindings.set(head, onToggle); return; }
+  bindings.set(head, onToggle);
+  const activate = (event) => {
+    const control = event.target.closest(interactive);
+    if (control && control !== head) return;
+    if (event.type === 'keydown') {
+      if (event.key !== 'Enter' && event.key !== ' ') return;
+      event.preventDefault(); // Space must not scroll; held keys toggle only once.
+      if (event.repeat) return;
+    }
+    const expanded = card.classList.contains('cxp-collapsed');
+    setCardExpanded(card, expanded);
+    bindings.get(head)(card, expanded);
+  };
+  head.addEventListener('click', activate);
+  head.addEventListener('keydown', activate);
+}

package/neural-interface/public/shared/cdx/cdx-commands.js

@@ -0,0 +1,171 @@
+// Shared command metadata for dispatch, composer hints and feature menus.
+const definitions = [
+  ['agent', 'Open loaded agent threads', 'thread_loaded_list'],
+  ['apps', 'Search apps and inspect available tools', 'app_list'],
+  ['attachments', 'Inspect thread attachments', 'attachment_list'],
+  ['archive', 'Archive the current thread', 'thread_archive'],
+  ['clean', 'Stop all background terminals', 'background_clean'],
+  ['clear', 'Start a fresh conversation'],
+  ['compact', 'Compact thread context'],
+  ['copy', 'Copy the latest completed response'],
+  ['debug-config', 'Show effective config and restrictions', 'config_read'],
+  ['diff', 'Show the Git diff'],
+  ['effort', 'Choose reasoning effort', null, true],
+  ['experimental', 'Inspect experimental features', 'experimental_features'],
+  ['fast', 'Toggle Fast mode for supported models', 'config_read'],
+  ['feedback', 'Preview and send feedback', 'feedback_upload'],
+  ['fork', 'Fork the current thread', 'thread_fork'],
+  ['goal', 'Inspect or update the thread goal', 'goal_get'],
+  ['help', 'Show all sidepanel commands'],
+  ['hooks', 'Inspect configured hooks', 'hooks_list'],
+  ['init', 'Create or update AGENTS.md guidance', null, true],
+  ['logout', 'Sign out of Codex', 'account_logout'],
+  ['mcp', 'Search MCP servers and tools', 'mcp_status'],
+  ['mention', 'Add a structured file mention', null, true],
+  ['model', 'Choose model'],
+  ['new', 'Start a fresh conversation'],
+  ['permissions', 'Update approvals and sandboxing', 'config_read'],
+  ['personality', 'Set the active personality', 'config_read', true],
+  ['plan', 'Enable Plan mode or send a planning prompt', null, true],
+  ['plugins', 'Inspect plugin availability', 'plugin_list'],
+  ['ps', 'Inspect native background terminals', 'background_list'],
+  ['queue', 'Show queued messages'],
+  ['rename', 'Rename the current thread', 'thread_rename', true],
+  ['resume', 'Search and resume conversations'],
+  ['review', 'Choose working tree, branch, commit or custom review', 'review_start'],
+  ['settings', 'Open Codex settings'],
+  ['skills', 'Search native skills and manage enablement', 'skills_list'],
+  ['status', 'Show account, runtime and session status', 'status_snapshot'],
+  ['stop', 'Stop one or all background terminals', 'background_clean', true],
+  ['unarchive', 'Restore an archived thread by ID', 'thread_unarchive', true],
+];
+
+export const CODEX_COMMANDS = Object.freeze(definitions.map(([name, desc, capability, acceptsArgs = false]) => (
+  Object.freeze({ name, cmd: `/${name}`, desc, capability: capability || null, acceptsArgs })
+)));
+export const CODEX_COMMAND_BY_NAME = new Map(CODEX_COMMANDS.map((entry) => [entry.name, entry]));
+
+const LEGACY_ACTIONS = new Set([
+  'thread_list', 'thread_resume', 'thread_start', 'thread_rename', 'thread_fork',
+  'thread_archive', 'thread_unarchive', 'thread_loaded_list', 'review_start',
+  'account_read', 'account_logout', 'codex_login', 'rate_limits_read', 'status_snapshot',
+  'config_read', 'config_write', 'config_requirements', 'model_list',
+  'mcp_status', 'mcp_refresh', 'mcp_oauth_login', 'mcp_approval_set',
+  'permission_roots_list', 'permission_root_remove', 'skills_list', 'app_list',
+  'experimental_features', 'background_clean',
+]);
+
+export function parseCodexCommand(text) {
+  const raw = String(text || '').trim();
+  const match = raw.match(/^\/([A-Za-z0-9_-]+)(?:\s+([\s\S]*))?$/);
+  return match ? { name: match[1].toLowerCase(), args: String(match[2] || '').trim(), raw } : null;
+}
+
+export function capabilityAvailability(capabilities, name) {
+  if (!name) return { supported: true, experimental: false, reason: '' };
+  const value = capabilities?.[name];
+  // Only pre-existing bridge actions remain usable without runtime metadata.
+  // New methods must be explicitly advertised before the UI offers them.
+  if (value) return { ...value, supported: value.supported === true };
+  return LEGACY_ACTIONS.has(name)
+    ? { supported: true, experimental: false, reason: '' }
+    : { supported: false, experimental: false, reason: name.startsWith('plugin_') ? 'Plugin controls are under development and unavailable in this client.' : 'This runtime has not advertised support for this feature.' };
+}
+
+export function codexCommandHints(capabilities = {}) {
+  return CODEX_COMMANDS.map((entry) => {
+    const state = capabilityAvailability(capabilities, entry.capability);
+    return { ...entry, available: state.supported, desc: `${entry.desc}${state.experimental ? ' · Experimental' : ''}${state.supported ? '' : ` · Unavailable: ${state.reason || 'unsupported by this runtime'}`}` };
+  });
+}
+
+export function latestCompletedCodexText(items) {
+  const states = Array.from(items?.values?.() || items || []);
+  for (let i = states.length - 1; i >= 0; i -= 1) {
+    const state = states[i];
+    if (!state || !['agentMessage', 'plan'].includes(state.type)) continue;
+    if (!(state.completed === true || ['completed', 'complete'].includes(state.status))) continue;
+    const text = String(state.buffer ?? state.text ?? '').trim();
+    if (text) return text;
+  }
+  return '';
+}
+
+export function reviewTarget(type, value = '') {
+  const text = String(value).trim();
+  if (type === 'uncommittedChanges') return { type };
+  if (!text) throw new Error('Enter a branch, commit or review instructions.');
+  if (type === 'baseBranch') return { type, branch: text };
+  if (type === 'commit') return { type, sha: text };
+  if (type === 'custom') return { type, instructions: text };
+  throw new Error('Unknown review target.');
+}
+
+export function configValue(config, key) {
+  if (Object.hasOwn(config || {}, key)) return config[key];
+  return key.split('.').reduce((value, part) => value?.[part], config);
+}
+
+export function configRestriction(requirements, key) {
+  const req = requirements?.requirements?.requirements || requirements?.requirements || requirements || {};
+  const fields = { approval_policy: 'allowedApprovalPolicies', sandbox_mode: 'allowedSandboxModes', web_search: 'allowedWebSearchModes' };
+  if (fields[key] && Array.isArray(req[fields[key]])) return { allowed: req[fields[key]], reason: 'Managed configuration restriction' };
+  if (key.startsWith('features.') && Object.hasOwn(req.featureRequirements || {}, key.slice(9))) {
+    return { fixed: req.featureRequirements[key.slice(9)], reason: 'Required by managed configuration' };
+  }
+  return {};
+}
+
+export function serializeConfigInput(def, input) {
+  if (input.dataset?.originalValue) {
+    const original = JSON.parse(input.dataset.originalValue);
+    if (input.value === (typeof original === 'object' ? JSON.stringify(original) : String(original))) return original;
+  }
+  if (def.type === 'checkbox') return input.checked;
+  if (def.type === 'number') {
+    if (!input.value) return null;
+    const number = Number(input.value);
+    if (!Number.isSafeInteger(number) || number < 1) throw new Error(`${def.label} must be a positive whole number.`);
+    return number;
+  }
+  return input.value || null;
+}
+
+export function configChanges(definitions, inputs, original) {
+  const changed = {};
+  for (const def of definitions) {
+    const input = inputs[def.key];
+    if (!input || input.disabled) continue;
+    const value = serializeConfigInput(def, input);
+    const before = configValue(original, def.key);
+    if (JSON.stringify(value) !== JSON.stringify(before ?? (def.type === 'checkbox' ? false : null))) changed[def.key] = value;
+  }
+  return changed;
+}
+
+export const SESSION_CONFIG_FIELDS = Object.freeze({
+  model: 'model', model_reasoning_effort: 'effort', model_reasoning_summary: 'summary',
+  personality: 'personality', service_tier: 'serviceTier', approval_policy: 'approvalPolicy',
+});
+
+export function sessionSettings(config) {
+  return Object.fromEntries(Object.entries(config).filter(([key]) => SESSION_CONFIG_FIELDS[key]).map(([key, value]) => [SESSION_CONFIG_FIELDS[key], value]));
+}
+
+export function modelServiceTiers(model) {
+  const tiers = Array.isArray(model?.serviceTiers) && model.serviceTiers.length
+    ? model.serviceTiers
+    : (model?.additionalSpeedTiers || []).map((id) => ({ id, name: id }));
+  return tiers.filter((tier) => tier?.id).map((tier) => ({ value: tier.id, label: tier.name || tier.id }));
+}
+
+export function fastServiceTier(model) {
+  return modelServiceTiers(model).find((tier) => /^(fast|priority)$/i.test(tier.value) || /^fast(?:\s|$)/i.test(tier.label))?.value || null;
+}
+
+export function flattenNativeCatalog(result, kind) {
+  const value = result?.[kind] ?? result ?? {};
+  const entries = Array.isArray(value) ? value : (value.data || value[kind] || []);
+  if (kind === 'skills' || kind === 'hooks') return entries.flatMap((entry) => entry[kind] || (entry.name || entry.key ? [entry] : []));
+  return entries;
+}