synabun 1.3.0 → 2.0.0

package/neural-interface/lib/assistant-evidence.js

@@ -0,0 +1,236 @@
+/**
+ * What a dispatched worker actually ran in one turn: its commands (with an
+ * exit and the end of the output), the results of tools that can show success
+ * or failure, and the files it edited. The worker-claim judgment reads this
+ * as the evidence behind a "tests pass" (the Stop hook reads the same shape
+ * from a transcript: hooks/claude-code/shared.mjs readTurnActivity).
+ *
+ * Pure: fed from the dispatcher's provider-event stream (no adapter changes;
+ * every provider emits its tool events before its turn resolves).
+ *   Claude    SDK messages: tool_use blocks, then tool_result blocks matched by
+ *             id (+ tool_use_result, the tool's structured output)
+ *   Codex     item.completed: command_execution, mcp_tool_call, file_change, error
+ *   OpenCode  message.part.updated tool parts, keyed by callID, last write wins,
+ *             counted once completed or errored
+ */
+
+import { isTestOrBuildCommand } from '../../hooks/claude-code/shared.mjs';
+
+const MAX_KEPT = 24;          // commands / results kept per turn
+const MAX_PENDING = 200;      // Claude tool uses waiting for their result; OpenCode parts
+const SNAPSHOT_COMMANDS = 8;
+const SNAPSHOT_RESULTS = 6;
+const SNAPSHOT_FILES = 20;
+const TAIL = 500;
+const COMMAND_CLIP = 300;
+
+// Mirrors the hooks (shared.mjs): results that say nothing about whether the work succeeded.
+const QUIET_TOOLS = new Set(['Read', 'Grep', 'Glob', 'LS', 'ToolSearch', 'TodoWrite', 'NotebookRead',
+  'EnterPlanMode', 'ExitPlanMode', 'AskUserQuestion', 'Edit', 'Write', 'NotebookEdit', 'MultiEdit']);
+// SynaBun memory tools as Claude (mcp__SynaBun__recall), OpenCode (SynaBun_recall) and Codex (SynaBun.recall) name them.
+const MEMORY_TOOL = /(?:^|__)Syna[Bb]un[._]+(?:remember|reflect|recall|memories|forget|restore|sync)$/;
+const CLAUDE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+const OPENCODE_EDIT_TOOLS = new Set(['edit', 'write', 'patch', 'multiedit']);
+const OPENCODE_QUIET = /^(?:read|grep|glob|list|ls|todo\w*)$/i;
+
+function clipLine(value, max) {
+  const s = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return s.length > max ? `${s.slice(0, Math.max(0, max - 1))}…` : s;
+}
+function tailText(value, max = TAIL) {
+  const s = String(value ?? '').trim();
+  return s.length > max ? `…${s.slice(s.length - (max - 1))}` : s;
+}
+function blockText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map((b) => (b && b.type === 'text' ? b.text || '' : '')).filter(Boolean).join('\n');
+  return '';
+}
+const quietTool = (name) => QUIET_TOOLS.has(name) || MEMORY_TOOL.test(name);
+
+export function createTurnEvidence() {
+  return { seq: 0, commands: [], results: [], files: new Set(), pending: new Map(), parts: new Map() };
+}
+
+function pushCommand(acc, entry) {
+  acc.commands.push({ order: ++acc.seq, ...entry });
+  if (acc.commands.length > MAX_KEPT) acc.commands.shift();
+}
+/** Over the cap, the oldest success goes first: an error is the evidence that matters. */
+function pushResult(acc, entry) {
+  acc.results.push({ order: ++acc.seq, ...entry });
+  if (acc.results.length > MAX_KEPT) {
+    const index = acc.results.findIndex((r) => !r.is_error);
+    acc.results.splice(index === -1 ? 0 : index, 1);
+  }
+}
+function addFile(acc, path) {
+  if (typeof path === 'string' && path.trim() && acc.files.size < MAX_PENDING) acc.files.add(path.trim());
+}
+
+// ── Claude ──────────────────────────────────────────────────────────────────
+function bashOutput(block, tur) {
+  if (tur && typeof tur === 'object') {
+    const joined = [tur.stdout, tur.stderr].filter((s) => typeof s === 'string' && s).join('\n');
+    if (joined) return joined;
+  }
+  return blockText(block?.content) || (typeof tur === 'string' ? tur : '');
+}
+/** The hooks' bashExit (shared.mjs), for one tool_result. */
+function bashExit(input, block, tur) {
+  if (tur && typeof tur === 'object') {
+    if (tur.interrupted === true) return 'interrupted';
+    if (tur.backgroundTaskId) return 'background';
+  }
+  if (block?.is_error === true) return /interrupted by user/i.test(bashOutput(block, tur)) ? 'interrupted' : 'error';
+  return input?.run_in_background ? 'background' : 'ok';
+}
+function recordClaude(acc, event) {
+  const blocks = Array.isArray(event?.message?.content) ? event.message.content : [];
+  if (event.type === 'assistant') {
+    for (const block of blocks) {
+      if (block?.type !== 'tool_use' || !block.id) continue;
+      const name = String(block.name || '');
+      const input = block.input && typeof block.input === 'object' ? block.input : {};
+      if (CLAUDE_EDIT_TOOLS.has(name)) addFile(acc, input.file_path || input.notebook_path);
+      acc.pending.set(block.id, { name, input, order: ++acc.seq });
+      if (acc.pending.size > MAX_PENDING) acc.pending.delete(acc.pending.keys().next().value);
+    }
+    return;
+  }
+  if (event.type !== 'user') return;
+  const resultBlocks = blocks.filter((block) => block?.type === 'tool_result' && block.tool_use_id);
+  // tool_use_result is the structured output of the message's one tool result.
+  const tur = resultBlocks.length === 1 ? event.tool_use_result : undefined;
+  for (const block of resultBlocks) {
+    const use = acc.pending.get(block.tool_use_id);
+    if (!use) continue;
+    acc.pending.delete(block.tool_use_id);
+    if (use.name === 'Bash') {
+      pushCommand(acc, {
+        command: clipLine(use.input.command, COMMAND_CLIP),
+        exit: bashExit(use.input, block, tur),
+        output_tail: tailText(bashOutput(block, tur)),
+      });
+      continue;
+    }
+    if (quietTool(use.name)) continue;
+    pushResult(acc, { tool: use.name, is_error: block.is_error === true, tail: tailText(blockText(block.content) || (typeof tur === 'string' ? tur : '')) });
+  }
+}
+
+// ── Codex ───────────────────────────────────────────────────────────────────
+function mcpResultText(item) {
+  if (item?.error?.message) return String(item.error.message);
+  const content = Array.isArray(item?.result?.content) ? item.result.content : [];
+  return content.map((c) => (c && typeof c.text === 'string' ? c.text : '')).filter(Boolean).join('\n');
+}
+function recordCodex(acc, event) {
+  if (event?.type !== 'item.completed' || !event.item) return;
+  const item = event.item;
+  if (item.type === 'command_execution') {
+    const code = item.exit_code;
+    const exit = typeof code === 'number' ? (code === 0 ? 'ok' : 'error')
+      : (item.status === 'failed' || item.status === 'declined' ? 'error' : 'unknown');
+    pushCommand(acc, { command: clipLine(item.command, COMMAND_CLIP), exit, output_tail: tailText(item.aggregated_output || '') });
+  } else if (item.type === 'mcp_tool_call') {
+    const tool = `${item.server || 'mcp'}.${item.tool || 'tool'}`;
+    if (!quietTool(tool)) pushResult(acc, { tool, is_error: item.status === 'failed', tail: tailText(mcpResultText(item)) });
+  } else if (item.type === 'file_change') {
+    const paths = (Array.isArray(item.changes) ? item.changes : []).map((c) => c?.path).filter(Boolean);
+    for (const path of paths) addFile(acc, path);
+    if (item.status === 'failed') pushResult(acc, { tool: 'apply_patch', is_error: true, tail: tailText(`patch failed: ${paths.join(', ')}`) });
+  } else if (item.type === 'error') {
+    pushResult(acc, { tool: 'error', is_error: true, tail: tailText(item.message || 'error') });
+  }
+}
+
+// ── OpenCode ────────────────────────────────────────────────────────────────
+function recordOpenCode(acc, eventType, event) {
+  if (!/^message[.:]part[.:]updated$/i.test(String(eventType || ''))) return;
+  const part = event?.part;
+  if (!part || part.type !== 'tool') return;
+  const state = part.state && typeof part.state === 'object' ? part.state : {};
+  if (state.status !== 'completed' && state.status !== 'error') return;
+  const key = String(part.callID || part.id || '');
+  if (!key) return;
+  const tool = String(part.tool || '');
+  const input = state.input && typeof state.input === 'object' ? state.input : {};
+  const failed = state.status === 'error';
+  const text = failed ? String(state.error || '') : String(state.output ?? '');
+  let record = null;
+  if (tool === 'bash') {
+    // metadata.exit is not in the SDK types: read defensively.
+    const exitCode = state.metadata && typeof state.metadata === 'object' ? state.metadata.exit : undefined;
+    const exit = failed ? 'error' : typeof exitCode === 'number' ? (exitCode === 0 ? 'ok' : 'error') : 'unknown';
+    record = { kind: 'command', entry: { command: clipLine(input.command, COMMAND_CLIP), exit, output_tail: tailText(text) } };
+  } else if (OPENCODE_EDIT_TOOLS.has(tool)) {
+    addFile(acc, input.filePath || input.file_path || input.path);
+    if (failed) record = { kind: 'result', entry: { tool, is_error: true, tail: tailText(text) } };
+  } else if (!OPENCODE_QUIET.test(tool) && !quietTool(tool)) {
+    record = { kind: 'result', entry: { tool, is_error: failed, tail: tailText(text) } };
+  }
+  if (!record) return;
+  const previous = acc.parts.get(key);
+  acc.parts.set(key, { order: previous?.order ?? ++acc.seq, ...record });
+  if (acc.parts.size > MAX_PENDING) acc.parts.delete(acc.parts.keys().next().value);
+}
+
+/** Fold one provider-event payload ({ provider, eventType?, event }) into the turn's evidence. */
+export function recordProviderEvent(acc, payload = {}) {
+  if (!acc || !payload || typeof payload !== 'object') return acc;
+  const event = payload.event && typeof payload.event === 'object' ? payload.event : {};
+  if (payload.provider === 'claude-code') {
+    if (event.type === 'assistant' || event.type === 'user') recordClaude(acc, event);
+  } else if (payload.provider === 'codex') recordCodex(acc, event);
+  else if (payload.provider === 'opencode') recordOpenCode(acc, payload.eventType || event.type, event);
+  return acc;
+}
+
+/**
+ * The turn's evidence as the judgment reads it: the last 8 commands, ≤6 tool
+ * results (errors first, then the most recent, in the order they happened),
+ * ≤20 edited files, the test/build checks, and whether the turn exposed
+ * anything at all (a claim is not judged without evidence).
+ */
+export function evidenceSnapshot(acc) {
+  if (!acc) return { commands: [], results: [], files: [], checks: [], hasEvidence: false };
+  const commands = [...acc.commands];
+  const results = [...acc.results];
+  for (const part of acc.parts.values()) (part.kind === 'command' ? commands : results).push({ order: part.order, ...part.entry });
+  // A Bash call with no result by the end of the turn: interrupted, or left in the background.
+  for (const use of acc.pending.values()) {
+    if (use.name !== 'Bash') continue;
+    commands.push({ order: use.order, command: clipLine(use.input.command, COMMAND_CLIP), exit: use.input.run_in_background ? 'background' : 'interrupted', output_tail: '' });
+  }
+  commands.sort((a, b) => a.order - b.order);
+  results.sort((a, b) => a.order - b.order);
+  const errors = results.filter((r) => r.is_error).slice(-SNAPSHOT_RESULTS);
+  const rest = results.filter((r) => !r.is_error).slice(-(SNAPSHOT_RESULTS - errors.length));
+  const chosen = [...errors, ...rest].sort((a, b) => a.order - b.order);
+  const bare = (c) => ({ command: c.command, exit: c.exit, output_tail: c.output_tail });
+  return {
+    commands: commands.slice(-SNAPSHOT_COMMANDS).map(bare),
+    results: chosen.map((r) => ({ tool: r.tool, is_error: r.is_error, tail: r.tail })),
+    files: [...acc.files].slice(0, SNAPSHOT_FILES),
+    checks: commands.filter((c) => isTestOrBuildCommand(c.command)).slice(-10).map(bare),
+    hasEvidence: commands.length > 0 || results.length > 0,
+  };
+}
+
+const clipCommand = (command, max = 80) => clipLine(command, max);
+
+/** One line of deterministic evidence for an unverified claim (the Stop hook's claimEvidence). */
+export function claimEvidenceLine(snapshot) {
+  const checks = Array.isArray(snapshot?.checks) ? snapshot.checks : [];
+  if (!checks.length) return 'no test/build command ran this turn';
+  const last = checks[checks.length - 1];
+  const cmd = `\`${clipCommand(last.command)}\``;
+  if (last.exit === 'error') return `the last ${cmd} exited with an error`;
+  if (last.exit === 'interrupted') return `the last ${cmd} was interrupted`;
+  if (last.exit === 'background') return `${cmd} was still running in the background`;
+  const bash = Array.isArray(snapshot?.commands) ? snapshot.commands : [];
+  const lastRun = bash[bash.length - 1];
+  if (lastRun && lastRun.exit === 'error') return `the last command, \`${clipCommand(lastRun.command)}\`, exited with an error`;
+  return `the last check, ${cmd}, exited ok, but the message reports more than this turn's output shows`;
+}

