synabun 2.0.0 → 2.0.7

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

@@ -174,11 +174,29 @@ export function getLocaleChoice() {
   return matchLocale(saved) || SYSTEM_LOCALE;
 }
 
+/**
+ * The locale the page address asks for with `?lang=<tag>`, matched like a stored choice
+ * ('pt' → 'pt-BR'), or null (no tag, or one no locale answers). It holds for this page
+ * load only and is never stored: showcase captures use it to get an English UI without
+ * touching the user's own choice.
+ */
+export function getAddressLocale() {
+  const search = globalThis.window?.location?.search;
+  if (!search) return null;
+  try {
+    return matchLocale(new URLSearchParams(search).get('lang'));
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Detect the user's preferred locale.
- * Priority: stored explicit choice → system language → 'en'
+ * Priority: the page address (?lang=) → stored explicit choice → system language → 'en'
  */
 function detectLocale() {
+  const address = getAddressLocale();
+  if (address) return address;
   const choice = getLocaleChoice();
   return choice === SYSTEM_LOCALE ? getSystemLocale() : choice;
 }

package/neural-interface/public/shared/install-details-view.js

@@ -0,0 +1,86 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — the setup wizard's Details: what they say
+// ═══════════════════════════════════════════
+//
+// Inside the SynaBun desktop app, the setup wizard (onboarding.html) shows
+// what it checked and what this copy has, step by step, in a Details area
+// under Environment Check and under Install & Build: the commands SynaBun ran
+// and what they answered, where `npm i -g` puts packages, and every part's
+// dependencies with the version installed. The facts are
+// GET /api/setup/install-details (lib/install-details.js); this turns them into
+// the lines shown. English, like the rest of the wizard.
+//
+// No imports and no DOM: `node --test` loads this file as it is
+// (tests/install-details-view.test.mjs).
+
+const said = (tool) => (tool.ok ? tool.output || '(no answer)' : `did not run: ${tool.output || 'no output'}`);
+
+/** Environment Check: the Node.js SynaBun runs on, its npm and npx (the command and the answer), and the user's own npm. */
+export function environmentLines(details) {
+  if (!details || typeof details !== 'object') return [];
+  const lines = [];
+  const node = details.node;
+  if (node) {
+    lines.push('$ node --version');
+    lines.push(`${node.version}  ${node.path}${node.bundled ? '  (the Node.js that came with SynaBun)' : ''}`);
+  }
+  for (const name of ['npm', 'npx']) {
+    const tool = details[name];
+    if (!tool) { lines.push(`${name}: not found`); continue; }
+    lines.push(`$ ${tool.command}`);
+    lines.push(`${said(tool)}${tool.ok && tool.bundled ? '  (came with SynaBun)' : ''}`);
+  }
+  const prefix = details.globalPrefix;
+  if (prefix?.path) {
+    const setIn = prefix.from === 'npm_config_prefix' ? ', from npm_config_prefix' : prefix.from ? `, set in ${prefix.from}` : '';
+    const why = prefix.source === 'user' ? `your own npm prefix${setIn}` : 'a folder of SynaBun\'s, outside the app';
+    lines.push(`npm i -g installs into ${prefix.path} (${why})${prefix.bin ? `, commands in ${prefix.bin}` : ''}`);
+  }
+  if (details.kind === 'app') {
+    const user = details.userNpm;
+    lines.push(user
+      ? `Your own npm: ${user.path} ${user.ok ? user.output : '(did not answer)'}. SynaBun's terminals find it first.`
+      : 'No npm of your own: SynaBun\'s terminals use the one that came with SynaBun.');
+  }
+  return lines;
+}
+
+/** One part's packages: how many, then each dependency with the version installed. */
+function partLines(part, bundled) {
+  const lines = [`${part.name}: ${part.packages} package${part.packages === 1 ? '' : 's'} installed${bundled ? ' (came with SynaBun)' : ''}`];
+  for (const dep of part.dependencies || []) {
+    lines.push(`  ${dep.name} ${dep.installed || `not installed (wants ${dep.wanted})`}`);
+  }
+  return lines;
+}
+
+/** Install & Build: what this copy has, from the runtime to every dependency, and what is still to come. */
+export function installLines(details) {
+  if (!details || typeof details !== 'object') return [];
+  const app = details.kind === 'app';
+  const lines = [];
+  if (app) {
+    const where = details.app?.target ? ` for ${details.app.target}` : '';
+    lines.push(`SynaBun ${details.app?.version || ''}${where}: nothing to install, this copy came with its dependencies.`.replace(/\s+:/, ':'));
+  }
+  if (details.node) {
+    const npm = details.npm?.ok ? `, npm ${details.npm.output}` : '';
+    const npx = details.npx?.ok ? `, npx ${details.npx.output}` : '';
+    lines.push(`Node.js ${String(details.node.version).replace(/^v/, '')}${npm}${npx}${details.node.bundled ? ' (the runtime that came with SynaBun)' : ''}`);
+  }
+  for (const part of details.parts || []) lines.push(...partLines(part, app));
+  lines.push(details.mcp?.built ? `MCP server: built (${details.mcp.file})` : 'MCP server: not built yet');
+  const bundled = details.bundled;
+  if (bundled) {
+    lines.push(bundled.embeddingModel ? `Local embedding model: ${bundled.embeddingModel} (came with SynaBun)` : 'Local embedding model: not included (keyword recall only)');
+    if (bundled.cloudflared) lines.push(`cloudflared ${bundled.cloudflared}, for invite links and remote MCP (came with SynaBun)`);
+    if (bundled.gitBash) lines.push(`Git for Windows ${bundled.gitBash}, the Git Bash Claude Code needs (came with SynaBun)`);
+    if (details.app?.electron) lines.push(`The window: Electron ${details.app.electron}`);
+  }
+  if (details.browser) {
+    lines.push(details.browser.installed
+      ? `Automation browser (Chromium for Playwright): installed, ${details.browser.path}`
+      : 'Automation browser (Chromium for Playwright): not downloaded yet; SynaBun downloads it at its next start.');
+  }
+  return lines;
+}

package/neural-interface/public/shared/ocp-v2/ocp-v2-childpanel.js

@@ -18,6 +18,8 @@
 
 import { state, emit } from '../state.js';
 import { injectStyles } from './ocp-v2-styles.js';
+import { getDefaultStore } from './ocp-v2-state.js';
+import { wireFileLinks } from '../ui-file-links.js';
 import { mountRenderer } from './ocp-v2-render.js';
 import { mountCompose } from './ocp-v2-send.js';
 import { trackContextGauge } from './ocp-v2-context-gauge.js';
@@ -212,6 +214,8 @@ export function createChildPanel({
     messages.className = 'ocpv2-messages';
     messagesContainer.appendChild(messages);
     panel.appendChild(messagesContainer);
+    // File links open in the code editor, as in the main panel: a sub-agent works in its parent's directory.
+    wireFileLinks(messagesContainer, { cwd: () => store.getState().cwd || getDefaultStore().getState().cwd || '' });
 
     // This panel's own questions (closing it with prompts waiting, deleting a
     // message) show above its compose box.

package/neural-interface/public/shared/ocp-v2/ocp-v2-greeting.js

@@ -0,0 +1,47 @@
+// OpenCode panel — the greeting in the empty state (shared/greeting/, lib/greeting/).
+//
+// What SynaBun says when a person comes back and opens a new session: one or
+// two sentences, written by SynaBun ahead of time (the session's model never
+// greets). Only for a session with nothing in it that a person opened: never
+// an automation run's. The greeting's id goes back with the first message
+// (`greetingId` on message:send), so the model is told once what was said.
+// A server older than this page simply answers nothing.
+
+import { clearGreeting, forgetGreeting, mountGreeting } from '../greeting/greeting-card.js';
+
+const SURFACE = 'opencode-panel';
+let pending = null; // { id, sessionId } — the greeting on screen, until a first message carries it
+
+/**
+ * The empty state is on screen. `host`: its element (kept between renders, so asked once).
+ * ctx: { sessionId, cwd, automation, onOpenMemory(id), isCurrent() }
+ */
+export function offerGreeting(host, { sessionId = null, cwd = '', automation = false, onOpenMemory = null, isCurrent = null } = {}) {
+  if (!host) return;
+  const key = sessionId || '';
+  if (host.dataset.greetingFor === key && host.dataset.greetingAsked === '1') return;
+  host.dataset.greetingFor = key;
+  host.dataset.greetingAsked = '1';
+  clearGreeting(host);
+  if (automation) return;
+  mountGreeting(host, {
+    surface: SURFACE, session: sessionId || null, cwd,
+    onOpenMemory,
+    isCurrent: () => host.dataset.greetingFor === key && (typeof isCurrent !== 'function' || isCurrent() !== false),
+  }).then((greeting) => {
+    if (greeting && host.dataset.greetingFor === key) pending = { id: greeting.id, sessionId: sessionId || null };
+  }).catch(() => { /* a session always opens */ });
+}
+
+/** The id to send with a person's message to `sessionId`, once ('' when this session opened with no greeting). */
+export function takeGreetingId(sessionId) {
+  const held = pending;
+  if (!held) return '';
+  // A greeting shown before the session had an id belongs to the first session a message goes to.
+  if (held.sessionId && sessionId && held.sessionId !== sessionId) return '';
+  pending = null;
+  if (held.sessionId) forgetGreeting(SURFACE, held.sessionId);
+  return held.id || '';
+}
+
+export const _test = { reset() { pending = null; }, pending: () => pending };

package/neural-interface/public/shared/ocp-v2/ocp-v2-panel.js

@@ -43,13 +43,18 @@ import { mountChangesBar } from './ocp-v2-changes.js';
 import { mountEnvironmentPopover } from './ocp-v2-status.js';
 import { watchWorktree, newSessionPlan, checkoutOutcome } from './ocp-v2-changes-logic.js';
 import { mountRenderer } from './ocp-v2-render.js';
+import { offerGreeting } from './ocp-v2-greeting.js';
 import { mountCompose, focusCompose, appendPathToCompose } from './ocp-v2-send.js';
 import { mountProjectBar, unmountProjectBar } from './ocp-v2-projectbar.js';
 import { registerSidepanel, syncSidepanelLayout, focusSidepanel, openAnotherSidepanelSession, isHostedSessionFocused } from '../ui-sidepanel-windows.js';
 import { nativeLoopWindowId } from '../ui-native-window-id.js';
 import { requestGeneratedSessionTitle } from '../session-title.js';
+import { wireFileLinks } from '../ui-file-links.js';
+import { mountCliBanner } from '../ui-cli-banner.js';
+import { backToAssistant, buildWorkerEndCard, endWorkerRunOnClose, forgetWorkerEnd, trackWorkerEnd } from '../ui-worker-end.js';
+import { isDispatchedRun } from '../worker-end.js';
 import {
-  registerAutomationSession, unregisterAutomationSession, stopAutomationRun,
+  registerAutomationSession, unregisterAutomationSession, stopAutomationRun, isAutomationSession,
 } from './ocp-v2-automation-ownership.js';
 import {
   registerPrimaryPanel, bindPrimarySession, isChildPanelOpen, getVisibleChildPanel, openChildSession,
@@ -92,6 +97,8 @@ const _automationRunning = new Set();
 const _automationContinuedManually = new Set();
 const _automationManualSendInFlight = new Set();
 const _foreignActiveAutomationSessions = new Set();
+const _workerEnds = new Map(); // sessionId -> end card of the dispatched worker it belongs to (ui-worker-end.js)
+let _renderer = null;
 let _visible = false;
 let _booted = false;
 let _bootPromise = null;
@@ -115,6 +122,8 @@ const _titleReassertTimers = new Map();
 // rename carries is not the session's: nothing shows it or pushes it again.
 const _pendingRenames = createPendingRenames();
 let _composer = null;           // the primary panel's composer (mountCompose)
+let _cliBanner = null;          // the CLI banner and send-block (ui-cli-banner.js)
+let _cliWasBlocked = false;    // the banner held sends back last time it said (a change to usable heals the serve)
 // Where the panel goes. Every choice of the user (a tab, a session in the
 // menu, New session, a project, a worktree) begins an intent, and a navigation
 // binds the panel only while its intent is the latest one: a later choice wins
@@ -420,6 +429,33 @@ function buildPanel() {
   messages.className = 'ocpv2-messages';
   messagesContainer.appendChild(messages);
   panel.appendChild(messagesContainer);
+  // A link to a file the code editor can open opens it there (shared with the other panels). A relative
+  // path is a path in the session's directory.
+  wireFileLinks(messagesContainer, { cwd: () => getState().cwd || '' });
+
+  // ── The CLI banner (ui-cli-banner.js) ───────────────────────────────────
+  // Above the transcript while OpenCode is not usable: not installed (with
+  // Install, which runs OpenCode's own installer or official release on the
+  // server), being installed, failed to install, or found but failed to start
+  // (with the error it gave). The panel gets `ocp-cli-blocked` meanwhile, and
+  // the composer holds sends back (sendBlocked below).
+  _cliBanner = mountCliBanner({
+    toolKey: 'opencode',
+    prefix: 'ocp',
+    panel: () => panel,
+    anchor: () => messagesContainer,
+    // OpenCode was installed (or found again) while its serve could not start: start it now rather than at the
+    // next retry of the auto-heal, whose wait has grown by then.
+    onBlockedChange: (blocked) => {
+      const usableAgain = _cliWasBlocked && !blocked;
+      _cliWasBlocked = blocked;
+      if (usableAgain && getState().serverStatus !== 'ready') {
+        clearTimeout(_healTimer);
+        _healTimer = null;
+        scheduleAutoHeal('cli-usable', 0);
+      }
+    },
+  });
 
   // ── What the session changed on disk (session.diff) ─────────────────────
   mountChangesBar(panel, getDefaultStore());
@@ -445,7 +481,17 @@ function buildPanel() {
   });
 
   let composer = null;
-  const renderer = mountRenderer(messages, getDefaultStore(), {
+  const renderer = _renderer = mountRenderer(messages, getDefaultStore(), {
+    // A dispatched worker's end: the last card of its session's transcript.
+    endCard: (s) => workerEndCard(s?.sessionId),
+    // SynaBun's greeting for a person who comes back to a new session: never for an automation run's.
+    onEmpty: (host, s) => offerGreeting(host, {
+      sessionId: s?.sessionId || null,
+      cwd: s?.cwd || '',
+      automation: !!s?.sessionId && (_automationRunIds.has(s.sessionId) || isAutomationSession(s.sessionId)),
+      onOpenMemory: (id) => { if (id) emit('memory:open', { id }); },
+      isCurrent: () => (getState().sessionId || null) === (s?.sessionId || null) && getState().messageOrder.length === 0,
+    }),
     onOpenSession: (session, extra) => openCreatedSession(session, extra),
     // Fork is a navigation: its intent begins at the click, and the fork takes
     // the panel only while that click is still the user's latest choice.
@@ -500,11 +546,26 @@ function buildPanel() {
     // (ocp-v2-binding.js): the session the prompt or the Stop was for, frozen
     // before the first await. It is never the live state.
     canSend: (session) => !_automationRunning.has(session?.sessionId),
+    // While the CLI banner shows (OpenCode missing, broken or being installed),
+    // a send stays in the box and the banner is pointed at instead.
+    sendBlocked: () => !!_cliBanner?.blocked(),
+    onSendBlocked: () => _cliBanner?.nudge(),
     onManualSend: (session, phase, meta) => {
       const sessionId = session?.sessionId;
       if (phase === 'started') requestOpenCodeSessionTitle(session, meta);
       if (!sessionId || !_automationRunIds.has(sessionId) || _automationRunning.has(sessionId)) return;
-      if (phase === 'started') _automationManualSendInFlight.add(sessionId);
+      if (phase === 'started') {
+        const first = !_automationContinuedManually.has(sessionId) && !_automationManualSendInFlight.has(sessionId);
+        _automationManualSendInFlight.add(sessionId);
+        if (first) {
+          // The tab is the user's from here on (Codex's releaseAutomationForManualUse): the run's
+          // end card goes, and the router leaves the run alone, so nothing of it comes back here.
+          const runId = _automationRunIds.get(sessionId);
+          forgetWorkerEnd(runId);
+          showWorkerEnd(sessionId, null);
+          window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId } }));
+        }
+      }
       if (phase === 'failed') _automationManualSendInFlight.delete(sessionId);
       if (phase === 'succeeded') {
         _automationManualSendInFlight.delete(sessionId);
@@ -2180,6 +2241,7 @@ function applyVisibility(nextVisible) {
   _panelEl.classList.toggle('ocpv2-open', _visible);
   if (_visible) {
     state.lastActivePanel = 'opencode';
+    _cliBanner?.refresh();
   } else {
     // The popover is a child of <body>: it does not go with the panel by itself.
     _contextMenu?.close();
@@ -2238,11 +2300,12 @@ function dismissAutomationSession(sessionId) {
   if (!runId) return false;
   window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId } }));
   if (_automationRunning.has(sessionId)) {
-    fetch('/api/loop/stop', {
+    // A worker that finished its task is completed; any other run is stopped.
+    endWorkerRunOnClose(runId, () => fetch('/api/loop/stop', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ runId }),
-    }).catch(() => {});
+    }).catch(() => {}));
   }
   return true;
 }
@@ -2317,6 +2380,8 @@ function removeTab(sessionId, { byUser = false } = {}) {
   const titleTimer = _titleReassertTimers.get(sessionId);
   if (titleTimer) clearTimeout(titleTimer);
   _titleReassertTimers.delete(sessionId);
+  forgetWorkerEnd(_automationRunIds.get(sessionId));
+  _workerEnds.delete(sessionId);
   _automationRunIds.delete(sessionId);
   unregisterAutomationSession(sessionId);
   _automationRunning.delete(sessionId);
@@ -2354,22 +2419,56 @@ function createTabPill(sessionId) {
     if (event.target.closest('.term-minimized-pill-close')) return;
     handlePillClick(sessionId);
   });
-  pill.querySelector('.term-minimized-pill-close')?.addEventListener('click', async (event) => {
+  pill.querySelector('.term-minimized-pill-close')?.addEventListener('click', (event) => {
     event.stopPropagation();
-    // Mirror header X. Native transcripts are preserved unless the user has
-    // continued the terminal automation manually; backend cleanup is best-effort.
-    // Asked first when prompts are still waiting in that session; declined:
-    // the tab stays and nothing is deleted.
-    if (!(await mayCloseTab(sessionId))) return;
-    const wasRunning = sessionId === getState().sessionId && !!getState().running;
-    closeSessionBackend(sessionId, { wasRunning, context: 'pill close' }).catch(() => {});
-    try { await handlePillClose(sessionId, { byUser: true }); }
-    catch (err) { console.warn('[ocp-v2-panel] local pill close failed', err); }
+    closeTabByUser(sessionId, 'pill close');
   });
   tray.appendChild(pill);
   return pill;
 }
 
+// Mirror header X. Native transcripts are preserved unless the user has
+// continued the terminal automation manually; backend cleanup is best-effort.
+// Asked first when prompts are still waiting in that session; declined: the
+// tab stays, nothing is deleted, and this resolves false.
+async function closeTabByUser(sessionId, context) {
+  if (!(await mayCloseTab(sessionId))) return false;
+  const wasRunning = sessionId === getState().sessionId && !!getState().running;
+  closeSessionBackend(sessionId, { wasRunning, context }).catch(() => {});
+  try { await handlePillClose(sessionId, { byUser: true }); }
+  catch (err) { console.warn(`[ocp-v2-panel] local ${context} failed`, err); }
+  return true;
+}
+
+// The end of a worker the Assistant dispatched: its button closes the tab the
+// way the tab's X does (a warm worker that finished its task is completed, one
+// still at work is stopped; its record stays for the Assistant) and shows the
+// Assistant session that dispatched it.
+function workerEndCard(sessionId) {
+  const view = sessionId ? _workerEnds.get(sessionId) : null;
+  if (!view) return null;
+  return {
+    sig: view.sig,
+    build: () => buildWorkerEndCard(view, {
+      classes: {
+        card: 'ocpv2-post-plan-card ocpv2-worker-end', title: 'ocpv2-post-plan-header', detail: 'ocpv2-post-plan-body',
+        meta: 'ocpv2-post-plan-saved', note: 'ocpv2-post-plan-note', actions: 'ocpv2-post-plan-actions', button: 'ocpv2-post-plan-btn primary',
+      },
+      onBack: async () => {
+        if (!(await closeTabByUser(sessionId, 'worker end close'))) return false;
+        backToAssistant(view.assistantSessionId);
+        return true;
+      },
+    }),
+  };
+}
+
+function showWorkerEnd(sessionId, view) {
+  if (view) _workerEnds.set(sessionId, view);
+  else if (!_workerEnds.delete(sessionId)) return;
+  _renderer?.render();
+}
+
 function escapeHtml(s) {
   return String(s || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }
@@ -2539,9 +2638,12 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
   // Establish ownership before connect()/boot(): native provider events use a
   // separate socket and may report a Task child while this attach is awaiting.
   const previousRunId = _automationRunIds.get(sessionId);
+  const running = run.status === 'starting' || run.status === 'running';
+  // The user continued this run's session by hand after the run ended: the tab stays theirs.
+  const released = !running && previousRunId === run.runId
+    && (_automationContinuedManually.has(sessionId) || _automationManualSendInFlight.has(sessionId));
   _automationRunIds.set(sessionId, run.runId);
   registerAutomationSession(sessionId, run.runId);
-  const running = run.status === 'starting' || run.status === 'running';
   if (running || previousRunId !== run.runId) {
     _automationContinuedManually.delete(sessionId);
     _automationManualSendInFlight.delete(sessionId);
@@ -2565,6 +2667,16 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
     await handlePillClose(sessionId).catch(() => {});
     return { ok: false, reason: 'dismissed' };
   }
+  if (released) {
+    // The dock's Focus raises it; the run is let go again, and nothing in the tab changes.
+    window.dispatchEvent(new CustomEvent('native-loop:dismissed', { detail: { runId: run.runId } }));
+    if (focus && _nav.latest() === attachBegan && _tabSessionIds.includes(sessionId)) {
+      const nav = _nav.observe();
+      if (!_visible) await showPrimaryOpencodePanel();
+      await switchToSession(sessionId, _tabInfoCache.get(sessionId) || null, { nav });
+    }
+    return { ok: true, sessionId, released: true };
+  }
   ensureTab(sessionId, info);
   if (focus && _nav.latest() === attachBegan) {
     // (Its own navigation, observed after boot landed: a click made while the
@@ -2577,13 +2689,15 @@ export async function attachOpenCodeAutomation(run, { focus = !!run?.focus, isCa
     await rehydrateActiveSession().catch(() => {});
   }
   if (getState().sessionId === sessionId) setRunning(running);
-  if (run.status === 'failed' && run.error && getState().sessionId === sessionId
+  // (A dispatched worker's failure, with its reason, is on its end card.)
+  if (run.status === 'failed' && run.error && !isDispatchedRun(run) && getState().sessionId === sessionId
     && _tabInfoCache.get(sessionId)?._automationLifecycleError !== run.error) {
     const cachedInfo = _tabInfoCache.get(sessionId) || info;
     cachedInfo._automationLifecycleError = run.error;
     _tabInfoCache.set(sessionId, _stoppedShares.clean(cachedInfo));
     pushError({ message: run.error });
   }
+  trackWorkerEnd(run, { apply: (view) => showWorkerEnd(sessionId, view) });
   renderPill();
   return { ok: true, sessionId };
 }

package/neural-interface/public/shared/ocp-v2/ocp-v2-render.js

@@ -212,9 +212,13 @@ function render(_container, store, opts = {}) {
   );
   const questions = requestsVisibleIn(s.pendingQuestions, s.sessionId, isKnownDescendantSession);
   const retry = retryBannerView(s.sessionStatus);
-  const hasInteractiveCards = permissions.length > 0 || questions.length > 0 || !!s.showPostPlanActions;
+  // The panel's last card for the session on screen (a dispatched worker's end): { sig, build } or null.
+  const endCard = typeof opts.endCard === 'function' ? opts.endCard(s) : null;
+  const hasInteractiveCards = permissions.length > 0 || questions.length > 0 || !!s.showPostPlanActions || !!endCard;
   if (s.messageOrder.length === 0 && !hasInteractiveCards && !s.errors.length && !retry && !revertBanner) {
     _reconcile(_container, [{ key: '__empty__', sig: 'empty', build: _buildEmpty }]);
+    // The panel may put SynaBun's greeting in it (ocp-v2-greeting.js).
+    try { opts.onEmpty?.(_container.querySelector(':scope > .ocpv2-empty'), s); } catch { /* the empty state stands on its own */ }
     return;
   }
 
@@ -346,6 +350,8 @@ function render(_container, store, opts = {}) {
     });
   }
 
+  if (endCard) desired.push({ key: 'end', sig: `end:${endCard.sig}`, build: endCard.build });
+
   _reconcile(_container, desired);
 }
 

package/neural-interface/public/shared/ocp-v2/ocp-v2-send.js

@@ -33,6 +33,7 @@ import {
 } from './ocp-v2-send-logic.js';
 import { hydrateTranscript } from './ocp-v2-rehydrate.js';
 import { captureBinding, trackBinding, isBindingToken, searchOnBinding } from './ocp-v2-binding.js';
+import { takeGreetingId } from './ocp-v2-greeting.js';
 
 const STOR_MODE = 'opencode-v2-mode';   // the last agent picked (build / plan / a custom one)
 const STOR_HISTORY = 'ocp-v2-prompt-history';
@@ -965,6 +966,16 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
     syncButton();
   }
 
+  // The panel holds sends back while its CLI banner shows (opts.sendBlocked,
+  // ui-cli-banner.js): nothing is sent, nothing is cleared, the banner is
+  // pointed at. A composer mounted without the option (a sub-agent's) never is.
+  function sendHeldBack() {
+    let held = false;
+    try { held = !!opts.sendBlocked?.(); } catch { held = false; }
+    if (held) { try { opts.onSendBlocked?.(); } catch {} }
+    return held;
+  }
+
   function rememberPrompt(text) {
     if (!text) return;
     _history.push(text);
@@ -1037,6 +1048,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
     // read this snapshot.
     const turn = captureBinding(store);
     if (!turn.sessionId) { store.pushError({ message: 'No session. Reopen the panel to retry.' }); return false; }
+    if (sendHeldBack()) return false;
     if (opts.canSend && opts.canSend(turn) === false) {
       store.pushError({ message: 'Stop the running automation before sending a manual turn.' });
       return false;
@@ -1139,6 +1151,11 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
     const hasPaths = (s.pendingPaths?.length || 0) > 0;
 
     if (_shell) {
+      // The CLI is missing, broken or being installed (the panel's CLI banner
+      // says so): the command stays in the box, in shell mode. (Prompts and
+      // server commands are held back where they are sent, and come back into
+      // the box from there; a local slash command needs no CLI.)
+      if (sendHeldBack()) return false;
       // Only what the user typed (or pasted) into the shell-mode composer runs.
       // Anything that got into the box another way drops back to a prompt.
       const allowed = shellRunAllowed({ shell: _shell, value: _input.value, typedValue: _shellTypedValue });
@@ -1223,6 +1240,7 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
     // first await; everything after it reads `turn`.
     const turn = captureBinding(store);
     const s = store.getState();
+    if (sendHeldBack()) return false;
     if (opts.canSend && opts.canSend(turn) === false) {
       store.pushError({ message: 'Stop the running automation before sending a manual turn.' });
       return false;
@@ -1449,6 +1467,10 @@ export function mountCompose(rootEl, store = getDefaultStore(), opts = {}) {
         variant: turn.variant || undefined,
         cwd: options.cwd || turn.cwd || undefined,
         mcpProfile: turn.mcpProfile || undefined,
+        // A person's own message (the greeting engine keeps when they were last here), and the
+        // greeting this session opened with, told to the model once.
+        human: true,
+        greetingId: takeGreetingId(turnSessionId) || undefined,
       });
       if (res?.error) return failSend(shouldSuppressAbortError(res.error) ? '' : res.error);
       // Delivered: that stands, whatever the panel shows by now.