synabun 2.0.0 → 2.0.5

package/neural-interface/lib/claude-agent-bridge.js

@@ -30,7 +30,7 @@ import { CLAUDE_NOT_INSTALLED, resolveClaudeSdkExecutable } from './claude-execu
 import { diagnoseLaunchFailure, isNativeBinaryLaunchFailure } from './native-binary-runtime.js';
 import { normalizePanelSession, startSignature, applyPanelSessionOptions, liveSettingsPatch, normalizeMcpServers, mergeTabMcpServers } from './claude-panel-session.js';
 import { SESSION_REQUESTS, runSessionRequest, slimRewind, slimMcpStatus } from './claude-panel-requests.js';
-import { applyTemporaryOptions, plansDirsOf, planFileOfToolCall, removeTemporaryPlanFiles } from './claude-temporary.js';
+import { applyTemporaryOptions, plansDirsOf, snapshotPlanFiles, planFileOfToolCall, removeTemporaryPlanFiles } from './claude-temporary.js';
 import { rootBypassBlock } from './claude-bypass-policy.js';
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
@@ -107,6 +107,7 @@ export const PANEL_CAPABILITIES = Object.freeze([
   'message_flags',    // session.hookEvents / promptSuggestions / subagentText / agentSummaries → the matching SDK options
   'task_control',     // inbound `stop_task` / `background_tasks` → `task_control_result`; system/session_crons events
   'origin_human',     // a query marked `typed: true` is sent with origin {kind:'human'}
+  'greeting',         // query `greetingId`: the model is told once what SynaBun greeted the user with (lib/greeting/)
   'session_requests', // inbound `session_request {id, what, args}` → `session_response`: context_usage, usage, mcp_status, mcp_reconnect, mcp_toggle, rewind_preview
   'rewind_stats',     // `rewind_result` carries filesChanged / insertions / deletions
   'session_title',    // query `title` names a new session where the CLI reads it
@@ -226,7 +227,7 @@ function log(...args) { console.log('[claude-sdk]', ...args); }
 
 // Panel sessions, a temporary chat (lib/claude-temporary.js): the plan files
 // Claude Code wrote for one that still have to be removed. path → { plansDirs,
-// since, ended, last }. One is removed once the pump of the process that wrote
+// since, before, ended, last }. One is removed once the pump of the process that wrote
 // it has settled (`ended`), and stays owed after that removal, whether it
 // removed the file or found none: the pump settles when the SDK's own cleanup
 // stops waiting for the process, which can be before the process is gone, and
@@ -602,8 +603,9 @@ export class ClaudeSession {
       // `typesafe:'off'` on a query (the live skin test) keeps this CLI's hooks
       // from paying for judgments: they read the kill switch from their env.
       // (Panel sessions: the CLI reports running / idle / requires_action only when
-      // asked to; `idle` is its own word that a turn is over. See _noteSessionState.)
-      env: { ...cleanEnv(), ...(this.typesafeOff ? { SYNABUN_TYPESAFE: 'off' } : {}), ...(sessionOpts.env || {}), ...(accountEnv || {}), ...(this.panel ? { CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1' } : {}) },
+      // asked to; `idle` is its own word that a turn is over. See _noteSessionState.
+      // SYNABUN_PANEL_SESSION tells the user-level SynaBun hooks that the panel greets here, not they.)
+      env: { ...cleanEnv(), ...(this.typesafeOff ? { SYNABUN_TYPESAFE: 'off' } : {}), ...(sessionOpts.env || {}), ...(accountEnv || {}), ...(this.panel ? { CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1', SYNABUN_PANEL_SESSION: '1' } : {}) },
       abortController: this.abortController,
       stderr: (text) => {
         const t = String(text || '').trim();
@@ -643,6 +645,16 @@ export class ClaudeSession {
       // Resuming a session whose prompt cache has expired pays to write it
       // again: the CLI says how much at SessionStart.
       options.hooks = mergeHookMatchers(options.hooks, {
+        // The greeting SynaBun showed when this conversation opened (lib/greeting/): said to the
+        // model once, with the first prompt, as background. The model is never asked to greet.
+        UserPromptSubmit: [{
+          hooks: [async () => {
+            const note = gen === this._queryGen ? this._greetingNote : '';
+            if (!note) return {};
+            this._greetingNote = '';
+            return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: note } };
+          }],
+        }],
         SessionStart: [{
           hooks: [async (input) => {
             if (gen === this._queryGen && input?.prompt_cache_likely_expired === true && Number(input?.estimated_cache_write_usd) > 0) {
@@ -744,7 +756,10 @@ export class ClaudeSession {
       // (Which of the session's MCP connections is SynaBun's is asked of the live process when a tool of one is called.)
       applyTemporaryOptions(options, { mcpUrl: deps.mcpUrl || '', mcpStatus: () => this.q?.mcpServerStatus?.() });
       this._tempPlansDirs = plansDirsOf(options.env, { cwd: workDir, settings: options.settings });
-      if (!this._tempSince) this._tempSince = Date.now();
+      if (!this._tempSince) {
+        this._tempPlansBefore = snapshotPlanFiles(this._tempPlansDirs);
+        this._tempSince = Date.now();
+      }
     }
     // The executable resolved at the top of this call. The SDK uses
     // pathToClaudeCodeExecutable verbatim with zero validation, so it was vetted
@@ -1079,7 +1094,7 @@ export class ClaudeSession {
   // stay owed and are swept once more when it can no longer be alive.
   _removeTemporaryPlans() {
     if (!this._tempPlans?.size) return;
-    const owed = { plansDirs: this._tempPlansDirs, since: this._tempSince, ended: false, last: false };
+    const owed = { plansDirs: this._tempPlansDirs, since: this._tempSince, before: this._tempPlansBefore, ended: false, last: false };
     for (const path of this._tempPlans) _temporaryPlansOwed.set(path, owed);
     this._tempPlans.clear();
     Promise.resolve(this.pumpPromise).catch(() => {}).then(() => {
@@ -1098,6 +1113,7 @@ export class ClaudeSession {
     this._tempLive = false;
     this._tempOver = false;
     this._tempSince = 0;
+    this._tempPlansBefore = null;
   }
 
   // Whether this message makes, keeps or may not make the conversation a
@@ -2811,6 +2827,17 @@ export class ClaudeSession {
       } catch {}
     }
 
+    // The panel echoes the id of the greeting it showed when this conversation opened: the model is
+    // told once, with this prompt (the UserPromptSubmit hook in _startQuery). A slash command takes none.
+    // (A prompt the person typed in the panel is also them being here, whether or not the user-level hooks are installed.)
+    if (this.panel && !warmOnly && msg.typed === true && typeof prompt === 'string' && prompt.trim() && typeof deps.greetingActivity === 'function') {
+      try { deps.greetingActivity({ cwd: cwd || this.cwd || null, words: prompt, temporary: this.temporary === true }); } catch { /* the prompt goes on */ }
+    }
+    if (this.panel && !warmOnly && typeof msg.greetingId === 'string' && typeof deps.greetingNote === 'function') {
+      try { this._greetingNote = String(deps.greetingNote(msg.greetingId, { skip: typeof prompt === 'string' && prompt.trimStart().startsWith('/') }) || ''); }
+      catch { this._greetingNote = ''; }
+    }
+
     // SynaBun skill injection runs FIRST; unrecognized /commands pass through to the CLI
     if (prompt && prompt.startsWith('/')) {
       try {

package/neural-interface/lib/claude-model-catalog.js

@@ -45,6 +45,32 @@ const CACHE_TTL_MS = 10 * 60 * 1000;
 let _cache = { at: 0, key: '', models: [] };
 let _inflight = null;
 
+// Who else keeps a copy of this list (the Assistant's model catalog). Told when a
+// discovery returns a list that differs from the one before it, so a copy is
+// dropped the moment the picker's own source changes: after a CLI update, or
+// when the account's models change. The first discovery after a start counts.
+const _changeListeners = new Set();
+
+export function onClaudeModelsChanged(listener) {
+  if (typeof listener !== 'function') return () => {};
+  _changeListeners.add(listener);
+  return () => { _changeListeners.delete(listener); };
+}
+
+// What makes two lists the same list for a picker: ids in order, the model each
+// runs as, the label, the context window and the effort levels.
+export function claudeModelsSignature(models) {
+  return JSON.stringify((Array.isArray(models) ? models : []).map(m => [
+    m?.id || '', m?.resolvedModel || '', m?.label || '', m?.contextWindow || 0, (m?.effortLevels || []).join(','),
+  ]));
+}
+
+function notifyModelsChanged(models) {
+  for (const listener of [..._changeListeners]) {
+    try { listener(models); } catch {}
+  }
+}
+
 // What a cache keyed on "the CLI" has to key on. An update never changes the
 // configured path: the native installer and Homebrew re-point a symlink at a new
 // version directory, and npm rewrites the entrypoint in place. The resolved target
@@ -262,7 +288,7 @@ export function queryClaudeCliModels(claudeBin, { cwd, timeoutMs = DISCOVERY_TIM
 // Cached discovery. `source` lets the UI distinguish a verified list from the
 // baked-in fallback. Cache is keyed on the binary's identity, so switching the
 // configured CLI (Settings > Terminal) or updating it re-discovers.
-export async function discoverClaudeModels(claudeBin, { force = false, cwd } = {}) {
+export async function discoverClaudeModels(claudeBin, { force = false, cwd, query = queryClaudeCliModels } = {}) {
   const bin = String(claudeBin || '');
   const key = binaryIdentity(bin);
   const fresh = _cache.models.length
@@ -273,10 +299,12 @@ export async function discoverClaudeModels(claudeBin, { force = false, cwd } = {
 
   _inflight = (async () => {
     try {
-      const raw = await queryClaudeCliModels(bin, { cwd });
+      const raw = await query(bin, { cwd });
       const models = normalizeClaudeModels(raw);
       if (models.length) {
+        const changed = claudeModelsSignature(models) !== claudeModelsSignature(_cache.models);
         _cache = { at: Date.now(), key, models };
+        if (changed) notifyModelsChanged(models);
         return { source: 'cli', models };
       }
       return { source: 'fallback', models: [...CLAUDE_FALLBACK_MODELS] };

package/neural-interface/lib/claude-temporary.js

@@ -7,9 +7,9 @@
 // one sentence the model is told, and the plan files Claude Code writes for it
 // whatever the options say.
 
-import { lstatSync, readFileSync, realpathSync, statSync, unlinkSync } from 'node:fs';
+import { lstatSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 
 // Set in the environment of a temporary session's process. SynaBun's Claude
 // Code hooks read it (hooks/claude-code/shared.mjs, isTemporaryChat) and store,
@@ -386,6 +386,41 @@ export function plansDirsOf(env, { cwd = '', settings = null } = {}) {
 const real = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
 const listOf = (dirs) => (Array.isArray(dirs) ? dirs : [dirs]).filter(Boolean);
 
+// Resolve existing ancestors too, when the plans directory does not exist yet.
+function realPlanFolder(dir) {
+  const full = resolve(dir);
+  try { return realpathSync(full); } catch {
+    const parent = dirname(full);
+    return parent === full ? full : join(realPlanFolder(parent), basename(full));
+  }
+}
+
+/**
+ * Files present before the session starts. Filesystem creation timestamps can
+ * lag Date.now(), so they cannot reliably identify a newly created plan.
+ * Device/inode identities also preserve existing files after edits or renames.
+ * Missing folders start empty; unreadable folders remain unclassified.
+ */
+export function snapshotPlanFiles(plansDirs) {
+  const before = { roots: new Set(), files: new Set() };
+  for (const dir of listOf(plansDirs)) {
+    const root = realPlanFolder(dir);
+    try {
+      for (const name of readdirSync(root)) {
+        try { before.files.add(planFileIdentity(lstatSync(join(root, name)))); } catch (err) {
+          if (err?.code !== 'ENOENT' && err?.code !== 'ENOTDIR') throw err;
+        }
+      }
+      before.roots.add(root);
+    } catch (err) {
+      if (err?.code === 'ENOENT') before.roots.add(root);
+    }
+  }
+  return before;
+}
+
+const planFileIdentity = (stat) => `${stat.dev}:${stat.ino}`;
+
 /**
  * The plan file a tool call of the session names, when it is one: a Write or
  * Edit of a Markdown file directly in a plans folder, or the file an
@@ -407,12 +442,13 @@ export function planFileOfToolCall(block, plansDirs) {
  * a plans folder whatever the session's options say (`plansDirectory` only
  * moves it inside the project), so the bridge removes it once the session's
  * process has ended. Only a regular Markdown file that is really in one of the
- * plans folders and was created after the session's process started: a plan
- * that was there before is someone else's.
+ * plans folders and was absent from the pre-session snapshot: a plan that was
+ * there before is someone else's. Callers without a snapshot retain the
+ * timestamp check.
  * @returns {{ removed: string[], failed: string[] }} `failed`: still there
  *   because the removal itself did not work; the caller keeps them and tries again
  */
-export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since }) {
+export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since, before }) {
   const removed = [];
   const failed = [];
   const roots = new Set();
@@ -422,8 +458,11 @@ export function removeTemporaryPlanFiles(paths, { plansDirs, plansDir, since })
       if (extname(path).toLowerCase() !== '.md') continue;
       const stat = lstatSync(path);
       if (!stat.isFile()) continue; // not a link, not a folder
-      if (!roots.has(realpathSync(dirname(path)))) continue;
-      if (!(stat.birthtimeMs >= since)) continue;
+      const parent = realpathSync(dirname(path));
+      if (!roots.has(parent)) continue;
+      if (before) {
+        if (!before.roots.has(parent) || before.files.has(planFileIdentity(stat))) continue;
+      } else if (!(stat.birthtimeMs >= since)) continue;
       unlinkSync(path);
       removed.push(path);
     } catch (err) {