synabun 2.0.10 → 2.2.0

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

@@ -1,3 +1,6 @@
+import { answerWorkerQuestion } from '../worker-questions.js';
+import { cxpText, cxpSessionLabel } from './cdx-copy.js';
+import { codexWantsRolloutPreview, rolloutPreviewApplies } from './cdx-preview.js';
 import { mountCodexSettings } from './cdx-settings.js';
 import { t } from '../i18n.js';
 import { getCliState, isCliInstalling } from '../cli-status.js';
@@ -13,8 +16,8 @@ import { accountName, accountSummary, accountSwitchPlan, accountText, serverAcco
 import { mountAccountMenu } from '../account-menu.js';
 import '../account-i18n.js';
 import { restoreMcpAppCards, teardownMcpApps, retireMcpAppNode, stripMcpAppRuntime } from './cdx-mcp-app-host.js';
-import { renderTurnDiff, completeTurnOutputs } from './cdx-render.js';
-import { hydrateOutputControls } from './cdx-output.js';
+import { renderTurnDiff, completeTurnOutputs, clearMarkdownCache } from './cdx-render.js';
+import { hydrateOutputControls, disposeOutputBlocks } from './cdx-output.js';
 import { sanitizeStoredHtml } from '../assistant/asst-sanitize.js';
 import {
   beginPlanTurn, capturePlanItem, finishPlanTurn, getPlanMarkdown, syncPlanMirrors, recordPlanTurn,
@@ -31,6 +34,7 @@ import {
 } from '../agent-runtime-options.js';
 import { CodexModelCatalog, codexModelAccountKey, codexContextAvailability } from './cdx-model-catalog.js';
 import { nativeLoopWindowId } from '../ui-native-window-id.js';
+import { skillHintEntries, skillsForPrompt, skillsListRequest } from './cdx-skill-hints.js';
 import { syncSidepanelLayout, focusSidepanel, isHostedSessionFocused } from '../ui-sidepanel-windows.js';
 import { notify, NOTIF_TYPE } from '../ui-notifications.js';
 import { createStickyScrollController } from '../ui-scroll-follow.js';
@@ -203,6 +207,13 @@ function autosizeInput() { _onAutosizeInput?.(); }
 function emit(...args) { _onEmit?.(...args); }
 
 function sendSocket(msg) {
+  if (_boundTab?.automationRunId && msg?.type === 'server_request_response') {
+    const tab = _boundTab;
+    answerWorkerQuestion(tab.automationRunId, msg.requestId, { behavior: msg.error || ['cancel', 'decline'].includes(msg.result?.action) || ['cancel', 'decline'].includes(msg.result?.decision) ? 'deny' : 'allow', result: msg.result, error: msg.error })
+      .then((result) => withTab(tab, () => handleServerRequestResponseResult({ responseToken: msg.responseToken, ok: true, status: result.stale ? 'stale' : 'answered' })),
+        (error) => withTab(tab, () => handleServerRequestResponseResult({ responseToken: msg.responseToken, ok: false, status: tab._workerQuestions?.has(String(msg.requestId)) ? 'delivery_failed' : 'stale', retryable: true, error: error.message })));
+    return true;
+  }
   const packet = msg && _boundTab?.id
     ? {
         ...msg,
@@ -275,6 +286,16 @@ function closeAutomationHistorySocket(tab) {
   }
 }
 
+// The rollout read before Codex's app-server is up (server.js sendEarlyCodexRolloutPreview): shown only for
+// the thread this tab shows, and only while nothing else (a stored snapshot) is on screen. The real history
+// replaces it.
+function paintRolloutPreview(tab, msg) {
+  const shownThread = String(_boundTab?.threadId || _threadId || '');
+  if (!rolloutPreviewApplies(msg, shownThread, _transcriptSourceType)) return;
+  renderHistory(msg.thread, msg.fallbackItems || null);
+  placeWorkerEnd(tab);
+}
+
 function buildWsCallbacks(tab, options = {}) {
   return {
     onConnecting() {
@@ -298,7 +319,6 @@ function buildWsCallbacks(tab, options = {}) {
           userVerification: true,
           windowId: windowId,
           accountId: _accountId || 'default',
-          mcpProfile: tab.mcpProfile || null,
           ...codexRuntimeSelection(tab),
         });
       } else {
@@ -308,9 +328,10 @@ function buildWsCallbacks(tab, options = {}) {
           userVerification: true,
           windowId: windowId,
           threadId: _threadId || null,
+          // The early rollout preview only for the tab on screen (server.js sendEarlyCodexRolloutPreview).
+          preview: codexWantsRolloutPreview(tab, _boundTab, _threadId),
           cwd: _project || null,
           accountId: _accountId || 'default',
-          mcpProfile: tab.mcpProfile || null,
           ...codexRuntimeSelection(tab),
         });
       }
@@ -369,7 +390,6 @@ function buildWsCallbacks(tab, options = {}) {
           _accountId = msg.accountId;
           if (_boundTab) _boundTab.accountId = _accountId;
         }
-        if (msg.mcpProfile && _boundTab) _boundTab.mcpProfile = msg.mcpProfile;
         // A reattached app-server can still have a different process-active
         // thread. Preserve the tab's displayed thread instead of adopting it.
         _threadId = _threadId || msg.threadId || null;
@@ -395,7 +415,6 @@ function buildWsCallbacks(tab, options = {}) {
           threadId: _threadId || null,
           cwd: _project || null,
           accountId: _accountId || 'default',
-          mcpProfile: tab.mcpProfile || null,
           ...codexRuntimeSelection(tab),
         });
       } else {
@@ -408,7 +427,6 @@ function buildWsCallbacks(tab, options = {}) {
           threadId: _threadId || null,
           cwd: _project || null,
           accountId: _accountId || 'default',
-          mcpProfile: tab.mcpProfile || null,
           ...codexRuntimeSelection(tab),
         });
       }
