synabun 1.3.0 → 2.0.0-beta

package/neural-interface/lib/effort-levels.js

@@ -0,0 +1,148 @@
+// ═══════════════════════════════════════════
+// SynaBun — effort levels: one vocabulary, checked per model
+// ═══════════════════════════════════════════
+//
+// Every provider names its reasoning levels differently and every model
+// supports its own subset: Claude Code advertises `effortLevels`, Codex
+// `supportedReasoningEfforts`, OpenCode per-model `variants`. The Assistant
+// catalog folds all three into `row.efforts`; this module orders them and
+// corrects a requested effort to one the model really runs. The client keeps
+// the same table in public/shared/agent-runtime-options.js.
+
+import { findModel, defaultModelRow, contextVariantOf, baseModelId } from './assistant-catalog.js';
+
+/** Canonical order, lowest first. `thinking` (an OpenCode variant) is "on", just above none. */
+export const EFFORT_ORDER = Object.freeze(['none', 'thinking', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+
+export const EFFORT_LABELS = Object.freeze({
+  none: 'None', thinking: 'Thinking', minimal: 'Min', low: 'Low', medium: 'Med',
+  high: 'High', xhigh: 'XHigh', max: 'Max', ultra: 'Ultra',
+});
+
+/** Every value `codex exec --config model_reasoning_effort=…` accepts. */
+const CODEX_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const AUTO = new Set(['', 'off', 'default', 'auto']);
+
+function clean(value) { return String(value ?? '').trim(); }
+
+/** Position in EFFORT_ORDER, or -1 for an id outside the vocabulary. */
+export function effortRank(id) { return EFFORT_ORDER.indexOf(clean(id).toLowerCase()); }
+
+/** Title-cased label for any id ("xhigh" → "XHigh", "deep-think" → "Deep Think"). */
+export function effortLabel(id) {
+  const value = clean(id);
+  return EFFORT_LABELS[value.toLowerCase()]
+    || value.split(/[-_\s]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join(' ');
+}
+
+/** Unique ids in canonical order; ids outside the vocabulary keep their order, last. */
+export function sortEfforts(ids = []) {
+  const seen = new Set();
+  const out = [];
+  for (const raw of Array.isArray(ids) ? ids : []) {
+    const id = clean(typeof raw === 'string' ? raw : (raw?.reasoningEffort || raw?.effort || raw?.id || ''));
+    if (!id || AUTO.has(id.toLowerCase()) || seen.has(id.toLowerCase())) continue;
+    seen.add(id.toLowerCase());
+    out.push(id);
+  }
+  const known = out.filter((id) => effortRank(id) >= 0).sort((a, b) => effortRank(a) - effortRank(b));
+  return [...known, ...out.filter((id) => effortRank(id) < 0)];
+}
+
+/** OpenCode `variants` (object or array) → the enabled variant names. */
+export function variantNames(variants) {
+  if (Array.isArray(variants)) return variants.map((v) => (typeof v === 'string' ? v : v?.name || v?.id)).filter(Boolean);
+  if (!variants || typeof variants !== 'object') return [];
+  return Object.entries(variants).filter(([, value]) => !(value && typeof value === 'object' && value.disabled === true)).map(([name]) => name);
+}
+
+/**
+ * The levels a model runs, in canonical order, from any row shape: catalog
+ * `efforts`, Claude `effortLevels`, Codex `supportedReasoningEfforts` (strings
+ * or { reasoningEffort | effort }), OpenCode `variants`. [] = the model takes
+ * no effort. null = the row says nothing about effort (can't check).
+ */
+export function modelEfforts(row) {
+  if (!row || typeof row !== 'object') return null;
+  const source = Array.isArray(row.efforts) ? row.efforts
+    : Array.isArray(row.effortLevels) ? row.effortLevels
+    : Array.isArray(row.supportedReasoningEfforts) ? row.supportedReasoningEfforts
+    : Array.isArray(row.supported_reasoning_efforts) ? row.supported_reasoning_efforts
+    : row.variants !== undefined ? variantNames(row.variants)
+    : null;
+  return source ? sortEfforts(source) : null;
+}
+
+/** `effort` clamped into `levels`: kept, else the highest level below it, else the lowest. */
+export function clampEffort(effort, levels, { fallback = null } = {}) {
+  const want = clean(effort);
+  if (!want || !levels?.length) return null;
+  const same = levels.find((id) => id.toLowerCase() === want.toLowerCase());
+  if (same) return same;
+  const rank = effortRank(want);
+  if (rank < 0) return fallback && levels.includes(fallback) ? fallback : null;
+  const ranked = levels.filter((id) => effortRank(id) >= 0);
+  const below = ranked.filter((id) => effortRank(id) < rank);
+  if (below.length) return below[below.length - 1];
+  return ranked[0] || levels[0];
+}
+
+function rowFor(catalog, provider, model) {
+  if (!model) return { row: defaultModelRow(catalog, provider), match: 'default' };
+  let hit = findModel(catalog, provider, model);
+  if (!hit?.row && contextVariantOf(model)) hit = findModel(catalog, provider, baseModelId(model)) || hit;
+  return hit || null;
+}
+
+/**
+ * Check `effort` against the model's levels. → { effort, corrected: {from, to} | null }.
+ * off/default/auto/empty → null (the model's own default). Supported → kept.
+ * Unsupported → the highest supported level below it, else the lowest
+ * (minimal → low, ultra on a max-only model → max). A model with no levels →
+ * null. Unknown model or unverified catalog → passed through unchanged: a value
+ * we cannot check is never dropped.
+ */
+export function normalizeEffort({ provider = null, model = null, effort = null, catalog = null } = {}) {
+  const raw = clean(effort).slice(0, 40);
+  if (AUTO.has(raw.toLowerCase())) return { effort: null, corrected: null };
+  if (!catalog || !provider) return { effort: raw, corrected: null };
+  const row = rowFor(catalog, provider, model)?.row || null;
+  const levels = modelEfforts(row);
+  if (!levels) return { effort: raw, corrected: null };
+  const next = clampEffort(raw, levels, { fallback: row?.defaultEffort || null });
+  return next === raw ? { effort: raw, corrected: null } : { effort: next, corrected: { from: raw, to: next } };
+}
+
+/** The model's levels for a provider/model pair (null when unknown). */
+export function effortsFor(catalog, provider, model) {
+  if (!catalog || !provider) return null;
+  return modelEfforts(rowFor(catalog, provider, model)?.row || null);
+}
+
+/**
+ * Codex worker value for `model_reasoning_effort`: every level Codex accepts
+ * passes through unchanged (max stays max, ultra stays ultra); off → undefined.
+ */
+export function codexReasoningEffort(effort) {
+  const value = clean(effort).toLowerCase();
+  return CODEX_EFFORTS.has(value) ? value : undefined;
+}
+
+/**
+ * Saved route preferences whose effort their model does not run.
+ * → { fixes: [{ key, target, from, to }], unverified } — `unverified` = some
+ * preference's provider list was unavailable, so it was left alone (retry later).
+ * Idempotent: a repaired preference produces no fix the next time.
+ */
+export function repairPreferenceEfforts(preferences = {}, catalog = null) {
+  const fixes = [];
+  let unverified = false;
+  if (!catalog) return { fixes, unverified: true };
+  for (const [key, pref] of Object.entries(preferences || {})) {
+    if (!pref?.provider || !pref.effort) continue;
+    if (!(catalog.models?.[pref.provider] || []).length) { unverified = true; continue; }
+    const { effort, corrected } = normalizeEffort({ provider: pref.provider, model: pref.model || null, effort: pref.effort, catalog });
+    if (corrected) fixes.push({ key, target: { ...pref, effort }, from: corrected.from, to: corrected.to });
+  }
+  return { fixes, unverified };
+}

package/neural-interface/lib/event-loop-monitor.js

@@ -0,0 +1,67 @@
+// Event-loop health for latency-sensitive processes (the Neural Interface
+// server and the pty-host). Terminal keystroke echo and PTY output ride the
+// event loop, so any synchronous work shows up here first.
+//
+// Node's monitorEventLoopDelay reports the sampling timer's own period on top
+// of the real delay (an idle loop at resolution 10 reads p50 ≈ 11 ms), so every
+// figure is reported as `raw − resolution`. The histogram also misses a stall
+// that straddles a reset, so a small timestamped sampler keeps the last stalls.
+
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
+
+const round = (n, digits = 2) => Number.isFinite(n) ? Number(n.toFixed(digits)) : 0;
+
+export function createEventLoopMonitor({ resolutionMs = 10, stallMs = 50, sampleMs = 100, keepStalls = 50 } = {}) {
+  const histogram = monitorEventLoopDelay({ resolution: resolutionMs });
+  histogram.enable();
+
+  let windowStart = Date.now();
+  let eluStart = performance.eventLoopUtilization();
+  const stalls = [];
+
+  let expected = performance.now() + sampleMs;
+  const sampler = setInterval(() => {
+    const now = performance.now();
+    const late = now - expected;
+    expected = now + sampleMs;
+    if (late >= stallMs) {
+      stalls.push({ at: Date.now() - Math.round(late), ms: Math.round(late) });
+      if (stalls.length > keepStalls) stalls.shift();
+    }
+  }, sampleMs);
+  sampler.unref?.();
+
+  const delayMs = (ns) => Math.max(0, ns / 1e6 - resolutionMs);
+
+  function snapshot({ reset = false } = {}) {
+    const count = histogram.count || 0;
+    const pct = (p) => count ? round(delayMs(histogram.percentile(p))) : 0;
+    const elu = performance.eventLoopUtilization(eluStart);
+    const out = {
+      windowMs: Date.now() - windowStart,
+      count,
+      p50: pct(50),
+      p90: pct(90),
+      p99: pct(99),
+      p999: pct(99.9),
+      max: count ? round(delayMs(histogram.max)) : 0,
+      mean: count ? round(delayMs(histogram.mean)) : 0,
+      elu: round(elu.utilization, 3),
+      stalls: stalls.slice(),
+    };
+    if (reset) {
+      histogram.reset();
+      windowStart = Date.now();
+      eluStart = performance.eventLoopUtilization();
+      stalls.length = 0;
+    }
+    return out;
+  }
+
+  function stop() {
+    clearInterval(sampler);
+    histogram.disable();
+  }
+
+  return { snapshot, stop };
+}

package/neural-interface/lib/exec-loop-command.js

@@ -0,0 +1,209 @@
+import { existsSync } from 'node:fs';
+import { codexReasoningEffort } from './effort-levels.js';
+
+function assertSingleLine(value, label) {
+  const text = String(value ?? '');
+  if (!text || /[\0\r\n]/.test(text)) {
+    throw new Error(`${label} must be a non-empty single-line value`);
+  }
+  return text;
+}
+
+function codexConfigString(value) {
+  return JSON.stringify(String(value));
+}
+
+/**
+ * Split the configurable CLI command into an executable and fixed arguments.
+ * Settings intentionally supports prefixes such as `wsl -d Ubuntu gemini`.
+ * An existing path wins before tokenization so unquoted executable paths with
+ * spaces keep working; quoted paths are handled by the tokenizer.
+ */
+export function parseConfiguredCommand(
+  value,
+  {
+    platform = process.platform,
+    exists = existsSync,
+  } = {},
+) {
+  const text = assertSingleLine(value, 'CLI command').trim();
+  if (exists(text)) return { command: text, args: [] };
+
+  const tokens = [];
+  let token = '';
+  let tokenStarted = false;
+  let quote = null;
+  const supportsSingleQuotes = platform !== 'win32';
+
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        tokenStarted = true;
+      } else if (char === '\\' && text[index + 1] === quote) {
+        token += quote;
+        tokenStarted = true;
+        index++;
+      } else {
+        token += char;
+        tokenStarted = true;
+      }
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (tokenStarted) {
+        tokens.push(token);
+        token = '';
+        tokenStarted = false;
+      }
+      continue;
+    }
+    if (char === '"' || (supportsSingleQuotes && char === "'")) {
+      quote = char;
+      tokenStarted = true;
+      continue;
+    }
+    token += char;
+    tokenStarted = true;
+  }
+
+  if (quote) throw new Error('CLI command contains an unmatched quote');
+  if (tokenStarted) tokens.push(token);
+  if (!tokens[0]) throw new Error('CLI command must include an executable');
+  return { command: tokens[0], args: tokens.slice(1) };
+}
+
+export function buildExecInvocation({
+  profile,
+  command,
+  cwd,
+  model,
+  effort,
+  mcpEnvOverrides = [],
+  platform = process.platform,
+  commandExists = existsSync,
+} = {}) {
+  const configured = parseConfiguredCommand(command || profile, {
+    platform,
+    exists: commandExists,
+  });
+  const executable = configured.command;
+  const args = [...configured.args];
+
+  switch (profile) {
+    case 'codex': {
+      args.push('exec', '--dangerously-bypass-approvals-and-sandbox');
+      for (const [key, value] of mcpEnvOverrides) {
+        args.push('-c', `mcp_servers.SynaBun.env.${key}=${codexConfigString(value)}`);
+      }
+      const normalizedEffort = codexReasoningEffort(effort);
+      if (normalizedEffort) args.push('-c', `model_reasoning_effort=${codexConfigString(normalizedEffort)}`);
+      if (model) args.push('--model', String(model));
+      if (cwd) args.push('-C', String(cwd));
+      args.push('-');
+      break;
+    }
+    case 'gemini':
+      if (model) args.push('--model', String(model));
+      break;
+    case 'opencode':
+      args.push('run', '--dangerously-skip-permissions');
+      if (model) args.push('--model', String(model));
+      args.push('--format', 'default');
+      break;
+    default:
+      break;
+  }
+
+  for (const arg of args) assertSingleLine(arg, 'CLI argument');
+  return { command: executable, args };
+}
+
+export function posixShellQuote(value) {
+  const text = assertSingleLine(value, 'Shell argument');
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Quote one argv value for a Windows batch file. This follows the standard
+ * CommandLineToArgvW backslash/quote rules and doubles percent signs so paths
+ * such as "100% Ready" cannot be mistaken for batch variable expansion.
+ * Delayed expansion is disabled in the generated wrapper, preserving '!'.
+ */
+export function windowsBatchQuote(value, expansionPasses = 1) {
+  const percentEscape = '%'.repeat(2 ** Math.max(1, Number(expansionPasses) || 1));
+  const text = assertSingleLine(value, 'Batch argument').replace(/%/g, percentEscape);
+  let result = '"';
+  let backslashes = 0;
+  for (const char of text) {
+    if (char === '\\') {
+      backslashes++;
+      continue;
+    }
+    if (char === '"') {
+      result += '\\'.repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+      continue;
+    }
+    result += '\\'.repeat(backslashes) + char;
+    backslashes = 0;
+  }
+  result += '\\'.repeat(backslashes * 2) + '"';
+  return result;
+}
+
+export function execWrapperExtension(platform = process.platform) {
+  return platform === 'win32' ? '.cmd' : '.sh';
+}
+
+export function renderExecWrapper({
+  platform = process.platform,
+  command,
+  args = [],
+  taskFile,
+  sentinel,
+} = {}) {
+  const executable = assertSingleLine(command, 'CLI command');
+  const inputPath = assertSingleLine(taskFile, 'Task file');
+  const marker = assertSingleLine(sentinel, 'Iteration sentinel');
+  if (!/^SYNABUN_ITER_DONE_\d+$/.test(marker)) {
+    throw new Error(`Invalid iteration sentinel: ${marker}`);
+  }
+
+  if (platform === 'win32') {
+    const needsCall = !/\.(?:exe|com)$/i.test(executable);
+    // CALL reparses its command line. Escape percent signs for both the batch
+    // file's initial expansion and CALL's second expansion.
+    const quote = (value) => windowsBatchQuote(value, needsCall ? 2 : 1);
+    const invocation = [quote(executable), ...args.map(quote)].join(' ');
+    return [
+      '@echo off',
+      'setlocal DisableDelayedExpansion',
+      `${needsCall ? 'call ' : ''}${invocation} < ${quote(inputPath)}`,
+      'set "SYNABUN_RC=%ERRORLEVEL%"',
+      `echo ${marker} rc=%SYNABUN_RC%`,
+      'endlocal',
+      'exit /b 0',
+      '',
+    ].join('\r\n');
+  }
+
+  const invocation = [posixShellQuote(executable), ...args.map(posixShellQuote)].join(' ');
+  return [
+    '#!/bin/sh',
+    `${invocation} < ${posixShellQuote(inputPath)}`,
+    'synabun_rc=$?',
+    `printf '%s rc=%s\\n' ${posixShellQuote(marker)} "$synabun_rc"`,
+    'exit 0',
+    '',
+  ].join('\n');
+}
+
+export function execWrapperLaunchCommand(wrapperFile, platform = process.platform) {
+  const path = assertSingleLine(wrapperFile, 'Wrapper file');
+  return platform === 'win32'
+    ? `call ${windowsBatchQuote(path)}`
+    : `sh ${posixShellQuote(path)}`;
+}

package/neural-interface/lib/folder-picker.ps1

@@ -0,0 +1,77 @@
+param([string]$Title = 'Select a folder')
+
+Add-Type -AssemblyName System.Windows.Forms
+
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+[ComImport, Guid("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7")]
+class FileOpenDialogRCW {}
+
+[ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"),
+ InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IShellItem {
+    void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+    void GetParent(out IShellItem ppsi);
+    void GetDisplayName(uint sigdnName, [MarshalAs(UnmanagedType.LPWStr)] out string ppszName);
+    void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+    void Compare(IShellItem psi, uint hint, out int piOrder);
+}
+
+[ComImport, Guid("42f85136-db7e-439c-85f1-e4075d135fc8"),
+ InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+interface IFileOpenDialog {
+    [PreserveSig] uint Show(IntPtr hwndOwner);
+    void SetFileTypes(uint cFileTypes, IntPtr rgFilterSpec);
+    void SetFileTypeIndex(uint iFileType);
+    void GetFileTypeIndex(out uint piFileType);
+    void Advise(IntPtr pfde, out uint pdwCookie);
+    void Unadvise(uint dwCookie);
+    void SetOptions(uint fos);
+    void GetOptions(out uint pfos);
+    void SetDefaultFolder(IShellItem psi);
+    void SetFolder(IShellItem psi);
+    void GetFolder(out IShellItem ppsi);
+    void GetCurrentSelection(out IShellItem ppsi);
+    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string pszName);
+    void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string pszName);
+    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
+    void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string pszText);
+    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string pszLabel);
+    void GetResult(out IShellItem ppsi);
+    void AddPlace(IShellItem psi, int fdap);
+    void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string pszDefaultExtension);
+    void Close(int hr);
+    void SetClientGuid(ref Guid guid);
+    void ClearClientData();
+    void SetFilter(IntPtr pFilter);
+    void GetResults(out IntPtr ppenum);
+    void GetSelectedItems(out IntPtr ppsai);
+}
+
+public static class FolderPicker {
+    [DllImport("user32.dll")]
+    static extern IntPtr GetForegroundWindow();
+
+    public static string Pick(string title) {
+        // Grab the currently focused window (the browser) so the dialog opens on top of it
+        IntPtr foreground = GetForegroundWindow();
+
+        var dlg = (IFileOpenDialog)new FileOpenDialogRCW();
+        dlg.SetOptions(0x20); // FOS_PICKFOLDERS
+        if (!string.IsNullOrEmpty(title)) dlg.SetTitle(title);
+        uint hr = dlg.Show(foreground);
+        if (hr != 0) return string.Empty;
+        IShellItem item;
+        dlg.GetResult(out item);
+        string path;
+        item.GetDisplayName(0x80058000, out path); // SIGDN_DESKTOPABSOLUTEPARSING
+        return path ?? string.Empty;
+    }
+}
+'@ -ReferencedAssemblies System.Windows.Forms
+
+$result = [FolderPicker]::Pick($Title)
+if ($result) { Write-Output $result }