synabun 2026.4.21 → 2026.4.25-beta.2

package/neural-interface/lib/plugin-installer.js

@@ -0,0 +1,264 @@
+import { spawnSync } from 'child_process';
+import {
+  existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync,
+  lstatSync, renameSync, rmSync,
+} from 'fs';
+import { join, resolve, dirname } from 'path';
+import os from 'node:os';
+
+const PLUGINS_ROOT = () => join(os.homedir(), '.claude', 'plugins');
+const INSTALLED_PLUGINS_FILE = () => join(PLUGINS_ROOT(), 'installed_plugins.json');
+const KNOWN_MARKETPLACES_FILE = () => join(PLUGINS_ROOT(), 'known_marketplaces.json');
+
+let trackerPath = null;
+export function setTrackerPath(p) { trackerPath = p; }
+const trackerFile = () => trackerPath || join(process.cwd(), 'data', 'synabun-plugins.json');
+
+function ensureDir(p) { if (!existsSync(p)) mkdirSync(p, { recursive: true }); }
+
+function readJson(p, fallback) {
+  try { return existsSync(p) ? JSON.parse(readFileSync(p, 'utf-8')) : fallback; }
+  catch { return fallback; }
+}
+
+function writeJsonAtomic(p, obj) {
+  ensureDir(dirname(p));
+  const tmp = `${p}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+  try { renameSync(tmp, p); }
+  catch { writeFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf-8'); try { unlinkSync(tmp); } catch {} }
+}
+
+function runClaude(args, { timeoutMs = 180000 } = {}) {
+  const r = spawnSync('claude', args, {
+    encoding: 'utf-8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: timeoutMs,
+  });
+  const stdout = (r.stdout || '').toString();
+  const stderr = (r.stderr || '').toString();
+  const combined = `${stdout}${stderr ? '\n' + stderr : ''}`.trim();
+  if (r.error && r.error.code === 'ENOENT') {
+    return { ok: false, code: -1, stdout, stderr, combined, notFound: true };
+  }
+  return { ok: r.status === 0, code: r.status ?? -1, stdout, stderr, combined };
+}
+
+function claudeNotFoundErr() {
+  return { ok: false, error: 'Claude Code CLI not found on PATH. Install `claude` to manage plugins.' };
+}
+
+function gitHeadSha(repoPath) {
+  if (!repoPath || !existsSync(repoPath)) return 'unknown';
+  const r = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: repoPath, encoding: 'utf-8' });
+  const out = (r.stdout || '').trim();
+  return out || 'unknown';
+}
+
+function readTracker() { return readJson(trackerFile(), { version: 1, plugins: {} }); }
+function writeTracker(obj) { writeJsonAtomic(trackerFile(), obj); }
+
+function isSynabunSymlinkMarketplace(entry) {
+  return entry && entry.source && entry.source.source === 'synabun-symlink';
+}
+
+// Purge legacy "synabun-symlink" entries that break CC's marketplace loader,
+// plus orphaned installed_plugins rows whose cache path no longer exists.
+function cleanLegacyState() {
+  try {
+    const known = readJson(KNOWN_MARKETPLACES_FILE(), null);
+    if (known && typeof known === 'object') {
+      let changed = false;
+      for (const [name, entry] of Object.entries(known)) {
+        if (isSynabunSymlinkMarketplace(entry)) {
+          delete known[name];
+          changed = true;
+          const mkLink = join(PLUGINS_ROOT(), 'marketplaces', name);
+          try { if (lstatSync(mkLink).isSymbolicLink()) unlinkSync(mkLink); } catch {}
+          try { rmSync(join(PLUGINS_ROOT(), 'cache', name), { recursive: true, force: true }); } catch {}
+        }
+      }
+      if (changed) writeJsonAtomic(KNOWN_MARKETPLACES_FILE(), known);
+    }
+
+    const installed = readJson(INSTALLED_PLUGINS_FILE(), null);
+    if (installed && installed.plugins && typeof installed.plugins === 'object') {
+      let changed2 = false;
+      for (const key of Object.keys(installed.plugins)) {
+        const list = installed.plugins[key] || [];
+        const filtered = list.filter(e => e && e.installPath && existsSync(e.installPath));
+        if (filtered.length !== list.length) {
+          if (filtered.length) installed.plugins[key] = filtered;
+          else delete installed.plugins[key];
+          changed2 = true;
+        }
+      }
+      if (changed2) writeJsonAtomic(INSTALLED_PLUGINS_FILE(), installed);
+    }
+  } catch {}
+}
+
+function parsePluginManifest(repoPath) {
+  const pluginJson = readJson(join(repoPath, '.claude-plugin', 'plugin.json'), null);
+  if (!pluginJson || !pluginJson.name) return { ok: false, error: `Missing .claude-plugin/plugin.json at ${repoPath}` };
+  const marketplaceJson = readJson(join(repoPath, '.claude-plugin', 'marketplace.json'), null);
+  const pluginName = String(pluginJson.name).trim();
+  const marketplaceName = (marketplaceJson && marketplaceJson.name) || pluginName;
+  const hooks = pluginJson.hooks && typeof pluginJson.hooks === 'object' ? Object.keys(pluginJson.hooks) : [];
+  return { ok: true, pluginName, marketplaceName, hooks, manifest: pluginJson };
+}
+
+// Install via `claude plugin marketplace add` + `claude plugin install`.
+// Prefers githubUrl (CC manages its own clone); falls back to local repoPath.
+export function installClaudePlugin({ repoPath, githubUrl } = {}) {
+  cleanLegacyState();
+
+  if (!repoPath || !existsSync(repoPath)) {
+    return { ok: false, error: `Repo path required to read plugin manifest: ${repoPath}` };
+  }
+  const meta = parsePluginManifest(repoPath);
+  if (!meta.ok) return meta;
+  const { pluginName, marketplaceName, hooks } = meta;
+
+  const source = githubUrl || resolve(repoPath);
+
+  const addRes = runClaude(['plugin', 'marketplace', 'add', source, '--scope', 'user']);
+  if (addRes.notFound) return claudeNotFoundErr();
+  const alreadyAdded = /already (added|exists|configured|registered)/i.test(addRes.combined);
+  if (!addRes.ok && !alreadyAdded) {
+    return { ok: false, error: `claude plugin marketplace add failed: ${addRes.combined || `exit ${addRes.code}`}` };
+  }
+
+  const installRes = runClaude(['plugin', 'install', `${pluginName}@${marketplaceName}`, '--scope', 'user']);
+  if (installRes.notFound) return claudeNotFoundErr();
+  const alreadyInstalled = /already installed/i.test(installRes.combined);
+  if (!installRes.ok && !alreadyInstalled) {
+    return { ok: false, error: `claude plugin install failed: ${installRes.combined || `exit ${installRes.code}`}` };
+  }
+
+  const installed = readJson(INSTALLED_PLUGINS_FILE(), { plugins: {} });
+  const key = `${pluginName}@${marketplaceName}`;
+  const ccList = installed.plugins?.[key] || [];
+  const ccEntry = ccList.find(e => e && e.scope === 'user') || ccList[0] || null;
+  const installPath = ccEntry?.installPath || null;
+  const gitCommitSha = ccEntry?.gitCommitSha || gitHeadSha(repoPath);
+
+  const tracker = readTracker();
+  if (!tracker.plugins || typeof tracker.plugins !== 'object') tracker.plugins = {};
+  tracker.plugins[key] = {
+    pluginName,
+    marketplaceName,
+    source,
+    githubUrl: githubUrl || null,
+    repoPath: resolve(repoPath),
+    gitCommitSha,
+    installedAt: tracker.plugins[key]?.installedAt || new Date().toISOString(),
+    lastUpdated: new Date().toISOString(),
+  };
+  writeTracker(tracker);
+
+  return {
+    ok: true,
+    pluginName,
+    marketplaceName,
+    installPath,
+    marketplacePath: join(PLUGINS_ROOT(), 'marketplaces', marketplaceName),
+    key,
+    hooks,
+    gitCommitSha,
+    alreadyInstalled,
+  };
+}
+
+export function uninstallClaudePlugin({ marketplaceName, pluginName } = {}) {
+  cleanLegacyState();
+  if (!marketplaceName) return { ok: false, error: 'marketplaceName required' };
+
+  const tracker = readTracker();
+  const managedKeys = Object.keys(tracker.plugins || {}).filter(k => {
+    const [pName, mName] = k.split('@');
+    if (mName !== marketplaceName) return false;
+    if (pluginName && pName !== pluginName) return false;
+    return true;
+  });
+  if (!managedKeys.length) return { ok: false, error: `No SynaBun-managed plugin found for ${marketplaceName}${pluginName ? '/' + pluginName : ''}` };
+
+  const removedPlugins = [];
+  for (const key of managedKeys) {
+    const [pName] = key.split('@');
+    const r = runClaude(['plugin', 'uninstall', key]);
+    if (r.notFound) return claudeNotFoundErr();
+    const notFound = /not (installed|found)/i.test(r.combined);
+    if (!r.ok && !notFound) {
+      return { ok: false, error: `claude plugin uninstall failed: ${r.combined || `exit ${r.code}`}` };
+    }
+    delete tracker.plugins[key];
+    removedPlugins.push(pName);
+  }
+
+  const remaining = Object.keys(tracker.plugins || {}).some(k => k.endsWith(`@${marketplaceName}`));
+  if (!remaining) {
+    runClaude(['plugin', 'marketplace', 'remove', marketplaceName]);
+  }
+  writeTracker(tracker);
+  return { ok: true, removedPlugins };
+}
+
+export function listSynabunPlugins() {
+  const tracker = readTracker();
+  const installed = readJson(INSTALLED_PLUGINS_FILE(), { plugins: {} });
+  const out = [];
+  for (const [key, meta] of Object.entries(tracker.plugins || {})) {
+    const ccList = installed.plugins?.[key] || [];
+    const ccEntry = ccList.find(e => e && e.scope === 'user') || ccList[0] || null;
+    const installPath = ccEntry?.installPath || null;
+    const installPresent = installPath ? existsSync(installPath) : false;
+    const repoExists = meta.repoPath ? existsSync(meta.repoPath) : true;
+    out.push({
+      key,
+      pluginName: meta.pluginName,
+      marketplaceName: meta.marketplaceName,
+      scope: ccEntry?.scope || 'user',
+      installPath,
+      installedAt: meta.installedAt,
+      lastUpdated: meta.lastUpdated,
+      gitCommitSha: ccEntry?.gitCommitSha || meta.gitCommitSha,
+      repoPath: meta.repoPath || null,
+      githubUrl: meta.githubUrl || null,
+      broken: !ccEntry || !installPresent || !repoExists,
+    });
+  }
+  return out;
+}
+
+// Migration: purge legacy synabun-symlink state + reinstall via CLI for any
+// entries whose original repo path still exists.
+export function repairSynabunPlugins() {
+  const before = readJson(KNOWN_MARKETPLACES_FILE(), {}) || {};
+  const legacy = Object.entries(before)
+    .filter(([, v]) => isSynabunSymlinkMarketplace(v))
+    .map(([name, v]) => ({ name, path: v.source?.path || null }));
+
+  cleanLegacyState();
+
+  const repaired = [];
+  const failed = [];
+  for (const { name, path } of legacy) {
+    if (!path || !existsSync(path)) {
+      failed.push({ marketplaceName: name, error: 'Original repo path missing — cannot reinstall automatically' });
+      continue;
+    }
+    const meta = parsePluginManifest(path);
+    if (!meta.ok) { failed.push({ marketplaceName: name, error: meta.error }); continue; }
+    let githubUrl = null;
+    try {
+      const r = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: path, encoding: 'utf-8' });
+      const u = (r.stdout || '').trim();
+      if (/^https?:\/\//.test(u)) githubUrl = u.replace(/\.git$/, '');
+    } catch {}
+    const res = installClaudePlugin({ repoPath: path, githubUrl });
+    if (res.ok) repaired.push({ marketplaceName: name, pluginName: res.pluginName });
+    else failed.push({ marketplaceName: name, error: res.error });
+  }
+  return { repaired, failed };
+}

package/neural-interface/package.json

@@ -21,7 +21,7 @@
     "express": "^4.21.2",
     "node-html-markdown": "^2.0.0",
     "node-pty": "^1.1.0",
-    "playwright": "^1.58.2",
+    "playwright": "1.54.2",
     "undici": "^8.1.0",
     "ws": "^8.19.0"
   }

package/neural-interface/public/shared/api.js

@@ -975,6 +975,24 @@ export async function launchLoop(params) {
   });
 }
 
+export async function fetchLoopLog(terminalSessionId) {
+  const res = await fetch(`/api/loop/log/${encodeURIComponent(terminalSessionId)}`);
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(text || `HTTP ${res.status}`);
+  }
+  return res.text();
+}
+
+export async function sendClientLoopLog(terminalSessionId, tag, msg, meta) {
+  try {
+    return await jsonFetch('/api/loop/client-log', {
+      method: 'POST',
+      ...jsonBody({ terminalSessionId: terminalSessionId || null, tag, msg, meta }),
+    });
+  } catch { /* logging best-effort */ }
+}
+
 export async function stopLoop(terminalSessionId) {
   return jsonFetch('/api/loop/stop', {
     method: 'POST',
@@ -1004,11 +1022,42 @@ export async function searchMemoriesByCategory(query, category, limit = 15) {
   });
 }
 
-// ── Loop Schedules ──
-
-export async function fetchSchedules() {
-  return jsonFetch('/api/schedules');
-}
+// ── Loop Schedules ──
+
+export async function fetchScheduleGroups() {
+  return jsonFetch('/api/schedule-groups');
+}
+
+export async function createScheduleGroup(payload) {
+  return jsonFetch('/api/schedule-groups', {
+    method: 'POST',
+    ...jsonBody(payload),
+  });
+}
+
+export async function updateScheduleGroup(id, payload) {
+  return jsonFetch(`/api/schedule-groups/${encodeURIComponent(id)}`, {
+    method: 'PUT',
+    ...jsonBody(payload),
+  });
+}
+
+export async function deleteScheduleGroup(id) {
+  return jsonFetch(`/api/schedule-groups/${encodeURIComponent(id)}`, {
+    method: 'DELETE',
+  });
+}
+
+export async function reorderScheduleGroups(orderedIds) {
+  return jsonFetch('/api/schedule-groups/reorder', {
+    method: 'POST',
+    ...jsonBody({ orderedIds }),
+  });
+}
+
+export async function fetchSchedules() {
+  return jsonFetch('/api/schedules');
+}
 
 export async function createSchedule(params) {
   return jsonFetch('/api/schedules', {
@@ -1059,12 +1108,12 @@ export async function fetchScheduleTimers() {
 
 // ── Quick Timers ──
 
-export async function createQuickTimer(templateId, minutes, { profile, model, usesBrowser } = {}) {
-  return jsonFetch('/api/quick-timer', {
-    method: 'POST',
-    ...jsonBody({ templateId, minutes, profile, model, usesBrowser }),
-  });
-}
+export async function createQuickTimer(templateId, minutes, { profile, model, effort, usesBrowser } = {}) {
+  return jsonFetch('/api/quick-timer', {
+    method: 'POST',
+    ...jsonBody({ templateId, minutes, profile, model, effort, usesBrowser }),
+  });
+}
 
 export async function fetchQuickTimers() {
   return jsonFetch('/api/quick-timers');
@@ -1076,12 +1125,12 @@ export async function cancelQuickTimer(id) {
   });
 }
 
-export async function triggerQuickTimerNow(templateId, { profile, model, usesBrowser } = {}) {
-  return jsonFetch('/api/quick-timer/now', {
-    method: 'POST',
-    ...jsonBody({ templateId, profile, model, usesBrowser }),
-  });
-}
+export async function triggerQuickTimerNow(templateId, { profile, model, effort, usesBrowser } = {}) {
+  return jsonFetch('/api/quick-timer/now', {
+    method: 'POST',
+    ...jsonBody({ templateId, profile, model, effort, usesBrowser }),
+  });
+}
 
 // ── Isolated Agents ──
 

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

@@ -49,13 +49,12 @@ export const STOR = {
 };
 
 // ── Effort Levels ──
-export const EFFORT_LEVELS = ['off', 'low', 'medium', 'high'];
+export const EFFORT_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
 
 // ── Panel Identity ──
 export const PANEL_OWNER = 'codex-sidepanel';
 
-// ── Limits ──
-export const MAX_TABS = 10;
+// ── Snapshot Limits ──
 export const MAX_THREAD_SNAPSHOTS = 18;
 export const MAX_THREAD_SNAPSHOT_CHARS = 2_000_000;
 
@@ -69,7 +68,9 @@ CRITICAL — When you need clarification during planning:
 1. Use request_user_input to ask concise multiple-choice questions.
 2. After calling request_user_input, stop and wait for the user's reply before continuing.
 3. Do NOT ask clarification questions as plain text.
-4. Do NOT make code changes until the plan is approved.`,
+4. Do NOT make code changes until the plan is approved.
+5. When the plan is ready, stop after the plan. Do NOT continue into implementation.
+6. The sidepanel will ask the user whether to Edit plan, Compact context, or Continue with implementation.`,
 ];
 
 // ── Stall Detection ──

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

@@ -4,9 +4,10 @@
 import { storage } from '../storage.js';
 import { state, emit, on } from '../state.js';
 import { reserveRightPanelLayout, clearRightPanelLayout } from '../ui-sidepanel-layout.js';
+import { subscribeCliStatus, recheckCliStatus, getCliDocUrl, getCliInstallCommand, getCliLabel } from '../cli-status.js';
 import { isClaudePanelOpen, toggleClaudePanel } from '../ui-claude-panel.js';
 import { injectStyles } from './cdx-styles.js';
-import { flushCardBody } from './cdx-render.js';
+import { appendAssistantMarkdownMessage, flushCardBody, renderPostPlanActions } from './cdx-render.js';
 import {
   OPENAI_ICON, ICON_SPARK, ICON_PLUS, ICON_MINIMIZE, ICON_X, ICON_STOP,
   ICON_EDIT, ICON_SHIELD, ICON_PLAN, ICON_BRAIN, SYNABUN_LOGO_ICON,
@@ -17,7 +18,7 @@ import {
   createTab, switchTab, closeTab, closeActiveTab, saveTabs, restoreTabs,
   initContextBridge,
   renderPills, renderProjects, updateActiveTabView,
-  sendPrompt, dispatchPrompt, interruptTurn, interruptAllTabs, anyTabRunning, queueCurrentDraft, steerActiveTurn,
+  sendPrompt, dispatchPrompt, interruptTurn, queueCurrentDraft, steerActiveTurn,
   cycleEffort, togglePlanMode, toggleAutoAccept, syncToolbarState,
   requestModelList, populateModelDropdown,
   setSessionLabel, renameActiveSession, promptNameNewSession, openSettingsPanel, renderSessionMenu,
@@ -27,11 +28,18 @@ import {
   syncQueueTray, editQueueItem, toggleQueuePause, clearQueue,
   startCompaction,
   syncInputEnabled, syncReservedWidth, scheduleThreadSnapshotSave,
+  flushAllThreadSnapshots,
   resetStallTimer, stopStallTimer,
   withTab,
   ensureProjectsLoaded,
 } from './cdx-tabs.js';
 
+window.addEventListener('beforeunload', () => { try { flushAllThreadSnapshots(); } catch {} });
+window.addEventListener('pagehide', () => { try { flushAllThreadSnapshots(); } catch {} });
+document.addEventListener('visibilitychange', () => {
+  if (document.hidden) { try { flushAllThreadSnapshots(); } catch {} }
+});
+
 // ═══════════════════════════════════════════
 //  Module-level State (panel owns)
 // ═══════════════════════════════════════════
@@ -39,6 +47,8 @@ import {
 let _panel = null;
 let _visible = false;
 let _resizeBound = false;
+let _cliInstalled = null;
+let _cliUnsub = null;
 
 // ═══════════════════════════════════════════
 //  Bound State (mirrors active tab — managed by cdx-tabs)
@@ -68,6 +78,9 @@ let _planContent = '';
 let _editedPlanContent = '';
 let _showPostPlanActions = false;
 let _postPlanHeader = 'PLAN COMPLETE';
+let _planTurnActive = false;
+let _planApprovalPending = false;
+let _lastPlanTurnId = '';
 let _planFilePath = '';
 
 // ═══════════════════════════════════════════
@@ -85,8 +98,6 @@ let _host = {};
  *   flushCardBody(itemState)
  *   resetThreadState(opts)
  *   appendSystem(text, tone)
- *   appendAssistantMarkdownMessage(tab, markdown)
- *   renderPostPlanActions(tab, headerText)
  *   sendServerRequestReply(requestId, opts)
  *   getRequestCardEntry(requestId) -> object|null
  *   restoreChangelogButtons(buttons)
@@ -133,6 +144,9 @@ export function syncBoundState(s) {
   _editedPlanContent = s.editedPlanContent ?? _editedPlanContent;
   _showPostPlanActions = s.showPostPlanActions ?? _showPostPlanActions;
   _postPlanHeader = s.postPlanHeader ?? _postPlanHeader;
+  _planTurnActive = s.planTurnActive ?? _planTurnActive;
+  _planApprovalPending = s.planApprovalPending ?? _planApprovalPending;
+  _lastPlanTurnId = s.lastPlanTurnId ?? _lastPlanTurnId;
   _planFilePath = s.planFilePath ?? _planFilePath;
 }
 
@@ -319,7 +333,7 @@ function buildPanel() {
           </button>
         </div>
         <div class="cxp-footer-right">
-          <button class="cxp-toolbar-toggle" id="cxp-effort-toggle" title="Effort level: off" data-effort="off">${ICON_BRAIN}<span class="cxp-btn-label">Effort</span><span class="cxp-effort-dots"><i></i><i></i><i></i></span></button>
+          <button class="cxp-toolbar-toggle" id="cxp-effort-toggle" title="Effort level: off" data-effort="off">${ICON_BRAIN}<span class="cxp-btn-label">Effort</span><span class="cxp-effort-dots"><i></i><i></i><i></i><i></i><i></i></span></button>
           <button class="cxp-toolbar-toggle" id="cxp-plan-toggle" title="Plan mode: off">${ICON_PLAN}<span class="cxp-btn-label">Plan</span></button>
           <button class="cxp-toolbar-toggle" id="cxp-autoaccept-toggle" title="Auto-accept: off">${ICON_SHIELD}<span class="cxp-btn-label">Auto</span></button>
           <div class="cxp-dropdown" id="cxp-model" data-placeholder="model...">
@@ -379,6 +393,74 @@ function startupEmptyText() {
   return '';
 }
 
+// ── CLI installation status (banner + send-block) ──
+function renderCliMissingBanner(emptyEl) {
+  if (!emptyEl) return;
+  const label = getCliLabel('codex');
+  const cmd = getCliInstallCommand('codex');
+  const url = getCliDocUrl('codex');
+  const statusEl = emptyEl.querySelector('.cxp-empty-status');
+  if (statusEl) statusEl.style.display = 'none';
+  let banner = emptyEl.querySelector('.cxp-cli-missing');
+  if (!banner) {
+    banner = document.createElement('div');
+    banner.className = 'cxp-cli-missing';
+    banner.innerHTML = `
+      <div class="cxp-cli-missing-title">${label} CLI not installed</div>
+      <div class="cxp-cli-missing-body">Run: <code>${cmd}</code></div>
+      <div class="cxp-cli-missing-actions">
+        <a class="cxp-cli-missing-link" href="${url}" target="_blank" rel="noopener noreferrer">Install guide</a>
+        <button class="cxp-cli-missing-recheck" type="button">Re-check</button>
+      </div>
+    `;
+    emptyEl.appendChild(banner);
+    const btn = banner.querySelector('.cxp-cli-missing-recheck');
+    btn?.addEventListener('click', async () => {
+      btn.disabled = true;
+      btn.textContent = 'Checking…';
+      try { await recheckCliStatus('codex'); }
+      finally {
+        if (btn.isConnected) {
+          btn.disabled = false;
+          btn.textContent = 'Re-check';
+        }
+      }
+    });
+  }
+}
+
+function refreshCliBanners() {
+  if (!_panel) return;
+  const empties = _panel.querySelectorAll('.cxp-empty');
+  if (_cliInstalled === null) {
+    _panel.classList.add('cxp-cli-blocked');
+    for (const el of empties) renderCliMissingBanner(el);
+  } else {
+    _panel.classList.remove('cxp-cli-blocked');
+    for (const el of empties) {
+      const banner = el.querySelector('.cxp-cli-missing');
+      if (banner) banner.remove();
+      const statusEl = el.querySelector('.cxp-empty-status');
+      if (statusEl) statusEl.style.display = '';
+    }
+  }
+  // Re-evaluate send button state with new CLI flag
+  try { syncInputEnabled(); } catch {}
+}
+
+export function isCdxCliInstalled() {
+  return _cliInstalled !== null;
+}
+
+function ensureCliSubscription() {
+  if (_cliUnsub) return;
+  _cliUnsub = subscribeCliStatus('codex', (info) => {
+    _cliInstalled = info?.installed || null;
+    refreshCliBanners();
+  });
+  document.addEventListener('cdx-empty-rebuilt', () => refreshCliBanners());
+}
+
 // ═══════════════════════════════════════════
 //  setVisible — Show / Hide Panel
 // ═══════════════════════════════════════════
@@ -386,12 +468,12 @@ function startupEmptyText() {
 function _cdxDocEscHandler(event) {
   if (event.key !== 'Escape') return;
   if (!_visible) return;
-  if (!anyTabRunning()) return;
+  if (!activeTab()?.running) return;
   const hintsEl = panelEl('#cxp-slash-hints');
   if (hintsEl && !hintsEl.hidden) return; // let input-level handler dismiss hints first
   event.preventDefault();
   event.stopImmediatePropagation();
-  interruptAllTabs();
+  interruptTurn();
 }
 
 function setVisible(nextVisible) {
@@ -415,6 +497,7 @@ function setVisible(nextVisible) {
     loadCurrentProfile();
     loadRecallProfile();
     panelEl('#cxp-input')?.focus();
+    refreshCliBanners();
   } else {
     document.removeEventListener('keydown', _cdxDocEscHandler, { capture: true });
   }
@@ -629,7 +712,7 @@ function wireEvents() {
     if (event.key === 'Escape') {
       const hintsEl = panelEl('#cxp-slash-hints');
       if (hintsEl && !hintsEl.hidden) { hintsEl.hidden = true; _slashActiveIdx = -1; event.preventDefault(); return; }
-      if (anyTabRunning()) { event.preventDefault(); interruptAllTabs(); return; }
+      if (activeTab()?.running) { event.preventDefault(); interruptTurn(); return; }
     }
     if (event.key === 'Tab' && activeTab()?.running) {
       const tab = activeTab();
@@ -673,15 +756,16 @@ function wireEvents() {
     fileInput.value = '';
   });
   send?.addEventListener('click', () => {
-    if (anyTabRunning()) {
-      interruptAllTabs();
+    if (activeTab()?.running) {
+      interruptTurn();
       return;
     }
     sendPrompt();
   });
   minimizeBtn?.addEventListener('click', () => setVisible(false));
   newBtn?.addEventListener('click', () => {
-    createTab({ project: activeTab()?.project || storage.getItem(STOR.project) || '' });
+    const tab = createTab({ project: activeTab()?.project || storage.getItem(STOR.project) || '' });
+    if (!tab) return;
     promptNameNewSession();
   });
   closeBtn?.addEventListener('click', () => closeActiveTab());
@@ -855,16 +939,22 @@ function wireEvents() {
     tab.editedPlanContent = content || tab.editedPlanContent || '';
     tab.showPostPlanActions = true;
     tab.postPlanHeader = 'PLAN UPDATED';
+    tab.planApprovalPending = true;
+    tab.planTurnActive = false;
+    tab.lastPlanTurnId = '';
     if (filePath) tab.planFilePath = filePath;
     if (isActiveTab(tab)) {
       _planContent = tab.planContent;
       _editedPlanContent = tab.editedPlanContent;
       _showPostPlanActions = true;
       _postPlanHeader = 'PLAN UPDATED';
+      _planApprovalPending = true;
+      _planTurnActive = false;
+      _lastPlanTurnId = '';
       if (filePath) _planFilePath = filePath;
     }
-    _host.appendAssistantMarkdownMessage?.(tab, content || '');
-    _host.renderPostPlanActions?.(tab, 'PLAN UPDATED');
+    appendAssistantMarkdownMessage(tab, content || '');
+    renderPostPlanActions(tab, 'PLAN UPDATED');
     saveTabs();
   });
 
@@ -896,7 +986,18 @@ function wireEvents() {
     if (source && source !== 'codex') return;
     const tab = _tabs.find((entry) => entry.id === tabId) || activeTab();
     if (!tab) return;
-    _host.renderPostPlanActions?.(tab);
+    tab.showPostPlanActions = true;
+    tab.planApprovalPending = true;
+    tab.planTurnActive = false;
+    tab.postPlanHeader = tab.postPlanHeader || 'PLAN COMPLETE';
+    if (isActiveTab(tab)) {
+      _showPostPlanActions = true;
+      _planApprovalPending = true;
+      _planTurnActive = false;
+      _postPlanHeader = tab.postPlanHeader;
+    }
+    renderPostPlanActions(tab, tab.postPlanHeader);
+    saveTabs();
   });
 
   on('changelog-edit-cancelled', () => {
@@ -942,6 +1043,8 @@ function ensurePanel() {
   autosizeInput();
   restoreTabs();
   syncInputEnabled();
+  ensureCliSubscription();
+  window.dispatchEvent(new CustomEvent('sidepanel-tray:provider-loaded', { detail: { provider: 'codex' } }));
   // Close Codex when a Claude/OpenCode pill is clicked (mutual exclusion)
   const tray = document.getElementById('term-minimized-tray');
   if (tray) {