synabun 2.0.9 → 2.1.0

package/neural-interface/public/shared/settings/settings-claude-hooks.js

@@ -0,0 +1,135 @@
+// ═══════════════════════════════════════════
+// SETTINGS — SynaBun's Claude Code hooks, in words
+// ═══════════════════════════════════════════
+//
+// What `GET /api/claude-code/integrations` says in `claudeHooks` (lib/claude-hooks-status.js) about Settings →
+// Automations → Automation behavior → SynaBun hooks in Claude Code: whether a Claude Code session the owner starts
+// by themselves runs SynaBun's hooks, what stands in the way, and whether the switch can change it. Pure: no DOM
+// and no import, so node runs it (tests/settings-claude-hooks-view.test.mjs).
+//
+//   readClaudeHooksResponse({ status, body, error })   what the server answered → a reading
+//   describeClaudeHooks(reading, { tx })                the row as ui-settings.js draws it
+//   describeClaudeHooksSaveFailure(input, { tx })       the sentence for a change that could not be made
+//
+// `tx(key, params)` is the caller's translate function over the settings.redesign.* strings (the kit's `tx`).
+// The row never shows "off" for what it could not read: a refusal (SynaBun's automation browser), a server started
+// before this, an unreadable settings file each say what they are, with the switch disabled.
+
+const K = 'settings.redesign.hooks.claudeHooks';
+
+/** The rows of the "Hooks for standalone Claude Code" list: one per moment, the guards over two events. */
+export const CLAUDE_HOOK_ROWS = Object.freeze([
+  Object.freeze({ key: 'SessionStart', events: ['SessionStart'] }),
+  Object.freeze({ key: 'UserPromptSubmit', events: ['UserPromptSubmit'] }),
+  Object.freeze({ key: 'PreCompact', events: ['PreCompact'] }),
+  Object.freeze({ key: 'Stop', events: ['Stop'] }),
+  Object.freeze({ key: 'PreToolUse', events: ['PreToolUse', 'PostToolBatch'] }),
+  Object.freeze({ key: 'PostToolUse', events: ['PostToolUse'] }),
+  Object.freeze({ key: 'SubagentStart', events: ['SubagentStart'] }),
+  Object.freeze({ key: 'SubagentStop', events: ['SubagentStop'] }),
+]);
+
+/** The refusals of SynaBun's owner-only routes for a browser that is not the owner's (lib/owner-authority.js). */
+const REFUSED_CODES = new Set(['WORKER_BROWSER', 'PEER_REFUSED']);
+
+const clean = (value, max = 240) => {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+const names = (list) => [...new Set((list || []).map((p) => clean(p.label || String(p.path || '').split(/[\\/]/).filter(Boolean).pop() || p.path, 60)))].join(', ');
+
+/**
+ * What the server answered.
+ *
+ *   ready        `hooks` is the server's claudeHooks
+ *   old-server   an answer without claudeHooks: the running server was started before it (public/ is served live,
+ *                lib/ only after a restart), and its own reading of the settings may be wrong
+ *   refused      403 WORKER_BROWSER / PEER_REFUSED: SynaBun's automation browser, never the owner's own window
+ *   forbidden    403 otherwise (a guest)
+ *   unreadable   anything else (no answer, an error, a body that is not the payload)
+ */
+export function readClaudeHooksResponse({ status = 0, body = null, error = null } = {}) {
+  const code = Number(status) || 0;
+  if (code >= 200 && code < 300 && body && typeof body === 'object' && body.ok === true) {
+    const hooks = body.claudeHooks;
+    if (hooks && typeof hooks === 'object' && Number(hooks.version) >= 1 && typeof hooks.state === 'string') return { state: 'ready', hooks, reason: null };
+    return { state: 'old-server', hooks: null, reason: null };
+  }
+  if (code === 403) {
+    const refusal = String(body?.code || '');
+    return { state: REFUSED_CODES.has(refusal) ? 'refused' : 'forbidden', hooks: null, reason: clean(body?.error) || null, code: refusal || null };
+  }
+  return { state: 'unreadable', hooks: null, reason: clean(error || body?.error || (code ? `HTTP ${code}` : '')) || null };
+}
+
+/** Which list rows are on: every event of the row has all of SynaBun's handlers. */
+export function claudeHookRowsOn(events) {
+  return Object.fromEntries(CLAUDE_HOOK_ROWS.map((row) => [row.key, row.events.every((event) => events?.[event] === true)]));
+}
+
+/**
+ * The row: { state, ready, disabled, on, notes: [{ text, tone }], note: { text, tone } | null, repair, applies,
+ * rows: { [rowKey]: boolean } | null (the list below; null when nothing could be read), onRows, totalRows }.
+ * `note` says why nothing below can be trusted or changed; `notes` describe what is installed.
+ */
+export function describeClaudeHooks(reading, { tx }) {
+  const r = reading || readClaudeHooksResponse({ status: 0 });
+  const view = { state: r.state, ready: false, disabled: true, on: false, notes: [], note: null, repair: false, applies: tx(`${K}.applies`), rows: null, onRows: 0, totalRows: CLAUDE_HOOK_ROWS.length };
+  if (r.state === 'old-server') { view.note = { text: tx(`${K}.restart`), tone: 'warn' }; return view; }
+  if (r.state === 'refused') { view.note = { text: tx(`${K}.refused`), tone: 'warn' }; return view; }
+  if (r.state === 'forbidden') { view.note = { text: tx(`${K}.forbidden`), tone: 'warn' }; return view; }
+  if (r.state !== 'ready') {
+    view.note = { text: r.reason ? tx(`${K}.unreadable`, { reason: r.reason }) : tx(`${K}.unreadableNoReason`), tone: 'warn' };
+    return view;
+  }
+  const h = r.hooks;
+  if (h.state === 'error') {
+    view.note = { text: tx(`${K}.settingsUnreadable`, { path: h.settingsPath || '~/.claude/settings.json', reason: clean(h.error) || '?' }), tone: 'warn' };
+    return view;
+  }
+  const path = h.settingsPath || '~/.claude/settings.json';
+  const rows = claudeHookRowsOn(h.events);
+  const onRows = Object.values(rows).filter(Boolean).length;
+  const installed = h.state === 'on' || h.state === 'partial';
+  const managed = h.blockedBy?.scope === 'managed';
+  view.ready = true;
+  view.rows = rows;
+  view.onRows = onRows;
+  // On means "a session the owner starts runs them": installed and not switched off by Claude Code itself.
+  view.on = installed && !h.blockedBy;
+  // The organization's managed settings, and a packaged app started from a temporary place, cannot be switched here.
+  view.disabled = managed || !!h.installBlocker;
+
+  if (h.installBlocker) view.notes.push({ text: clean(h.installBlocker, 400), tone: 'warn' });
+  if (managed) view.notes.push({ text: tx(`${K}.blocked.managed.${h.blockedBy.setting === 'allowManagedHooksOnly' ? 'managedOnly' : 'disableAll'}`, { path: h.blockedBy.path }), tone: 'warn' });
+  else if (h.blockedBy) view.notes.push({ text: tx(`${K}.blocked.user`, { path: h.blockedBy.path || path }), tone: 'warn' });
+  else if (h.state === 'on') view.notes.push({ text: tx(`${K}.on`, { path }), tone: 'info' });
+  else if (h.state === 'partial') view.notes.push({ text: tx(`${K}.partial`, { on: onRows, total: CLAUDE_HOOK_ROWS.length }), tone: 'info' });
+  else view.notes.push({ text: tx(`${K}.off`), tone: 'info' });
+
+  if (h.needsRepair && !managed) {
+    view.repair = !h.installBlocker;
+    if (h.current < h.installed) view.notes.push({ text: tx(`${K}.repair.stale`, { count: h.installed - h.current }), tone: 'warn' });
+    if (h.duplicates > 0) view.notes.push({ text: tx(`${K}.repair.duplicates`, { count: h.duplicates }), tone: 'warn' });
+    const different = (h.projects || []).filter((p) => p.issue === 'different');
+    if (different.length) view.notes.push({ text: tx(`${K}.repair.projects`, { names: names(different) }), tone: 'warn' });
+    if (h.nodeMissing) view.notes.push({ text: tx(`${K}.repair.node`), tone: 'warn' });
+  }
+  const off = (h.projects || []).filter((p) => p.issue === 'disableAllHooks');
+  if (off.length) view.notes.push({ text: tx(`${K}.projectsOff`, { names: names(off) }), tone: 'warn' });
+  const stillOn = (h.projects || []).filter((p) => p.issue === 'project-only');
+  if (stillOn.length) view.notes.push({ text: tx(`${K}.projectsStillOn`, { names: names(stillOn) }), tone: 'warn' });
+  return view;
+}
+
+/**
+ * The sentence for a change that could not be made: { action: 'on' | 'off' | 'repair', status, body, error }.
+ * An answer without claudeHooks after a change that worked is a server started before this (said as such).
+ */
+export function describeClaudeHooksSaveFailure({ action = 'on', status = 0, body = null, error = null } = {}, { tx }) {
+  const verb = ['on', 'off', 'repair'].includes(action) ? action : 'on';
+  const code = Number(status) || 0;
+  if (!code) return tx(`${K}.save.noAnswer.${verb}`);
+  if (code === 403 && REFUSED_CODES.has(String(body?.code || ''))) return tx(`${K}.save.refused.${verb}`);
+  return tx(`${K}.save.failed.${verb}`, { reason: clean(body?.error || error) || `HTTP ${code}` });
+}

package/neural-interface/public/shared/settings/settings-data.js

@@ -0,0 +1,90 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Settings' reads
+// ═══════════════════════════════════════════
+// The answers the Settings modal is built from (openSettingsModal in
+// ui-settings.js), kept in the page's data cache (data-cache.js): Settings
+// opens from them at once and they are read again in the background once they
+// are old. Only a first open waits for them; the launch prefetch reads them
+// once the page has painted, and closing Settings reads them again, so the next
+// open shows what was changed in this one. Each open gets its own copy (the
+// panes edit theirs in place). Never kept in sessionStorage: this is
+// configuration.
+// No DOM: runs under node --test as well.
+
+import { createDataCache } from '../data-cache.js';
+
+const MINUTE = 60_000;
+
+// `ok`: the endpoint says it answered (`{ ok: true, … }`). `raw`: the status and body are kept as they came, for
+// a reader that tells the states apart itself (settings-greeting.js, settings-user-context.js).
+const okBody = (body) => !!body && typeof body === 'object' && body.ok !== false && !body.error;
+export const SETTINGS_READS = Object.freeze({
+  settings: { url: '/api/settings', accept: okBody },
+  connections: { url: '/api/connections', accept: (body) => Array.isArray(body?.connections) },
+  // Raw: the hooks' row tells a refusal, an old server and an unreadable file apart (settings-claude-hooks.js).
+  integrations: { url: '/api/claude-code/integrations', raw: true },
+  skills: { url: '/api/claude-code/skills', accept: (body) => body?.ok === true },
+  // The tunnel changes by itself (starting, stopping from the Share menu): asked again after a few seconds.
+  tunnel: { url: '/api/tunnel/status', accept: (body) => body?.ok === true, ttlMs: 10_000 },
+  mcpKey: { url: '/api/mcp-key', accept: (body) => body?.ok === true },
+  openclaw: { url: '/api/bridges/openclaw', accept: (body) => body?.ok === true },
+  greeting: { url: '/api/greeting', raw: true },
+  setup: { url: '/api/setup/status', accept: (body) => body?.ok === true },
+  cli: { url: '/api/cli/config', accept: (body) => body?.ok === true },
+  toolPermissions: { url: '/api/claude-code/tool-permissions', accept: (body) => body?.ok === true },
+  toolCategories: { url: '/api/claude-code/tool-categories', accept: (body) => body?.ok === true, ttlMs: 10 * MINUTE },
+  discord: { url: '/api/discord/config', accept: (body) => body?.ok === true },
+  skins: { url: '/api/skins', accept: (body) => body?.ok === true },
+  icons: { url: '/api/file-icons', accept: (body) => body?.ok === true },
+  youtube: { url: '/api/youtube/config', accept: (body) => body?.ok === true },
+  typesafe: { url: '/api/typesafe/config', accept: (body) => body?.ok === true },
+  userContext: { url: '/api/assistant/user-context', raw: true },
+  workerGuard: { url: '/api/assistant/worker-guard', raw: true },
+});
+
+const caches = Object.fromEntries(Object.entries(SETTINGS_READS).map(([name, spec]) => [name, createDataCache(`settings:${name}`, {
+  ttlMs: spec.ttlMs || MINUTE,
+  load: async () => {
+    const res = await fetch(spec.url);
+    if (spec.raw) return { status: res.status, body: await res.json().catch(() => null) };
+    if (!res.ok) throw new Error(`${spec.url}: HTTP ${res.status}`);
+    return res.json();
+  },
+  accept: spec.raw ? (value) => value?.status >= 200 && value.status < 300 && !!value.body : spec.accept,
+})]));
+
+function copy(value) {
+  try { return typeof structuredClone === 'function' ? structuredClone(value) : JSON.parse(JSON.stringify(value)); } catch { return value; }
+}
+
+/**
+ * Every read, as Promise.allSettled gives them: `{ [name]: { status: 'fulfilled', value } | { status: 'rejected',
+ * reason } }`. A kept answer is given at once (a copy of it) and read again in the background when it is old;
+ * a read never made waits for its request, as the modal always did.
+ */
+export async function readSettingsData() {
+  const names = Object.keys(SETTINGS_READS);
+  const settled = await Promise.allSettled(names.map((name) => caches[name].get('')));
+  return Object.fromEntries(names.map((name, i) => [name, settled[i].status === 'fulfilled' ? { status: 'fulfilled', value: copy(settled[i].value) } : settled[i]]));
+}
+
+/** Read whatever is not fresh now (launch prefetch); resolves when done, never rejects. */
+export function prefetchSettingsData() {
+  return Promise.allSettled(Object.values(caches).map((cache) => cache.prefetch(''))).then(() => undefined);
+}
+
+/**
+ * The answers are due (Settings closed: something may have been changed in it; a sync event said so): the next
+ * open waits for none of them that are read again in time, and `names` limits it to some.
+ */
+export function refreshSettingsData(names = null) {
+  for (const [name, cache] of Object.entries(caches)) {
+    if (names && !names.includes(name)) continue;
+    cache.invalidate('', { refetch: true });
+  }
+}
+
+/** True when every read has an answer kept (Settings can open without waiting). */
+export function settingsDataReady() {
+  return Object.values(caches).every((cache) => cache.has(''));
+}

package/neural-interface/public/shared/settings/settings-ia.js

@@ -103,7 +103,7 @@ export const SETTINGS_PAGES = [
     id: 'connected-tools', key: 'connected_tools', group: 'tools', icon: 'mcp',
     panes: [{ id: 'mcp' }, { id: 'morelogin', titleKey: k('pane.morelogin') }],
     sections: [
-      { id: 'stg-sec-tool-profiles',  key: 'tool_profiles',         state: 'open' },
+      { id: 'stg-sec-default-tools',  key: 'default_tools',         state: 'open' },
       { id: 'stg-sec-added-servers',  key: 'added_servers',         state: 'open' },
       { id: 'stg-sec-ml-connection',  key: 'morelogin_connection',  state: 'open' },
       { id: 'stg-sec-ml-profiles',    key: 'morelogin_profiles',    state: 'open' },
@@ -184,6 +184,19 @@ export const SETTINGS_PAGES = [
       { id: 'stg-sec-2d-graph',      key: 'd2_graph',               state: 'advanced', variant: 'graphics' },
     ],
   },
+  {
+    // The software itself (settings-app-pane.js): updates, start at login, the window, the folders and a restart.
+    // A row shows where it applies: the desktop app's own settings come from the app (window.synabunDesktop.app),
+    // an npm or Git install's from GET /api/system/app; settings-app.js decides what each install shows.
+    id: 'app', key: 'app', group: 'app', icon: 'app',
+    panes: [{ id: 'app' }],
+    sections: [
+      { id: 'stg-sec-app-updates',     key: 'updates',     state: 'open' },
+      { id: 'stg-sec-app-startup',     key: 'startup',     state: 'open' },
+      { id: 'stg-sec-app-window',      key: 'window',      state: 'open' },
+      { id: 'stg-sec-app-maintenance', key: 'maintenance', state: 'open' },
+    ],
+  },
   {
     // The last page: version, links, system and dependencies (settings-about-pane.js, GET /api/system/about).
     // Its header (icon, version, Check for updates, Copy info) is not a section: it is always shown.
@@ -240,7 +253,7 @@ export const SETTINGS_CONTROLS = {
   'stg-sec-manual-setup': 'SET029 SET030 SET031 SET032',
   'cc-cli-paths': 'CLI001 CLI002 CLI007 CLI003 CLI004 CLI005 CLI006',
   'stg-sec-opencode-service': 'OCP001 OCP002 OCP003 OCP004 OCP005 OCP021 OCP022 OCP019',
-  'stg-sec-opencode-behavior': 'OCP013 OCP014 OCP015 OCP016',
+  'stg-sec-opencode-behavior': 'OCP013 OCP015 OCP016',
   'stg-sec-opencode-tools': 'OCP017',
   'stg-sec-opencode-history': 'OCP023 OCP018',
   'stg-sec-database': 'GEN015 GEN001 GEN002 GEN003 GEN016 GEN004 GEN005 GEN006 GEN017 DB003',
@@ -255,18 +268,18 @@ export const SETTINGS_CONTROLS = {
   'bcg-identity': 'BRW021 BRW022 BRW023 BRW024 BRW025',
   'bcg-viewport': 'BRW026 BRW027 BRW028 BRW029 BRW030 BRW031 BRW032',
   'bcg-advanced': 'BRW033 BRW034 BRW035 BRW036 BRW037 BRW038 BRW039 BRW040 BRW041 BRW042 BRW043 BRW044 BRW045 BRW046 BRW047 BRW048 BRW049 BRW050 BRW051 BRW052 BRW053 BRW054 BRW055 BRW056 BRW057 BRW058 BRW059 BRW060 BRW061 BRW062 BRW063 BRW064 BRW065 BRW066 BRW067 BRW068 BRW069 BRW070 BRW071 BRW072 BRW073 BRW074 BRW075 BRW076 BRW077 BRW078 BRW079 BRW080',
-  'stg-sec-tool-profiles': 'MCP022 MCP024',
+  'stg-sec-default-tools': 'MCP022 MCP024 MCP005 MCP004',
   'stg-sec-added-servers': 'MCP026 MCP006 MCP007 MCP008 MCP009 MCP010 MCP011 MCP012 MCP013 MCP014 MCP015 MCP027 MCP016 MCP017 MCP018 MCP019 MCP020 MCP021',
   'stg-sec-ml-connection': 'ML015 ML001 ML002 ML003',
   'stg-sec-ml-profiles': 'ML004 ML005 ML006 ML016 ML017 ML018 ML019',
   'stg-sec-ml-credentials': 'ML007 ML008 ML009 ML010 ML011',
   'stg-sec-ml-server': 'ML012 ML013 ML014',
   'stg-sec-skills': 'SKL004 SKL001',
-  'stg-sec-tool-permissions': 'PER012 PER001 PER002 PER003 PER004 PER005 PER006 PER007 PER008 PER009 PER010 PER011',
+  'stg-sec-tool-permissions': 'PER012 PER001 PER002 PER003 PER004 PER005 PER006 PER008 PER009 PER010 PER011',
   'stg-sec-editor-editing': 'EDT014 EDT015 EDT016 EDT017 EDT018 EDT019 EDT020 EDT021 EDT022 EDT023',
   'stg-sec-editor-ai': 'EDT001 EDT002 EDT003 EDT004 EDT005 EDT006 EDT007 EDT008 EDT009 EDT010 EDT011 EDT012 EDT013',
   'stg-sec-greetings': 'AUT058 AUT059 AUT060',
-  'stg-sec-automation-behavior': 'AUT053 AUT054 AUT055 AUT056 AUT057 AUT046 AUT036 AUT037 AUT038 AUT039 AUT040 AUT041 AUT028 AUT029 AUT030 AUT031 AUT032 AUT033 AUT034 AUT035',
+  'stg-sec-automation-behavior': 'AUT053 AUT054 AUT055 AUT061 AUT062 AUT056 AUT057 AUT046 AUT036 AUT037 AUT038 AUT039 AUT040 AUT041 AUT028 AUT029 AUT030 AUT031 AUT032 AUT033 AUT034 AUT035',
   'stg-sec-online-access': 'AUT048 AUT042 AUT043 AUT044 AUT045 AUT049 AUT050 AUT051 AUT052',
   'stg-sec-social': 'SOC003 SOC001 SOC002',
   'stg-sec-youtube': 'YT017 YT001 YT002 YT003 YT004 YT005 YT006 YT007 YT008 YT009 YT010 YT011 YT012 YT013 YT014 YT015 YT016 YT018',
@@ -290,6 +303,10 @@ export const SETTINGS_CONTROLS = {
   'stg-sec-visual-tuning': 'UI003 UI004 UI005 UI006 UI007 UI008 UI009 UI010',
   'stg-sec-file-icons': 'ICO001 ICO003 ICO002 ICO004 ICO005',
   'stg-sec-2d-graph': 'GFX001 GFX002 GFX003 GFX004 GFX005 GFX006 GFX007 GFX008',
+  'stg-sec-app-updates': 'SYS001 SYS002 SYS003',
+  'stg-sec-app-startup': 'SYS004 SYS005',
+  'stg-sec-app-window': 'SYS006 SYS007 SYS008',
+  'stg-sec-app-maintenance': 'SYS009 SYS010 SYS011',
   'stg-sec-about-dependencies': 'ABT003',
 };
 /** Controls of a page that sit outside its sections (a pane's save bar, the tabs of a pane). */
@@ -332,7 +349,7 @@ export const SETTINGS_TAB_ALIASES = {
   judgments:     { page: 'ai-decisions',    section: 'jv-sec-connection' },
   projects:      { page: 'projects',        section: 'stg-sec-workspaces' },
   browser:       { page: 'browser',         section: 'setup-browser' },
-  mcp:           { page: 'connected-tools', section: 'stg-sec-tool-profiles' },
+  mcp:           { page: 'connected-tools', section: 'stg-sec-default-tools' },
   morelogin:     { page: 'connected-tools', section: 'stg-sec-ml-connection' },
   skills:        { page: 'tool-access',     section: 'stg-sec-skills' },
   permissions:   { page: 'tool-access',     section: 'stg-sec-tool-permissions' },

package/neural-interface/public/shared/settings/settings-opencode.js

@@ -0,0 +1,89 @@
+// ═══════════════════════════════════════════
+// SETTINGS — the OpenCode SynaBun found, in words
+// ═══════════════════════════════════════════
+//
+// What `GET /api/opencode/status` (`installed`, server.js opencodeInstallState) and
+// `POST /api/cli/detect/opencode` (`support`) say about the OpenCode binary: which version it is,
+// or why SynaBun does not drive it and how to get OpenCode 2. The server decides
+// (lib/opencode-protocol.js opencodeSupportFor gives `code`); the page words it in its own
+// language. Pure: no DOM and no imports, so node runs it (tests/settings-opencode-view.test.mjs).
+//
+//   describeOpencodeInstall(installed, { th, tx })   → { tone, status, html, text }
+//
+// `installed` is `{ installed, version, supported, code, path, minimum, commands }`: `supported`
+// is true for a version SynaBun drives, false for one it refuses (`code` says why: 'opencode1',
+// 'outdated', 'newer'), null while the version is not known (a command line, a version that could
+// not be read: the serve's own answer decides when it starts). `th(key, html)` and `tx(key, params)`
+// are the kit's: `th` escapes the string and puts raw HTML in its `{names}` (every value here is
+// escaped first), `tx` gives the plain text, for a toast.
+
+const esc = (value) => String(value ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const code = (text) => `<code class="stg-code">${esc(text)}</code>`;
+
+// Written out whole, so the key checks find every one (tests/settings-ia.test.mjs, build_en.py --used).
+const REFUSAL_KEYS = {
+  opencode1: 'settings.redesign.opencode.refusal.opencode1',
+  outdated: 'settings.redesign.opencode.refusal.outdated',
+  newer: 'settings.redesign.opencode.refusal.newer',
+};
+const UPDATE_COMMAND = 'opencode upgrade';
+
+/** "2.1.4" from "opencode v2.1.4" (a prerelease kept whole), as the server's own sentence shows it. */
+export function shownOpencodeVersion(version) {
+  return String(version ?? '').trim().replace(/^opencode\s+/i, '').replace(/^v(?=\d)/i, '');
+}
+
+function commandList(commands) {
+  return (Array.isArray(commands) ? commands : []).map((command) => String(command ?? '').trim()).filter(Boolean);
+}
+
+/** The install commands as one phrase: `a`, or `a or b` (each its own <code> in the HTML). */
+export function opencodeCommandsPhrase(commands, { th, tx }) {
+  const list = commandList(commands);
+  const join = (words, wrap, translate) => words.slice(1).reduce(
+    (phrase, command) => translate('settings.redesign.opencode.commandOr', { first: phrase, second: wrap(command) }),
+    wrap(words[0]),
+  );
+  if (!list.length) return { html: '', text: '' };
+  return { html: join(list, code, th), text: join(list, (command) => command, tx) };
+}
+
+/**
+ * The note under the OpenCode service bar: `tone` '' | 'ok' | 'warn', `status` the short word for
+ * the status bar when OpenCode cannot run ('notInstalled' | 'notSupported' | null), `html` the note
+ * (empty: no note), `text` the same sentence as plain text.
+ */
+export function describeOpencodeInstall(installed, { th, tx }) {
+  const none = { tone: '', status: null, html: '', text: '' };
+  if (!installed || typeof installed !== 'object') return none;
+  const commands = opencodeCommandsPhrase(installed.commands, { th, tx });
+  if (installed.installed === false) {
+    return {
+      tone: 'warn',
+      status: 'notInstalled',
+      html: th('settings.redesign.opencode.notInstalled', { commands: commands.html }),
+      text: tx('settings.redesign.opencode.notInstalled', { commands: commands.text }),
+    };
+  }
+  const version = shownOpencodeVersion(installed.version);
+  const path = String(installed.path || 'opencode');
+  if (installed.supported === false && REFUSAL_KEYS[installed.code]) {
+    const key = REFUSAL_KEYS[installed.code];
+    const minimum = String(installed.minimum || '');
+    return {
+      tone: 'warn',
+      status: 'notSupported',
+      html: th(key, { path: code(path), version: esc(version), commands: commands.html, update: code(UPDATE_COMMAND), minimum: esc(minimum) }),
+      text: tx(key, { path, version, commands: commands.text, update: UPDATE_COMMAND, minimum }),
+    };
+  }
+  if (installed.supported === true && version) {
+    return {
+      tone: 'ok',
+      status: null,
+      html: th('settings.redesign.opencode.installedVersion', { version: esc(version), path: code(path) }),
+      text: tx('settings.redesign.opencode.installedVersion', { version, path }),
+    };
+  }
+  return none;
+}