synabun 2.0.0 → 2.0.7

package/neural-interface/public/shared/assistant/asst-sidepanel.js

@@ -26,7 +26,7 @@ import {
 } from '../ui-assistant.js';
 import { mountAssistant } from './asst-panel.js';
 import { openModelsManager } from './asst-route.js';
-import { brainLabel, readStoredBrain } from './asst-state.js';
+import { brainLabel, readStoredBrain, restoredSessionName } from './asst-state.js';
 import { closeMenu, isMenuOpen, openMenu } from './asst-menu.js';
 import { injectAssistantSidepanelStyles } from './asst-sidepanel-styles.js';
 import { createMascot, mascotCameoSvg } from '../synabun-mascot.js';
@@ -50,7 +50,7 @@ let _initialized = false;
 let _starting = false;
 let _startError = ''; // the last message the host showed while starting (the failed state repeats it)
 let _placeholderMascot = null; // the character while starting: the empty state's, same size; it flies to the empty state's spot
-let _pendingPath = '';
+let _pendingPaths = []; // file paths sent while no session was open: attached, in order, when one is
 let _toastTimer = null;
 let _renaming = false;
 const _tabs = [];   // { sessionId, viewport, toolbar, ctl, pill, label, userRenamed, status, brain }
@@ -260,7 +260,7 @@ function showPanelToast(text) {
 
 // ── Tabs ─────────────────────────────────────────────────────────────────────
 
-function mountTab({ sessionId, meta = null, brain = null, label = '', userRenamed = false, prompt = '', show = true } = {}) {
+function mountTab({ sessionId, meta = null, brain = null, label = '', userRenamed = false, prompt = '', show = true, restoring = false } = {}) {
   if (!sessionId) return null;
   ensurePanel();
   const existing = findTab(sessionId);
@@ -280,9 +280,13 @@ function mountTab({ sessionId, meta = null, brain = null, label = '', userRename
   toolbar.className = 'asp-tab-bar';
   toolbar.dataset.sessionId = sessionId;
   panelEl('.asp-bar-slot').appendChild(toolbar);
-  const renamed = !!(userRenamed && label);
+  // A renamed session comes back under its name: the session record's (a rename made in either
+  // host, the one the Sessions menu lists), else the rename saved with this tab. A record whose
+  // name was given up says so: the label and the renamed flag saved with a tab are stale.
+  const name = restoredSessionName(meta, userRenamed ? label : '');
+  const renamed = !!name;
   // The record exists before mountAssistant: the host hooks fire during mount.
-  const tab = { sessionId, viewport, toolbar, ctl: null, pill: null, label: renamed ? label : defaultLabel(), userRenamed: renamed, status: 'idle', brain: brain || meta?.brain || null };
+  const tab = { sessionId, viewport, toolbar, ctl: null, pill: null, label: renamed ? name : defaultLabel(), userRenamed: renamed, status: 'idle', brain: brain || meta?.brain || null };
   _tabs.push(tab);
   const host = {
     id: HOST_ID,
@@ -295,6 +299,16 @@ function mountTab({ sessionId, meta = null, brain = null, label = '', userRename
       renderPills();
       saveTabs();
     },
+    // A rename the panel could not save: the tab and its saved label go back to the record's name.
+    setName(text, renamed) {
+      const next = String(text || '').trim();
+      if (!next) return;
+      tab.label = next;
+      tab.userRenamed = !!renamed;
+      renderHeader();
+      renderPills();
+      saveTabs();
+    },
     setStatus(status) {
       tab.status = status || 'idle';
       if (tab.status === 'done' && isTabVisible(tab)) tab.status = 'idle';
@@ -311,7 +325,7 @@ function mountTab({ sessionId, meta = null, brain = null, label = '', userRename
     },
   };
   tab.ctl = mountAssistant(viewport, { sessionId, brain: tab.brain, host, session: meta });
-  if (tab.userRenamed) tab.ctl.setTitle(tab.label);
+  if (tab.userRenamed) tab.ctl.setTitle(tab.label, { restored: true });
   if (show) {
     switchTo(_tabs.length - 1);
     if (!_visible) setVisible(true);
@@ -324,7 +338,8 @@ function mountTab({ sessionId, meta = null, brain = null, label = '', userRename
   renderPills();
   saveTabs();
   if (prompt) setTimeout(() => { if (findTab(sessionId)) tab.ctl?.send(prompt); }, 50);
-  if (_pendingPath && tab === activeTab()) { const path = _pendingPath; _pendingPath = ''; tab.ctl.attachPath(path); }
+  // (Not while the saved tabs are coming back: the first of them is not the one that was showing.)
+  if (_pendingPaths.length && !restoring && tab === activeTab()) { const paths = _pendingPaths; _pendingPaths = []; for (const path of paths) tab.ctl.attachPath(path); }
   return tab;
 }
 
@@ -635,12 +650,14 @@ export async function initAssistantPanel() {
     if (!_visible) setVisible(true);
     tab.ctl?.attachImageDataUrl(dataUrl, 'whiteboard');
   });
-  on('assistant:attach-path', ({ path } = {}) => {
+  on('assistant:attach-path', (request = {}) => {
+    const { path } = request;
     if (!path || assistantBlocked()) return;
     const tab = activeTab();
     if (!_visible) setVisible(true);
     if (tab?.ctl) tab.ctl.attachPath(path);
-    else _pendingPath = String(path);
+    else _pendingPaths.push(String(path));
+    request.taken = true; // the sender says "sent" only of what was taken
   });
   // The server renamed a conversation (first prompt): refresh tooltips after the component applied it.
   on('sync:assistant:session-updated', (msg) => {
@@ -663,6 +680,7 @@ export async function initAssistantPanel() {
       label: entry.label || '',
       userRenamed: !!entry.userRenamed,
       show: false,
+      restoring: true,
     });
   }
   if (_tabs.length) {
@@ -670,6 +688,10 @@ export async function initAssistantPanel() {
     markActive();
     renderHeader();
     renderPills();
+    // Paths that were sent while the sessions were being asked about go to the one that is showing again.
+    const paths = _pendingPaths;
+    _pendingPaths = [];
+    for (const path of paths) activeTab()?.ctl?.attachPath(path);
   }
   saveTabs();
 }

package/neural-interface/public/shared/assistant/asst-slash.js

@@ -15,7 +15,7 @@ export const SLASH_COMMANDS = [
   { name: 'project', usage: '/project <path>', descKey: 'assistant.slash.project', desc: 'Set the working project' },
   { name: 'routes', usage: '/routes [always|unsure|never]', descKey: 'assistant.slash.routes', desc: 'Set when to ask before routing (or open the model routes)' },
   { name: 'models', usage: '/models [list | archived | hide <id…> | show <id…>]', descKey: 'assistant.slash.models', desc: 'Switch models off or on for the Assistant (or open the Models list)' },
-  { name: 'budget', usage: '/budget', descKey: 'assistant.slash.budget', desc: 'Set the money caps (per run, session, brain)' },
+  { name: 'budget', usage: '/budget', descKey: 'assistant.slash.budget', desc: 'Set the session budget and view provider shares' },
   { name: 'computer', usage: '/computer [on|off]', descKey: 'assistant.slash.computer', desc: 'Let the assistant use your Mac' },
   { name: 'stop', usage: '/stop [runId|all]', descKey: 'assistant.slash.stop', desc: 'Stop a run, everything, or the current turn' },
   { name: 'new', usage: '/new [provider]', descKey: 'assistant.slash.new', desc: 'Start a fresh session' },

package/neural-interface/public/shared/assistant/asst-state.js

@@ -181,7 +181,7 @@ export function resolveBrainDefaults(brain, catalog = {}) {
 
   if (ACCOUNT_PROVIDERS.has(b.provider)) {
     const accounts = catalog.accounts?.[b.provider] || [];
-    if (!b.accountId || (accounts.length && !accounts.some(a => a?.id === b.accountId))) {
+    if (!b.accountId || (b.accountId !== 'auto' && accounts.length && !accounts.some(a => a?.id === b.accountId))) {
       b.accountId = accounts.find(a => a?.isDefault)?.id || accounts[0]?.id || 'default';
     }
   } else {
@@ -231,6 +231,56 @@ export function modelShortName(model) {
   return tail.replace(/:\d+$/, '');
 }
 
+// ── Projects ────────────────────────────────────────────────────────────────
+
+/** A folder path without trailing separators ("/a/b/" is "/a/b"); the root stays itself. */
+function folderPath(path) {
+  const value = str(path);
+  return value.replace(/[\\/]+$/, '') || value;
+}
+
+/**
+ * What a working folder is called: its label among SynaBun's registered
+ * projects (GET /api/projects: [{ path, label }]), else the folder's own name;
+ * '' for none. The toolbar's Working project, the empty state's picker and the
+ * "Fix … in {project}" suggestion all read it, so they name it the same way.
+ */
+export function projectLabel(path, projects = []) {
+  const want = folderPath(path);
+  if (!want) return '';
+  const row = (Array.isArray(projects) ? projects : []).find(p => p && folderPath(p.path) === want);
+  return str(row?.label) || want.split(/[\\/]/).filter(Boolean).pop() || want;
+}
+
+const fillParams = (text, params) => (params ? String(text).replace(/\{(\w+)\}/g, (_, k) => (params[k] != null ? params[k] : `{${k}}`)) : String(text));
+
+/**
+ * The empty state's project picker: { chosen, key, label, title, aria }. With
+ * no project the brain works in the home directory and the picker asks
+ * "Choose a project"; with one it reads "Project  Synabun", the path in its
+ * tooltip. `tr(key, fallback, params)` translates.
+ */
+export function emptyProjectView(project, projects = [], tr = (_key, fallback, params) => fillParams(fallback, params)) {
+  const path = str(project);
+  const name = projectLabel(path, projects);
+  if (!name) {
+    return {
+      chosen: false,
+      key: '',
+      label: tr('assistant.empty.chooseProject', 'Choose a project'),
+      title: tr('assistant.brain.projectNoneTip', 'Working project: home directory'),
+      aria: tr('assistant.empty.projectAria', 'Choose a project (now: {project})', { project: tr('assistant.brain.projectNone', 'Home directory') }),
+    };
+  }
+  return {
+    chosen: true,
+    key: tr('assistant.empty.project', 'Project'),
+    label: name,
+    title: path,
+    aria: tr('assistant.empty.projectAria', 'Choose a project (now: {project})', { project: name === path ? name : `${name}, ${path}` }),
+  };
+}
+
 /** Does switching from `a` to `b` require a fresh server session (switch_brain)? */
 export function brainRequiresSwitch(a, b) {
   const x = normalizeBrain(a);
@@ -453,6 +503,22 @@ export function normalizeRouteMode(value, fallback = null) {
   return ROUTE_MODE_ALIASES[key] || fallback;
 }
 
+// Test density: how much testing SynaBun asks of dispatched workers (server: lib/assistant-test-density.js).
+// `null` means "server default" in a tab's own state; a missing or unknown value reads as the default level.
+export const TEST_DENSITIES = ['none', 'light', 'standard', 'thorough'];
+export const DEFAULT_TEST_DENSITY = 'light';
+
+/** A known level, else `fallback` (the default level; pass null to tell "not set" apart). */
+export function normalizeTestDensity(value, fallback = DEFAULT_TEST_DENSITY) {
+  const key = str(value).toLowerCase();
+  return TEST_DENSITIES.includes(key) ? key : fallback;
+}
+
+/** Bars of the composer's gauge that are filled at a level: none 0 · light 1 · standard 2 · thorough 3. */
+export function testDensityBars(level) {
+  return TEST_DENSITIES.indexOf(normalizeTestDensity(level));
+}
+
 const COMPUTER_ON = new Set(['on', 'true', '1', 'yes', 'enable', 'enabled']);
 const COMPUTER_OFF = new Set(['off', 'false', '0', 'no', 'disable', 'disabled']);
 
@@ -529,6 +595,121 @@ export function tabStorageKey(sessionId) {
   return `${KEYS.ASSISTANT_TAB_PREFIX}${sessionId}`;
 }
 
+/**
+ * The name the user gave a session, '' when they never renamed it. It lives on
+ * the server's session record (`title` + `userRenamed`, written by a rename in
+ * either host): the Sessions menu and a reopened tab read the same name, and a
+ * host's saved tab label is only its copy.
+ */
+export function userSessionTitle(meta) {
+  if (!meta || typeof meta !== 'object' || meta.userRenamed !== true) return '';
+  return str(meta.title);
+}
+
+/** What a tab is called until the user renames it (the server's DEFAULT_SESSION_TITLE). */
+export const DEFAULT_SESSION_TITLE = 'SynaBun';
+
+/**
+ * The title to write to the session record for a tab's name, null when there is
+ * nothing to write. `recordName` is userSessionTitle() of the record,
+ * `recordTitle` its title, `keepsRenames` whether the server marks renames
+ * (features.rename; one not restarted yet does not, and holds a name once its
+ * title says it), `defaultTitle` the default tab name as this locale shows it.
+ * The default name is no name: it is only written to take a rename back.
+ */
+export function renameToSave(name, { recordName = '', recordTitle = '', keepsRenames = false, defaultTitle = DEFAULT_SESSION_TITLE } = {}) {
+  const next = str(name);
+  if (!next) return null;
+  if (next === DEFAULT_SESSION_TITLE || next === str(defaultTitle)) return keepsRenames && str(recordName) ? DEFAULT_SESSION_TITLE : null;
+  return next === (keepsRenames ? str(recordName) : str(recordTitle)) ? null : next;
+}
+
+/**
+ * The name a host gives the tab it mounts for a session: the record's
+ * (userSessionTitle), else the label saved with the tab when the record says
+ * nothing about a name (a rename made before the record kept names). A record
+ * with `userRenamed: false` had its name given up: a saved label is stale.
+ */
+export function restoredSessionName(meta, savedLabel = '') {
+  return userSessionTitle(meta) || (sessionNameGivenUp(meta) ? '' : str(savedLabel));
+}
+
+/** The record says its name was taken back ("SynaBun" again): no saved label or renamed flag stands for it. */
+export function sessionNameGivenUp(meta) {
+  return !!meta && typeof meta === 'object' && meta.userRenamed === false;
+}
+
+/**
+ * Every rename on its way to a session record, one write at a time per session,
+ * so the name asked for last is the one the record ends with: after each answer
+ * the newest name is compared with what the record holds now, and what still
+ * differs (taking a rename back included) is written. One writer for the page,
+ * not one per tab: a write goes on after its tab closed, and a session list
+ * waits for `settled()`. `patch(sessionId, { title })` is the request.
+ *
+ * save(sessionId, name, opts): `recordName` / `recordTitle` / `keepsRenames` /
+ * `defaultTitle` are renameToSave()'s, as the caller knows the record (a write
+ * under way hears the record from its answer instead); `from` is the name the
+ * tab had before the first of them. `onSaved(session)` gets each answer,
+ * `onFailed({ name, back })` a write that did not get through: `name` was not
+ * saved, `back` is the name the record answers to (the last one it confirmed,
+ * else `from`). The latest call's callbacks are the ones used. The promise
+ * never rejects.
+ */
+export function createRenameWriter({ patch } = {}) {
+  const jobs = new Map(); // sessionId → { name, back, record, keepsRenames, defaultTitle, onSaved, onFailed, done }
+
+  const toWrite = (job) => renameToSave(job.name, { recordName: job.record.name, recordTitle: job.record.title, keepsRenames: job.keepsRenames, defaultTitle: job.defaultTitle });
+
+  async function run(sessionId, job) {
+    // The title of the last write the server answered. It may keep a name cut or tidied, which
+    // never equals the tab's: the same title is not sent twice in a row.
+    let written = null;
+    for (;;) {
+      const name = job.name;
+      const title = toWrite(job);
+      if (!title || title === written) break;
+      let session = null;
+      try { session = (await patch(sessionId, { title }))?.session || null; } catch {
+        jobs.delete(sessionId);
+        try { job.onFailed?.({ name: job.name, back: job.back }); } catch { /* the caller's */ }
+        return;
+      }
+      written = title;
+      job.back = name;
+      job.record = session?.title
+        ? { name: userSessionTitle(session), title: str(session.title) }
+        : { name: job.keepsRenames && title !== DEFAULT_SESSION_TITLE ? title : '', title };
+      try { job.onSaved?.(session); } catch { /* the caller's */ }
+    }
+    jobs.delete(sessionId);
+  }
+
+  function save(sessionId, name, { from = '', recordName = '', recordTitle = '', keepsRenames = false, defaultTitle = DEFAULT_SESSION_TITLE, onSaved = null, onFailed = null } = {}) {
+    const next = str(name);
+    if (!sessionId || !next) return Promise.resolve();
+    const waiting = jobs.get(sessionId);
+    if (waiting) {
+      // A write is under way: this name is the one compared with its answer.
+      Object.assign(waiting, { name: next, keepsRenames, defaultTitle, onSaved, onFailed });
+      return waiting.done;
+    }
+    const job = { name: next, back: str(from), record: { name: str(recordName), title: str(recordTitle) }, keepsRenames, defaultTitle, onSaved, onFailed, done: null };
+    if (!toWrite(job)) return Promise.resolve();
+    jobs.set(sessionId, job);
+    job.done = run(sessionId, job);
+    return job.done;
+  }
+
+  return {
+    save,
+    /** A rename of this session is on its way. */
+    pending: (sessionId) => jobs.has(sessionId),
+    /** Resolves once every rename that was on its way has its answer, whatever tab asked for it. */
+    settled: () => Promise.all([...jobs.values()].map((job) => job.done)).then(() => {}),
+  };
+}
+
 export function createTabState(sessionId, brain, extra = {}) {
   return {
     sessionId,
@@ -548,6 +729,7 @@ export function createTabState(sessionId, brain, extra = {}) {
     draft: '',
     routeMode: null,     // explicit per-session route mode; null = server default
     computerUse: null,   // explicit per-session computer use; null = server default
+    testDensity: null,   // explicit per-session test density; null = server default
     usageView: null,
     limit: null,         // the provider's usage limit notice (applyLimit); never persisted, the server re-sends it on attach
     ...extra,
@@ -568,12 +750,13 @@ export function serializeTabState(state) {
     costUsd: Number.isFinite(Number(state.costUsd)) ? Number(state.costUsd) : 0,
     routeMode: normalizeRouteMode(state.routeMode, null),
     computerUse: normalizeComputerMode(state.computerUse, null),
+    testDensity: normalizeTestDensity(state.testDensity, null),
     usageView: compactUsageView(state.usageView),
     updatedAt: Date.now(),
   };
 }
 
-/** Tolerant of older payloads: missing routeMode / computerUse read as null (server default). */
+/** Tolerant of older payloads: missing routeMode / computerUse / testDensity read as null (server default). */
 export function deserializeTabState(raw) {
   let data = raw;
   if (typeof raw === 'string') {
@@ -590,6 +773,7 @@ export function deserializeTabState(raw) {
     costUsd: Number.isFinite(Number(data.costUsd)) ? Number(data.costUsd) : 0,
     routeMode: normalizeRouteMode(data.routeMode, null),
     computerUse: normalizeComputerMode(data.computerUse, null),
+    testDensity: normalizeTestDensity(data.testDensity, null),
     usageView: compactUsageView(data.usageView),
   };
 }