@@ -426,10 +444,6 @@ function buildWsCallbacks(tab, options = {}) {
       restoreMcpAppCards(_messagesEl, { tab: _boundTab, items: _items, request: requestSocketPayloadForTab, draft: setMcpAppDraft });
       if (_boundTab) _boundTab.bootstrapped = true;
       ensureCodexTerminalAuth(tab);
-      if (msg.mcpProfile && _boundTab) {
-        _boundTab.mcpProfile = msg.mcpProfile;
-        if (activeTab() === _boundTab) _onActiveTabChanged?.(_boundTab);
-      }
       if (Object.prototype.hasOwnProperty.call(msg, 'threadId')) {
         _threadId = msg.threadId || null;
         if (_boundTab) _boundTab.threadId = _threadId;
@@ -457,6 +471,7 @@ function buildWsCallbacks(tab, options = {}) {
       // which rebuilds the transcript: they go back onto it afterwards.
       const heldRequests = heldServerRequests();
       if (msg.thread) {
+        if (msg.preview) { paintRolloutPreview(tab, msg); return; }
         if (_boundTab) {
           _boundTab.expectedThreadId = null;
           _boundTab.expectedThreadRequestId = null;
@@ -694,11 +709,6 @@ function buildWsCallbacks(tab, options = {}) {
         }
         renderStatusChrome();
       }
-      if (msg.type === 'mcp_profile_changed' && msg.profile) {
-        if (_boundTab) _boundTab.mcpProfile = msg.profile;
-        if (activeTab() === _boundTab) _onActiveTabChanged?.(_boundTab);
-        saveTabs();
-      }
       if (msg.type === 'mcp_approval_updated' && msg.name) {
         const server = _mcpServers.get(msg.name);
         if (server) {
@@ -769,6 +779,7 @@ let _projectThreads = parseStoredJson(STOR.projectThreads, {});
 // async; getThreadSnapshot returns null pre-hydration and renderHistory falls
 // back to SDK/JSONL items.
 let _threadSnapshots = {};
+let _threadSnapshotsHydrated = false;
 const _threadSnapshotsReady = fetchBlobNamespace('codex-snapshots')
   .then((map) => {
     const valid = {};
@@ -784,7 +795,8 @@ const _threadSnapshotsReady = fetchBlobNamespace('codex-snapshots')
     _threadSnapshots = { ...valid, ..._threadSnapshots };
     try { if (storage.getItem(STOR.threadSnapshots)) storage.removeItem(STOR.threadSnapshots); } catch {}
   })
-  .catch(() => {});
+  .catch(() => {})
+  .finally(() => { _threadSnapshotsHydrated = true; });
 let _tabs = [];
 let _activeTabIdx = -1;
 let _boundTab = null;
@@ -848,6 +860,9 @@ let _interruptRetried = false;
 let _prevInputTokens = 0;
 let _skillsCache = null;
 let _skillsPromise = null;
+// A skills:changed arrived since the list was last read: the next skills_list asks the app-server to reload its skills
+// (cdx-skill-hints.js skillsListRequest).
+let _skillsChanged = false;
 let _blockingServerRequests = new Map();
 let _bufferedSocketMessages = [];
 
@@ -1861,14 +1876,19 @@ async function restoreCanonicalPlan(tab, thread) {
 }
 
 // ── Formatting & helpers (lines 1148-1421) ──
+function codexStatusText(status) {
+  const known = {"pending": "pending", "completed": "completed", "complete": "complete", "inProgress": "in progress", "failed": "failed", "declined": "declined"};
+  return Object.hasOwn(known, status) ? cxpText(`status_${status}`, known[status]) : status;
+}
+
 export function formatStatus(status) {
-  if (!status) return 'pending';
-  if (typeof status === 'string') return status;
+  if (!status) return codexStatusText('pending');
+  if (typeof status === 'string') return codexStatusText(status);
   if (typeof status === 'object') {
     const [key, val] = Object.entries(status)[0] || [];
-    if (!key) return 'pending';
-    if (val && typeof val === 'object' && val.message) return `${key}: ${val.message}`;
-    return key;
+    if (!key) return codexStatusText('pending');
+    if (val && typeof val === 'object' && val.message) return `${codexStatusText(key)}: ${val.message}`;
+    return codexStatusText(key);
   }
   return String(status);
 }
@@ -2457,10 +2477,10 @@ export function setSessionLabel(label, { persist = true } = {}) {
   }
   if (isActiveTab(_boundTab)) {
     const labelEl = panelEl('#cxp-session-label');
-    if (labelEl) labelEl.replaceChildren(document.createTextNode(_sessionLabel));
+    if (labelEl) labelEl.replaceChildren(document.createTextNode(cxpSessionLabel(_sessionLabel)));
     // The whole name, for when the header shows only part of it.
     const sessionBtn = panelEl('#cxp-session-btn');
-    if (sessionBtn) sessionBtn.title = _sessionLabel;
+    if (sessionBtn) sessionBtn.title = cxpSessionLabel(_sessionLabel);
     syncLegacyState();
   }
   updateTrayPillLabel();
@@ -2508,6 +2528,11 @@ function scheduleCodexTitleReassert(tab) {
 
 function applyCodexProviderTitle(title) {
   const tab = _boundTab;
+  // Dispatch metadata owns the panel label; reading history must never rename the provider thread.
+  if (tab?.automationRunId) {
+    setSessionLabel(tab.automationTitle || tab.sessionLabel);
+    return;
+  }
   const incoming = normalizeSessionLabel(title || '');
   const desiredTitle = normalizeSessionLabel(tab?.pendingSessionLabel || tab?.sessionLabel || '');
   const authoritative = tab
@@ -2630,6 +2655,9 @@ function disposeDiscardedTab(tab) {
     clearTimeout(tab.snapshotTimer);
     tab.snapshotTimer = null;
   }
+  tab.scrollController?.destroy();
+  tab.scrollController = null;
+  disposeOutputBlocks(tab.messagesEl);
   tab.messagesEl?.remove();
   tab.pillEl?.remove();
 }
@@ -2718,9 +2746,37 @@ export function renderProjects() {
   ddPopulate(projectDropdown, projectItemsForValue(_project), _project);
 }
 
+function paintInitialThreadSnapshot(tab) {
+  if (!tab || tab.closed || !tab.threadId || tab.transcriptSourceType || tab.automationRunId) return false;
+  const expectedThreadId = String(tab.threadId);
+  let painted = false;
+  withTab(tab, () => {
+    const snap = getThreadSnapshot(expectedThreadId);
+    if (!snap) return;
+    painted = renderStoredTranscript(snap, 'Continue this Codex thread or start a fresh one.');
+    if (painted) {
+      updateThreadTokenUsage(tab.threadTokenUsage || snap.threadTokenUsage || null);
+      renderPostPlanActions(tab);
+      renderPostCompactionActions(tab);
+      placeWorkerEnd(tab);
+    }
+  });
+  if (!painted && !_threadSnapshotsHydrated && !tab._pendingSnapshotPaint) {
+    tab._pendingSnapshotPaint = true;
+    _threadSnapshotsReady.finally(() => {
+      tab._pendingSnapshotPaint = false;
+      if (!tab.closed && tab.threadId === expectedThreadId && !tab.transcriptSourceType) {
+        paintInitialThreadSnapshot(tab);
+      }
+    });
+  }
+  return painted;
+}
+
 export function updateActiveTabView() {
   const tab = activeTab();
   if (!_getPanelEl() || !tab) return;
+  paintInitialThreadSnapshot(tab);
   bindTabState(tab);
   _onActiveTabChanged?.(tab);
   _tabs.forEach((entry) => {
@@ -2788,7 +2844,6 @@ export function createTab(saved = {}, { autoSwitch = true } = {}) {
   const inheritedAccountId = saved.accountId ?? activeTab()?.accountId ?? 'default';
   const inheritedEffort = saved.effort ?? activeTab()?.effort ?? (storage.getItem(STOR.effort) || 'off');
   const inheritedAutoAccept = codexNewTabAutoAccept(saved, activeTab(), storedAutoAccept());
-  const inheritedMcpProfile = saved.mcpProfile ?? null;
   const automationRunId = saved.automationRunId || null;
   const inheritedPlanMode = automationRunId ? false : (saved.planMode ?? activeTab()?.planMode ?? false);
   const hasExplicitTitle = !!title && !['new session', 'saved session', 'untitled session', 'codex'].includes(title.toLowerCase());
@@ -2816,7 +2871,6 @@ export function createTab(saved = {}, { autoSwitch = true } = {}) {
     extendedContextVerificationArmed: false,
     effort: inheritedEffort,
     autoAccept: inheritedAutoAccept,
-    mcpProfile: inheritedMcpProfile,
     planMode: inheritedPlanMode,
     sessionListRequest: null,
     threadStartRequest: null,
@@ -2898,6 +2952,7 @@ export function createTab(saved = {}, { autoSwitch = true } = {}) {
     isolationRejections: {},
     ownedThreadIds: new Set(),
     automationRunId,
+    automationTitle: automationRunId ? (saved.automationTitle || title || '') : '',
     automationActive: !!saved.automationActive,
     automationAwaits: false, // the run's turn ended asking the user (runAwaitsAnswer, set by its attach): the pill needs you
     automationOwnerId: saved.automationOwnerId || null,
@@ -2945,6 +3000,8 @@ export function closeTab(idx, { detachAutomation = false } = {}) {
   tab.closed = true;
   tab.titleRequestController?.abort();
   tab.titleRequestController = null;
+  tab.authView?.dispose();
+  tab.terminalAuthView?.dispose();
   if (tab.titleReassertTimer) clearTimeout(tab.titleReassertTimer);
   flushThreadSnapshotSave(tab);
   withTab(tab, () => {
@@ -2967,11 +3024,16 @@ export function closeTab(idx, { detachAutomation = false } = {}) {
   }
   tab.scrollController?.destroy();
   tab.scrollController = null;
+  disposeOutputBlocks(tab.messagesEl);
   if (tab.messagesEl) retireMcpAppNode(tab.messagesEl, () => tab.messagesEl.remove());
   tab.pillEl?.remove();
   _tabs.splice(idx, 1);
   if (!_tabs.length) {
     _activeTabIdx = -1;
+    // The module binding otherwise keeps the last closed transcript, its item
+    // and request maps, and every closure on their DOM alive indefinitely.
+    bindTabState(null);
+    clearMarkdownCache();
     saveTabs();
     renderPills();
     _setVisible(false);
@@ -3039,7 +3101,6 @@ export function saveTabs() {
           contextMode: normalizeCodexContextMode(tab.contextMode),
           effort: tab.effort || 'off',
           autoAccept: !!tab.autoAccept,
-          mcpProfile: tab.mcpProfile || null,
           planMode: !!tab.planMode,
           planFilePath: tab.planFilePath || '',
           planContent: tab.planContent || '',
@@ -3062,6 +3123,7 @@ export function saveTabs() {
           postCompactionPending: tab.postCompactionPromptSource === 'manual' && !!tab.postCompactionPending,
           postCompactionPromptSource: tab.postCompactionPromptSource === 'manual' ? 'manual' : '',
           automationRunId: tab.automationRunId || null,
+          automationTitle: tab.automationTitle || '',
           automationActive: !!tab.automationActive,
           automationOwnerId: tab.automationOwnerId || null,
           releasedRunId: tab.releasedRunId || null,
@@ -3165,7 +3227,13 @@ export function restoreTabs() {
           if (tab && !tab.automationRunId && (saved.running || saved.startingThread || saved.needsYou)) wereWorking.push(tab);
         }
         if (!_tabs.length) throw new Error('No restorable Codex tabs');
-        _activeTabIdx = Math.min(Math.max(Number(data.activeIdx) || 0, 0), _tabs.length - 1);
+        const pendingTabId = globalThis.__synabunPendingTab?.provider === 'codex'
+          ? String(globalThis.__synabunPendingTab.tabId || '')
+          : '';
+        const pendingIdx = pendingTabId ? _tabs.findIndex((entry) => String(entry.id) === pendingTabId) : -1;
+        _activeTabIdx = pendingIdx >= 0
+          ? pendingIdx
+          : Math.min(Math.max(Number(data.activeIdx) || 0, 0), _tabs.length - 1);
         pruneDiscardableTabs({ keepTab: activeTab(), persist: false });
         if (!_tabs.length) throw new Error('No restorable Codex tabs');
         updateActiveTabView();
@@ -3520,7 +3588,7 @@ export function setThread(thread) {
   _freshThread = false;
   // History and a new thread carry the provider's name or, without one, the
   // first prompt. A name the user gave stays, and is sent to the provider again.
-  if (_boundTab?.titleByUser && hasCustomSessionLabel(_boundTab)) {
+  if (_boundTab?.automationRunId || (_boundTab?.titleByUser && hasCustomSessionLabel(_boundTab))) {
     applyCodexProviderTitle(getThreadLabel(thread, _sessionLabel || 'New session'));
   } else {
     setSessionLabel(getThreadLabel(thread, 'New session'));
@@ -4597,6 +4665,7 @@ export function promptNameNewSession() {
       try {
         const statusResponse = await fetch(`/api/git/status?path=${encodeURIComponent(chosenProject)}`);
         const status = statusResponse.ok ? await statusResponse.json() : null;
+        if (!status?.ok || !status.isGit || status.partial || status.stale || status.timedOut) throw new Error(status?.error || 'Git status is incomplete. Refresh before switching branches.');
         const shouldCheckout = !status?.changes?.length || window.confirm(
           `Switch from ${branchOriginal} to ${chosenBranch} with ${status.changes.length} uncommitted change${status.changes.length === 1 ? '' : 's'}? Git will preserve them when possible.`,
         );
@@ -5140,6 +5209,10 @@ export function dispatchPrompt(prompt, { tab = activeTab(), images = null, paths
   };
   if (tab?.model) msg.model = tab.model;
   if (tab?.effort && tab.effort !== 'off') msg.effort = tab.effort;
+  // A native skill picked from the hints (SK-050): sent as Codex's own skill input, once.
+  const nativeSkills = skillsForPrompt(inputText, tab?.pendingSkill);
+  if (nativeSkills.length) msg.skills = nativeSkills;
+  if (tab) tab.pendingSkill = null;
   // A person's own turn: the greeting engine keeps when they were last here. The greeting this
   // tab opened with goes back once, with the first prompt of its new thread.
   msg.human = true;
@@ -5968,7 +6041,7 @@ export function syncToolbarState() {
     effortBtn.title = `Reasoning effort: ${selected?.label || effort}`;
     effortBtn.classList.toggle('active', effort !== 'off');
     const label = effortBtn.querySelector('.cxp-btn-label');
-    if (label) label.textContent = effort === 'off' ? 'Effort' : (selected?.label || effort);
+    if (label) label.textContent = effort === 'off' ? cxpText('effortLabel', 'Effort') : cxpText(`effort_${effort}`, selected?.label || effort);
     const dots = effortBtn.querySelectorAll('.cxp-effort-dots i');
     const litCount = Math.max(0, options.findIndex((option) => option.id === effort));
     dots.forEach((d, i) => d.classList.toggle('lit', i < litCount));
@@ -5999,7 +6072,7 @@ export function syncToolbarState() {
     contextBtn.disabled = !!(tab?.running || tab?.startingThread || tab?.compacting)
       || (mode !== 'extended' && !supportsExtended);
     const label = contextBtn.querySelector('.cxp-btn-label');
-    if (label) label.textContent = mode === 'extended' ? 'Extended' : 'Default';
+    if (label) label.textContent = mode === 'extended' ? cxpText('extended', 'Extended') : cxpText('default', 'Default');
     if (availability.reason) {
       contextBtn.title = availability.reason;
     } else if (mode !== 'extended') {
@@ -6547,8 +6620,9 @@ function setModelForTab(tab, model) {
 function setEffortForTab(tab, effort) {
   if (!tab) return false;
   const normalized = String(effort || '').trim().toLowerCase();
-  const nextEffort = normalized === 'default' || normalized === 'none' ? 'off' : normalized;
   const supported = effortOptionsForTab(tab);
+  // 'none' is a real level on models that advertise it; elsewhere it means the default.
+  const nextEffort = normalized === 'default' || (normalized === 'none' && !supported.some((option) => option.id === 'none')) ? 'off' : normalized;
   if (!supported.some((option) => option.id === nextEffort)) {
     withTab(tab, () => appendSystem(`Unsupported reasoning effort for ${tab.model || 'this model'}: ${effort}. Use ${supported.map((option) => option.id).join(', ')}.`, 'error'));
     return false;
@@ -7215,6 +7289,15 @@ export function renderImageStrip() {
 // ── Whiteboard "Send to Panel" — receive image via event bus ──
 // Any window or surface changed a Codex account (signed in or out, a key, its mode, renamed, added,
 // removed): the menu re-reads the list, and the tabs on that account re-check sign-in.
+// A skill was installed, removed or changed (Skills Studio, Settings, an agent): the app-server is asked to reload its
+// skills at once (it does not watch the folders itself), so the hints and the thread's skills are current before the
+// next "/" is typed.
+appOn('sync:skills:changed', () => {
+  _skillsCache = null; _skillsPromise = null; _skillsChanged = true;
+  if (!activeTab()) return;
+  _skillsPromise = loadSlashCommands().catch(() => {}).finally(() => { _skillsPromise = null; });
+});
+
 appOn('sync:codex:accounts-changed', (msg = {}) => {
   refreshCodexAccounts().catch(() => {});
   for (const tab of _tabs) if (!msg.accountId || serverAccountId(tab.accountId) === msg.accountId) void tab.terminalAuthView?.refresh();
@@ -7491,16 +7574,12 @@ export async function loadSlashCommands() {
     if (!tab) return commands;
     const capabilities = await getCodexCapabilities(tab);
     commands = codexCommandHints(capabilities);
-    const data = await requestSocketPayloadForTab(tab, 'skills_list', { cwds: tab.project ? [tab.project] : [] });
+    const reload = _skillsChanged;
+    const data = await requestSocketPayloadForTab(tab, 'skills_list', skillsListRequest(tab, reload));
+    if (reload) _skillsChanged = false;
     const seen = new Set(BUILTIN_SLASH_COMMANDS.map((entry) => entry.cmd));
-    const skillCommands = flattenNativeCatalog(data, 'skills')
-      .filter((skill) => skill.enabled !== false)
-      .map((skill) => ({
-        cmd: '/' + String(skill.name || skill.dirName || '').trim(),
-        desc: String(skill.description || '').trim(),
-      }))
-      .filter((skill) => skill.cmd !== '/' && !seen.has(skill.cmd))
-      .sort((a, b) => a.cmd.localeCompare(b.cmd));
+    // Each native skill keeps its SKILL.md path: picking it sends Codex's own skill input (cdx-skill-hints.js).
+    const skillCommands = skillHintEntries(flattenNativeCatalog(data, 'skills'), seen);
     _skillsCache = [...commands, ...skillCommands];
   } catch {
     _skillsCache = commands;
@@ -7563,15 +7642,19 @@ export function showSlashHints(text) {
     descSpan.className = 'cxp-slash-hint-desc';
     descSpan.textContent = c.desc;
     item.append(cmdSpan, descSpan);
-    item.addEventListener('click', () => selectSlashHint(c.cmd));
+    item._hint = c;
+    item.addEventListener('click', () => selectSlashHint(c.cmd, c));
     hintsEl.appendChild(item);
   });
 }
 
-export function selectSlashHint(cmd) {
+export function selectSlashHint(cmd, hint = null) {
   const input = panelEl('#cxp-input');
   hideComposerHints();
   if (!input) return;
+  // A native skill picked here goes as Codex's own skill input with the prompt, while the prompt starts with it.
+  const pickTab = activeTab();
+  if (pickTab) pickTab.pendingSkill = hint?.skill ? { cmd: hint.cmd, name: hint.skill.name, path: hint.skill.path } : null;
   const command = CODEX_COMMAND_BY_NAME.get(String(cmd).replace(/^\//, ''));
   if (command?.name === 'model') {
     panelEl('#cxp-model')?.classList.toggle('open');
@@ -7609,7 +7692,7 @@ export function confirmSlashHint() {
     return true;
   }
   const cmdEl = items[_slashActiveIdx]?.querySelector('.cxp-slash-hint-cmd');
-  if (cmdEl) selectSlashHint(cmdEl.textContent);
+  if (cmdEl) selectSlashHint(cmdEl.textContent, items[_slashActiveIdx]._hint || null);
   return true;
 }
 

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

@@ -223,7 +223,6 @@ function handleSocketMessage(msg, tab, callbacks) {
     case 'rate_limits':
     case 'status_snapshot':
     case 'mcp_status':
-    case 'mcp_profile_changed':
     case 'config_saved':
     case 'mcp_refreshed':
     case 'mcp_oauth_done':

package/neural-interface/public/shared/cli-install-controller.js

@@ -0,0 +1,218 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — one CLI's install state, for a side panel (no DOM)
+// ═══════════════════════════════════════════
+//
+// What a panel needs to show for its CLI and to act on it: the latest answer of
+// /api/system/tool-versions (cli-status.js), an install this page started or
+// follows (POST /api/cli/install/:tool, or one another window started), a
+// "failed to start" a session reported, Add to PATH, Re-check. One controller
+// per panel; `onChange(view)` hears every change, `view()` is
+// cli-install-view.js cliBannerView() plus `checking` (a Re-check is under way)
+// and `nudging` (a held-back send asked for attention a moment ago).
+//
+// ui-cli-banner.js paints it as the Claude, Codex and OpenCode panels' banner;
+// the Antigravity panel paints it as its setup card (agy/agy-setup.js).
+
+import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallCommand, getCliLabel, installCli, followCliInstall, getCliInstallJobs, addCliToPath } from './cli-status.js';
+import { cliBannerView, cliInstallText, cliStateOf, reduceInstallJob, INSTALLABLE_CLIS } from './cli-install-view.js';
+
+/** How long the note about where an install put the CLI stays, when it has one. */
+export const DONE_NOTICE_MS = 12000;
+export const NUDGE_MS = 700;
+
+/**
+ * @param {object} o
+ * @param {string} o.toolKey 'claude-code' | 'codex' | 'opencode' | 'antigravity'
+ * @param {(view: object) => void} [o.onChange]
+ * @param {number} [o.doneNoticeMs]
+ * @param {number} [o.nudgeMs]
+ */
+export function createCliInstallController({ toolKey, onChange = () => {}, doneNoticeMs = DONE_NOTICE_MS, nudgeMs = NUDGE_MS } = {}) {
+  let info = null;        // this CLI in the latest answer of /api/system/tool-versions (null: none yet)
+  let forced = null;      // { reason }: a session could not start it, and the server was not asked again yet
+  let job = null;         // the install under way or just ended (cli-install-view.js reduceInstallJob)
+  let installing = false;
+  let addingPath = false;
+  let pathError = '';
+  let checking = false;
+  let looked = false;     // asked whether the server is already installing it since it went missing
+  let doneTimer = null;
+  let nudgeTimer = null;
+  let destroyed = false;
+
+  const view = () => ({
+    ...cliBannerView({
+      toolKey,
+      label: getCliLabel(toolKey),
+      info,
+      forced,
+      job,
+      addingPath, pathError,
+      guideUrl: getCliDocUrl(toolKey),
+      installCommand: getCliInstallCommand(toolKey),
+    }, { t: cliInstallText }),
+    checking,
+    nudging: !!nudgeTimer,
+    job,
+    info,
+  });
+
+  const changed = () => {
+    if (destroyed) return;
+    try { onChange(view()); } catch (error) { console.error('[cli-install] onChange:', error); }
+  };
+
+  function clearDone() {
+    clearTimeout(doneTimer);
+    doneTimer = null;
+    if (job?.phase === 'done') job = null;
+    changed();
+  }
+
+  function apply(event) {
+    if (!job && event?.type !== 'start') job = reduceInstallJob(null, { type: 'start' });
+    job = reduceInstallJob(job, event);
+    if (event?.type === 'done' && event.ok && event.status && typeof event.status === 'object') {
+      info = event.status;
+      forced = null;
+    }
+    changed();
+  }
+
+  function settle(final) {
+    if (job?.phase === 'running' && final) job = reduceInstallJob(job, final);
+    if (job?.phase === 'done') {
+      clearTimeout(doneTimer);
+      const where = job.path;
+      if (where && (where.onPath === false || where.added === true)) doneTimer = setTimeout(clearDone, doneNoticeMs);
+      else job = null;
+    }
+    changed();
+  }
+
+  async function install() {
+    if (installing || !INSTALLABLE_CLIS.includes(toolKey)) return null;
+    installing = true;
+    clearTimeout(doneTimer);
+    job = reduceInstallJob(null, { type: 'start' });
+    changed();
+    let final = null;
+    try {
+      final = await installCli(toolKey, { onEvent: apply });
+    } catch (error) {
+      final = { type: 'done', ok: false, code: 'internal', error: error?.message || null };
+    } finally {
+      installing = false;
+      settle(final);
+    }
+    return final;
+  }
+
+  async function addPath() {
+    if (addingPath) return;
+    addingPath = true; pathError = ''; changed();
+    try {
+      const result = await addCliToPath(toolKey);
+      info = { ...info, pathStatus: { dir: result.dir, onPath: true, canAdd: false } };
+      job = reduceInstallJob(null, { type: 'done', ok: true, status: info, path: { ...result, added: true } });
+      settle();
+    } catch (error) { pathError = error.message; }
+    finally { addingPath = false; changed(); }
+  }
+
+  // An install the server is already running (another window started it, or this page was reloaded during
+  // one): followed here as if this page had started it.
+  async function followRunning() {
+    if (installing) return;
+    const jobs = await getCliInstallJobs();
+    if (destroyed || installing || jobs?.[toolKey]?.state !== 'running') return;
+    installing = true;
+    job = reduceInstallJob(null, { type: 'start' });
+    changed();
+    let final = null;
+    try {
+      final = await followCliInstall(toolKey, { onEvent: apply });
+    } catch (error) {
+      final = { type: 'done', ok: false, code: 'connection', error: error?.message || null };
+    } finally {
+      installing = false;
+      settle(final);
+    }
+  }
+
+  async function recheck() {
+    if (checking) return info;
+    checking = true;
+    // Asking again starts over: an earlier failure is not repeated over a fresh answer.
+    if (job?.phase === 'failed') job = null;
+    changed();
+    try {
+      const next = await recheckCliStatus(toolKey);
+      info = next || info;
+      if (cliStateOf(info) === 'installed' || cliStateOf(info) === 'broken') forced = null;
+    } catch { /* the view stays as it is */ }
+    finally {
+      checking = false;
+      changed();
+    }
+    return info;
+  }
+
+  const unsubscribe = subscribeCliStatus(toolKey, (next) => {
+    info = next || null;
+    const state = cliStateOf(info);
+    if (state === 'installed') {
+      forced = null;
+      if (job?.phase === 'failed') job = null;
+    }
+    if (state === 'missing') {
+      if (!looked) { looked = true; followRunning().catch(() => {}); }
+    } else {
+      looked = false;
+    }
+    changed();
+  });
+
+  return {
+    view,
+    /** Tell `onChange` again (the panel was shown, or rebuilt). */
+    refresh: changed,
+    /** Sending is held back: the CLI is missing, broken, failed to install, or being installed. */
+    blocked: () => view().blocked,
+    /** A send was held back: `nudging` is true for a moment. */
+    nudge() {
+      if (!view().show) return;
+      clearTimeout(nudgeTimer);
+      nudgeTimer = setTimeout(() => { nudgeTimer = null; changed(); }, nudgeMs);
+      changed();
+    },
+    /**
+     * A session could not start the CLI ("CLI not found", a spawn error): "failed to start" with its words at
+     * once, then the server is asked again; its answer decides what stays.
+     */
+    flagFailure(reason = null) {
+      forced = { reason: reason ? String(reason).slice(0, 300) : null };
+      changed();
+      recheckCliStatus(toolKey)
+        .then((next) => {
+          info = next || info;
+          const state = cliStateOf(info);
+          if (state === 'installed' || state === 'broken') forced = null;
+          changed();
+        })
+        .catch(() => {});
+    },
+    install,
+    recheck,
+    addPath,
+    clearDone,
+    /** Whether an install runs from this page now. */
+    installing: () => installing,
+    destroy() {
+      destroyed = true;
+      unsubscribe();
+      clearTimeout(doneTimer);
+      clearTimeout(nudgeTimer);
+    },
+  };
+}