package/neural-interface/lib/assistant-hidden-models.js

@@ -0,0 +1,272 @@
+// ═══════════════════════════════════════════
+// SynaBun — Assistant hidden models (every provider)
+// ═══════════════════════════════════════════
+//
+// The models the user switched off in the Assistant's Models manager. The
+// router, the dispatcher, the catalog (routing sheet, agent_catalog) and every
+// Assistant model menu leave them out. One denylist per provider, so new
+// models start enabled:
+//   claude-code, codex → ~/.synabun/data/assistant-hidden-models.json
+//   opencode           → the Settings → OpenCode store (lib/opencode-hidden-models.js),
+//                        so both screens edit the same list
+// Matching (lib/assistant-catalog.js hiddenModelId): the id, or the row's
+// resolved model at the same context window, case-insensitive; context
+// variants ("opus" / "opus[1m]", "gpt-x" / "gpt-x[extended]") hide
+// independently. OpenCode ids match full or bare. Re-read when the file's
+// mtime changes; writes are atomic.
+
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { Router } from 'express';
+import { CATALOG_PROVIDERS, baseModelId, canonicalModelId, contextSuffix } from './assistant-catalog.js';
+import { HIDDEN_MODELS_SYNC_TYPE as OPENCODE_SYNC_TYPE } from './opencode-hidden-models.js';
+
+export const ASSISTANT_HIDDEN_SYNC_TYPE = 'assistant:hidden-models-changed';
+export const OWN_PROVIDERS = Object.freeze(['claude-code', 'codex']);
+export const MAX_HIDDEN_PER_PROVIDER = 2000;
+
+function hiddenError(code, message, status = 400, extra = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = status;
+  Object.assign(error, extra);
+  return error;
+}
+function arr(value) { return Array.isArray(value) ? value : []; }
+
+/** Unique (case-insensitive), sorted model ids; blanks and oversize values are dropped. */
+export function normalizeModelIds(list) {
+  const out = new Map();
+  for (const value of arr(list)) {
+    const id = typeof value === 'string' ? value.trim() : '';
+    if (!id || id.length > 300) continue;
+    if (!out.has(id.toLowerCase())) out.set(id.toLowerCase(), id);
+    if (out.size >= MAX_HIDDEN_PER_PROVIDER) break;
+  }
+  return [...out.values()].sort();
+}
+
+/** The Claude Code / Codex store: { version, updatedAt, providers: { 'claude-code': [], codex: [] } }. */
+export function createAssistantHiddenModelsStore({ path, now = Date.now, log = () => {} } = {}) {
+  if (!path) throw new Error('createAssistantHiddenModelsStore requires path');
+  const emptyProviders = () => Object.fromEntries(OWN_PROVIDERS.map((p) => [p, []]));
+  const empty = Object.freeze({ providers: emptyProviders(), version: 0, updatedAt: null });
+  let cached = null; // { mtimeMs, value }
+  const listeners = new Set();
+
+  function mtime() { try { return statSync(path).mtimeMs; } catch { return 0; } }
+  function read() {
+    const m = mtime();
+    if (cached && cached.mtimeMs === m) return cached.value;
+    let value = empty;
+    if (m) {
+      try {
+        const raw = JSON.parse(readFileSync(path, 'utf8')) || {};
+        const providers = emptyProviders();
+        for (const p of OWN_PROVIDERS) providers[p] = normalizeModelIds(raw.providers?.[p]);
+        value = { providers, version: Number(raw.version) || 0, updatedAt: raw.updatedAt || null };
+      } catch (error) { log('hidden-models:unreadable', error?.message || String(error)); value = cached?.value || empty; }
+    }
+    cached = { mtimeMs: m, value };
+    return value;
+  }
+  function list(provider) { return read().providers[provider] || []; }
+
+  /** Replace one provider's list. Returns { providers, version, updatedAt, changed }. */
+  function set(provider, ids) {
+    if (!OWN_PROVIDERS.includes(provider)) throw hiddenError('PROVIDER_INVALID', `provider must be one of ${OWN_PROVIDERS.join(', ')}`);
+    const current = read();
+    const nextList = normalizeModelIds(ids);
+    const changed = current.providers[provider].join('\n') !== nextList.join('\n');
+    if (!changed) return { ...current, changed: false };
+    const next = { version: current.version + 1, updatedAt: new Date(now()).toISOString(), providers: { ...current.providers, [provider]: nextList } };
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', 'utf8');
+    renameSync(tmp, path);
+    cached = { mtimeMs: mtime(), value: next };
+    for (const listener of listeners) { try { listener(next, { provider, changed: true }); } catch {} }
+    return { ...next, changed: true };
+  }
+
+  function onChange(fn) { listeners.add(fn); return () => listeners.delete(fn); }
+  return { read, list, set, onChange, path };
+}
+
+/**
+ * One view over both stores.
+ *   list(provider) → ids; all() → { 'claude-code', codex, opencode }
+ *   update(provider, { hide, show }) → { provider, hidden, changed, added, removed }
+ *   onChange(fn) → fn({ provider }) after either store changes
+ * OpenCode ids are "provider/model" (its store drops anything else); callers
+ * resolve bare ids first (the router does, from the catalog).
+ */
+export function createHiddenModels({ file, opencodeStore = null, now = Date.now, log = () => {} } = {}) {
+  const own = createAssistantHiddenModelsStore({ path: file, now, log });
+  const listeners = new Set();
+  const emit = (provider) => { for (const fn of listeners) { try { fn({ provider }); } catch {} } };
+  own.onChange((_value, meta) => emit(meta?.provider || null));
+  opencodeStore?.onChange?.(() => emit('opencode'));
+
+  function list(provider) {
+    if (provider === 'opencode') { try { return arr(opencodeStore?.list?.()); } catch { return []; } }
+    return OWN_PROVIDERS.includes(provider) ? own.list(provider) : [];
+  }
+  function all() { return Object.fromEntries(CATALOG_PROVIDERS.map((p) => [p, list(p)])); }
+
+  function update(provider, { hide = [], show = [] } = {}) {
+    if (!CATALOG_PROVIDERS.includes(provider)) throw hiddenError('PROVIDER_INVALID', `provider must be one of ${CATALOG_PROVIDERS.join(', ')}`);
+    if (provider === 'opencode' && !opencodeStore) throw hiddenError('PROVIDER_UNAVAILABLE', 'The OpenCode hidden-model store is not available.', 503);
+    const current = list(provider);
+    const key = (id) => String(id).trim().toLowerCase();
+    const hideIds = arr(hide).map((id) => String(id || '').trim()).filter(Boolean);
+    const showKeys = new Set(arr(show).map(key).filter(Boolean));
+    const next = new Map(current.map((id) => [key(id), id]));
+    for (const id of hideIds) if (!next.has(key(id))) next.set(key(id), id);
+    for (const k of showKeys) next.delete(k);
+    const nextList = [...next.values()];
+    const before = new Set(current.map(key));
+    const after = new Set(nextList.map(key));
+    const added = nextList.filter((id) => !before.has(key(id)));
+    const removed = current.filter((id) => !after.has(key(id)));
+    if (!added.length && !removed.length) return { provider, hidden: current, changed: false, added, removed };
+    const result = provider === 'opencode' ? opencodeStore.set(nextList) : own.set(provider, nextList);
+    return { provider, hidden: provider === 'opencode' ? result.models : result.providers[provider], changed: true, added, removed, version: result.version };
+  }
+
+  function onChange(fn) { listeners.add(fn); return () => listeners.delete(fn); }
+  return { list, all, update, onChange, store: own, path: file };
+}
+
+// ── resolving user-typed ids against the unfiltered catalog ─────────────────
+
+/**
+ * How well `want` names `row` (higher is better, 0 = no match): exact id 4,
+ * case-insensitive id 3, resolved model at the same context window or bare
+ * OpenCode id 2, label 1. The context suffix always counts: "opus" never
+ * names "opus[1m]".
+ */
+function rowScore(row, want) {
+  const id = String(row.id || '');
+  const lower = want.toLowerCase();
+  if (id === want) return 4;
+  if (id.toLowerCase() === lower) return 3;
+  if (row.provider === 'claude-code' && row.upstream && `${baseModelId(row.upstream)}${contextSuffix(id)}`.toLowerCase() === lower) return 2;
+  if (row.provider === 'opencode' && !want.includes('/') && id.split('/').slice(1).join('/').toLowerCase() === lower) return 2;
+  if (String(row.label || '').toLowerCase() === lower) return 1;
+  return 0;
+}
+
+function suggestionsFor(rowsByProvider, want, provider = null) {
+  const needle = String(want || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+  const score = (row) => { const id = String(row.id).toLowerCase().replace(/[^a-z0-9]/g, ''); let s = 0; for (const ch of new Set(needle)) if (id.includes(ch)) s += 1; if (id.includes(needle)) s += 10; return s; };
+  const rows = Object.entries(rowsByProvider).filter(([p]) => !provider || p === provider).flatMap(([p, list]) => list.map((row) => ({ ...row, provider: p })));
+  return rows.sort((a, b) => score(b) - score(a)).slice(0, 5).map((row) => ({ provider: row.provider, id: row.id }));
+}
+
+/**
+ * Resolve one id to { provider, id } for `action` ('hide' | 'show').
+ * `rowsByProvider` = every catalog row, hidden ones included; `hiddenByProvider`
+ * = the current lists (a model that left the catalog can still be shown again).
+ * A claude-* id the CLI accepts without listing it can be hidden too.
+ */
+export function resolveHiddenModelId({ id, provider = null, action = 'hide', rowsByProvider = {}, hiddenByProvider = {} }) {
+  const typed = String(id || '').trim();
+  if (!typed) throw hiddenError('MODEL_REQUIRED', 'Model id required.');
+  const providers = provider ? [provider] : CATALOG_PROVIDERS;
+  const candidates = [];
+  let want = typed;
+  for (const p of providers) {
+    want = canonicalModelId(p, typed);
+    let best = null;
+    for (const row of arr(rowsByProvider[p])) {
+      const s = rowScore({ ...row, provider: p }, want);
+      // A resolved-model match hides the resolved id itself, so every alias of
+      // it (default, opus, …) goes with it, at that context window only.
+      if (s && (!best || s > best.score)) best = { provider: p, id: s === 2 && p === 'claude-code' ? want.toLowerCase() : row.id, score: s };
+    }
+    if (!best && action === 'show') {
+      const lower = want.toLowerCase();
+      const hit = arr(hiddenByProvider[p]).find((h) => String(h).toLowerCase() === lower || (p === 'opencode' && !want.includes('/') && String(h).split('/').slice(1).join('/').toLowerCase() === lower));
+      if (hit) best = { provider: p, id: hit, score: 3 };
+    }
+    if (!best && p === 'claude-code' && /^claude-[a-z0-9.\-]+(\[1m\])?$/i.test(want)) best = { provider: p, id: want.toLowerCase(), score: 1 };
+    if (best) candidates.push(best);
+  }
+  want = typed;
+  if (!candidates.length) {
+    throw hiddenError('MODEL_UNKNOWN', `Unknown model "${want}"${provider ? ` for ${provider}` : ''}. Use an id from the Assistant's Models list.`, 400, { suggestions: suggestionsFor(rowsByProvider, want, provider) });
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const top = candidates.filter((c) => c.score === candidates[0].score);
+  if (top.length > 1) {
+    throw hiddenError('MODEL_AMBIGUOUS', `"${want}" names a model of ${top.map((c) => c.provider).join(' and ')}. Pass provider.`, 400, { suggestions: top.map((c) => ({ provider: c.provider, id: c.id })) });
+  }
+  return { provider: top[0].provider, id: top[0].id };
+}
+
+/**
+ * GET   /  → { ok, providers: { 'claude-code': [], codex: [], opencode: [] } }
+ * PATCH /  { provider?, hide?: [], show?: [] } → the new lists plus what changed.
+ *          A missing provider is inferred from the unfiltered catalog.
+ * Owner only (guests get 403). Broadcasts assistant:hidden-models-changed, and
+ * opencode:hidden-models-changed when the OpenCode list changed.
+ */
+export function createAssistantHiddenModelsRouter({ hiddenModels, catalog = null, opencodeStore = null, isGuestRequest = () => false, broadcastSync = () => {} } = {}) {
+  if (!hiddenModels) throw new Error('createAssistantHiddenModelsRouter requires hiddenModels');
+  const router = Router();
+  router.use((req, res, next) => {
+    if (isGuestRequest(req)) return res.status(403).json({ ok: false, code: 'OWNER_ONLY', error: 'Admin only' });
+    next();
+  });
+  router.get('/', (req, res) => {
+    try { res.json({ ok: true, providers: hiddenModels.all() }); }
+    catch (error) { res.status(500).json({ ok: false, error: error.message }); }
+  });
+  router.patch('/', async (req, res) => {
+    try {
+      const body = req.body || {};
+      const toList = (value) => (Array.isArray(value) ? value : (typeof value === 'string' && value.trim() ? [value] : []));
+      const hide = toList(body.hide);
+      const show = toList(body.show);
+      if (!hide.length && !show.length) throw hiddenError('MODELS_REQUIRED', 'Pass hide and/or show: arrays of model ids.');
+      if (hide.length + show.length > MAX_HIDDEN_PER_PROVIDER) throw hiddenError('TOO_MANY', `At most ${MAX_HIDDEN_PER_PROVIDER} ids per request.`);
+      const provider = body.provider ? String(body.provider).trim().toLowerCase() : null;
+      if (provider && !CATALOG_PROVIDERS.includes(provider)) throw hiddenError('PROVIDER_INVALID', `provider must be one of ${CATALOG_PROVIDERS.join(', ')}`);
+      let rowsByProvider = {};
+      try { rowsByProvider = (await catalog?.manageRows?.()) || {}; } catch {}
+      const hiddenByProvider = hiddenModels.all();
+      const plan = new Map(); // provider → { hide: [], show: [] }
+      const applied = [];
+      const add = (action, raw) => {
+        const hit = resolveHiddenModelId({ id: raw, provider, action, rowsByProvider, hiddenByProvider });
+        if (!plan.has(hit.provider)) plan.set(hit.provider, { hide: [], show: [] });
+        plan.get(hit.provider)[action].push(hit.id);
+        applied.push({ action, provider: hit.provider, id: hit.id, requested: String(raw) });
+      };
+      for (const id of hide) add('hide', id);
+      for (const id of show) add('show', id);
+      const results = [];
+      for (const [p, change] of plan) results.push(hiddenModels.update(p, change));
+      const changed = results.filter((r) => r.changed);
+      const providers = hiddenModels.all();
+      if (changed.length) {
+        broadcastSync({ type: ASSISTANT_HIDDEN_SYNC_TYPE, providers, changed: changed.map((r) => r.provider) });
+        const oc = changed.find((r) => r.provider === 'opencode');
+        if (oc) {
+          let version = oc.version;
+          try { version = opencodeStore?.read?.().version ?? version; } catch {}
+          broadcastSync({ type: OPENCODE_SYNC_TYPE, models: providers.opencode, version });
+        }
+      }
+      res.json({
+        ok: true, providers, changed: changed.length > 0, applied,
+        added: Object.fromEntries(changed.map((r) => [r.provider, r.added])),
+        removed: Object.fromEntries(changed.map((r) => [r.provider, r.removed])),
+      });
+    } catch (error) {
+      res.status(error.status || 500).json({ ok: false, error: error.message, code: error.code || null, suggestions: error.suggestions || undefined });
+    }
+  });
+  return router;
+}

package/neural-interface/lib/assistant-jev.js

@@ -0,0 +1,117 @@
+/**
+ * Jev in the SynaBun Assistant: the prompt-urgency judgment of the per-turn
+ * recall gate, and the worker-outcome / worker-claim judgments of dispatched
+ * runs (docs/judgments.md). Everything is injected by server.js, which imports
+ * it from mcp-server/dist in its own try/catch: a stale dist leaves the
+ * Assistant working without Jev (this wrapper is then simply not created).
+ *
+ * The wrapper owns the gates judge() does not: the master switch / key /
+ * kill switch (`enabled`), a 429's retry-after, and each rider's own surface
+ * switch (judge() only checks the lead surface). Thresholds are read on every
+ * call, so the Judgments tab changes them without a restart. Nothing here
+ * throws: a method resolves to null when no judgment was asked, and every
+ * caller keeps its pre-Jev behaviour for that case.
+ */
+
+const num = (value, fallback) => (value !== null && value !== undefined && value !== '' && Number.isFinite(Number(value)) ? Number(value) : fallback);
+
+export function createAssistantJev({
+  judgePrompt = null,
+  judgeWorkerOutcome = null,
+  surfaceConfig = () => null,
+  enabled = () => true,
+  retryAfterMs = () => 0,
+  annotate = () => {},
+} = {}) {
+  const settingsOf = (name) => { try { return surfaceConfig(name) || null; } catch { return null; } };
+  function waitMs() { try { return Math.max(0, num(retryAfterMs(), 0)); } catch { return 0; } }
+  /** Master switch, key and kill switch on, and no retry-after pending. */
+  function available() {
+    try { if (!enabled()) return false; } catch { return false; }
+    return waitMs() === 0;
+  }
+
+  /**
+   * How much searching memory would change the reply (surface prompt-urgency),
+   * the same state and question as the prompt hook, origin 'assistant'.
+   * → null (not asked) | { urgency: 'must'|'should'|'consider'|'skip'|null, confidence, logId }
+   */
+  async function promptUrgency({ prompt, project = null, sessionId = null, timeoutMs = null } = {}) {
+    const text = typeof prompt === 'string' ? prompt : '';
+    if (typeof judgePrompt !== 'function' || !text.trim() || !available()) return null;
+    const settings = settingsOf('prompt-urgency');
+    if (!settings?.enabled) return null;
+    // The caller's own budget (memory.recallBudgetMs) bounds it when given, not the
+    // surface timeout: that one is tuned for the prompt hook's 3 s budget, while here
+    // urgency runs beside retrieval + rerank, and live calls sit at ~1.0–1.1 s.
+    const surfaceTimeout = num(settings.timeoutMs, 1200);
+    const timeout = Math.max(1, Math.floor(num(timeoutMs, surfaceTimeout)));
+    let logId = null;
+    try {
+      const verdict = await judgePrompt(text, project || undefined, {
+        origin: 'assistant', sessionId: sessionId || null, project: project || null, timeoutMs: timeout,
+        onLogged: (id) => { logId = id ?? null; },
+      });
+      if (verdict && typeof verdict.urgency === 'string') return { urgency: verdict.urgency, confidence: num(verdict.confidence, 0), logId };
+    } catch { /* judge() never throws; a wrapper bug must not break recall either */ }
+    return { urgency: null, confidence: 0, logId };
+  }
+
+  /**
+   * One request about a worker's turn or failed run (lead worker-outcome, rider
+   * worker-claim). Only the questions whose surfaces are on are asked.
+   * → null (nothing asked) | { asked, logId, status, statusConfidence, cause,
+   *   causeConfidence, claimProbability, claimFlagged, verdict }
+   * `status` / `cause` are set only at confidence ≥ worker-outcome.minConfidence
+   * (`unclear` never); `claimFlagged` at P ≥ worker-claim.minProbability.
+   */
+  async function workerOutcome(input = {}, ask = {}, { runId = null, assistantSessionId = null, project = null } = {}) {
+    if (typeof judgeWorkerOutcome !== 'function' || !available()) return null;
+    const lead = settingsOf('worker-outcome');
+    const rider = settingsOf('worker-claim');
+    const want = {
+      status: ask.status === true && !!lead?.enabled,
+      cause: ask.cause === true && !!lead?.enabled,
+      claim: ask.claim === true && !!rider?.enabled,
+    };
+    if (!want.status && !want.cause && !want.claim) return null;
+    let logId = null;
+    let verdict = null;
+    try {
+      verdict = await judgeWorkerOutcome(input, want, {
+        origin: 'assistant', sessionId: assistantSessionId || runId || null, entityId: runId || undefined,
+        project: project && project !== 'global' ? project : null, onLogged: (id) => { logId = id ?? null; },
+      });
+    } catch { verdict = null; }
+    const minConfidence = num(lead?.minConfidence, 0.7);
+    const minProbability = num(rider?.minProbability, 0.9);
+    const out = {
+      asked: want, logId, status: null, statusConfidence: null, cause: null, causeConfidence: null,
+      claimProbability: null, claimFlagged: false, verdict: verdict || null,
+    };
+    if (!verdict || typeof verdict !== 'object') return out;
+    const statusConfidence = num(verdict.statusConfidence, 0);
+    if (want.status && typeof verdict.status === 'string' && verdict.status !== 'unclear' && statusConfidence >= minConfidence) {
+      out.status = verdict.status;
+      out.statusConfidence = statusConfidence;
+    }
+    const causeConfidence = num(verdict.causeConfidence, 0);
+    if (want.cause && typeof verdict.cause === 'string' && causeConfidence >= minConfidence) {
+      out.cause = verdict.cause;
+      out.causeConfidence = causeConfidence;
+    }
+    if (want.claim && num(verdict.claimProbability, null) !== null) {
+      out.claimProbability = Number(verdict.claimProbability);
+      out.claimFlagged = out.claimProbability >= minProbability;
+    }
+    return out;
+  }
+
+  /** Record what the caller did with a judgment on its log row. Never throws. */
+  function annotateLog(logId, outcome) {
+    if (!logId) return;
+    try { annotate(logId, outcome); } catch { /* diagnostics */ }
+  }
+
+  return { available, retryAfterMs: waitMs, promptUrgency, workerOutcome, annotate: annotateLog };
+}