synabun 2.0.0 → 2.0.5

package/hooks/claude-code/session-start.mjs

@@ -3,8 +3,10 @@
 /**
  * SynaBun SessionStart Hook for Claude Code
  *
- * Injects a lean session-start context: greeting, single recall directive,
- * and (when applicable) compaction indexing instructions.
+ * Injects a lean session-start context: the memory header and (when
+ * applicable) compaction indexing instructions. An interactive terminal
+ * session a person starts after time away is also shown SynaBun's greeting
+ * (`systemMessage`): the model is never asked to greet.
  *
  * Heavy reference data (category tree, user-learning rules) is deferred
  * to prompt-submit and post-remember hooks to keep boot fast and clean.
@@ -31,7 +33,7 @@ import { execSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
-import { getHookFeatures, detectProject, ensureProjectCategories, cleanupStaleLoops, cleanupStalePendingRemember, cleanupStaleFiles, appendCapped, DATA_DIR, isTemporaryChat } from './shared.mjs';
+import { getHookFeatures, detectProject, ensureProjectCategories, cleanupStaleLoops, cleanupStalePendingRemember, cleanupStaleFiles, appendCapped, DATA_DIR, isTemporaryChat, niUrl, greetingSurface, greetingOff, GREETING_NOTE_DIR } from './shared.mjs';
 
 // CC updates (especially when installer runs as root) can wipe ~/.claude.json
 // or strip mcpServers.SynaBun, leaving the side panel/CLI with MCP disabled
@@ -65,7 +67,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PRECOMPACT_DIR = join(DATA_DIR, 'precompact');
 const DEBUG_LOG = join(DATA_DIR, 'compact-debug.log');
 const LOOP_DIR = join(DATA_DIR, 'loop');
-// NOTE: Greeting helpers removed — greeting is now built entirely by prompt-submit.mjs
+// NOTE: the template greeting and its helpers are gone. SynaBun writes the greeting itself (openGreeting below).
 
 function getGitBranch(cwd) {
   try {
@@ -142,6 +144,45 @@ function designSystemLine(cwd) {
   } catch { return ''; }
 }
 
+// --- Greeting (neural-interface/lib/greeting/) ---
+
+/** The line the user is shown: SynaBun's words, then what they were based on and what they cost. */
+function greetingLine(greeting) {
+  const head = greeting.away ? `SynaBun \u00b7 back after ${greeting.away}` : 'SynaBun';
+  const records = Array.isArray(greeting.basis) ? greeting.basis.length : 0;
+  const cost = greeting.source === 'writer'
+    ? `written ahead by ${greeting.model || 'Claude'}${Number(greeting.costUsd) > 0 ? ` for $${Number(greeting.costUsd).toFixed(4)}` : ''}`
+    : 'put together from the records, no model';
+  return `${head}: ${greeting.text}\n(${records === 1 ? 'based on 1 record' : `based on ${records} records`}, ${cost})`;
+}
+
+/**
+ * Ask SynaBun's greeting engine whether this opening is a return worth a greeting (a lookup: the
+ * sentence was written ahead of time). → the line to show the user, or ''. The note for the model
+ * is kept for prompt-submit.mjs, which adds it to the first prompt, once.
+ */
+async function openGreeting({ sessionId, cwd }) {
+  try {
+    const response = await fetch(`${niUrl()}/api/greeting/open`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ surface: 'claude-cli', cwd, session: sessionId, note: true }),
+      signal: AbortSignal.timeout(1200),
+    });
+    if (!response.ok) return ''; // an older server (404), an engine that did not start (503)
+    const data = await response.json();
+    const greeting = data?.greeting;
+    if (!greeting || typeof greeting.text !== 'string' || !greeting.text.trim()) return '';
+    if (typeof data.note === 'string' && data.note) {
+      try {
+        mkdirSync(GREETING_NOTE_DIR, { recursive: true });
+        writeJsonAtomic(join(GREETING_NOTE_DIR, `${sessionId}.json`), { id: greeting.id || null, note: data.note, at: new Date().toISOString() });
+      } catch { /* the greeting is still shown; the model simply is not told */ }
+    }
+    return greetingLine(greeting);
+  } catch { return ''; }
+}
+
 // --- Main ---
 
 async function main() {
@@ -208,10 +249,10 @@ async function main() {
   const context = [];
 
   // ============================================================
-  // BLOCK 0: GREETING (highest attention, unless compaction or loop)
+  // BLOCK 0: LOOP DETECTION (a loop session gets a minimal context and returns here)
   // ============================================================
 
-  // Detect active loop — skip greeting + recall for autonomous loop sessions
+  // Detect active loop — an autonomous loop session gets no recall directive and is never greeted
   // Check both pending files (first iteration) AND active state files (subsequent iterations after /clear).
   // When SYNABUN_TERMINAL_SESSION is set (server-launched loop), only match loops
   // owned by THIS terminal — prevents unrelated sessions from entering loop mode.
@@ -221,6 +262,8 @@ async function main() {
   withStateLock(() => cleanupStalePendingRemember());
   // Subagent dispatch stashes are only read within minutes of being written.
   try { withStateLock(() => cleanupStaleFiles(join(DATA_DIR, 'subagent-dispatch'), 24 * 60 * 60 * 1000)); } catch { /* best effort */ }
+  // A greeting note nobody's first prompt picked up (the session was closed unused).
+  try { cleanupStaleFiles(GREETING_NOTE_DIR, 24 * 60 * 60 * 1000); } catch { /* best effort */ }
   const LOOP_STALE_MS = 10 * 60 * 1000;
   const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
   let isLoopSession = false;
@@ -242,7 +285,7 @@ async function main() {
             //   - env set → require exact terminalSessionId match
             //   - env unset → only match loops WITHOUT terminalSessionId
             // A non-loop CLI (env unset) must NOT latch onto a scheduled loop
-            // and suppress its greeting + recall.
+            // and lose its context and its greeting.
             if (terminalSessionEnv) {
               if (data.terminalSessionId !== terminalSessionEnv) continue;
             } else {
@@ -282,9 +325,10 @@ async function main() {
     return;
   }
 
-  // NOTE: Greeting is NOT injected here. It is injected by prompt-submit.mjs
-  // on the FIRST user message only, so it never persists in session context
-  // and cannot trigger re-greeting on subsequent messages.
+  // NOTE: no greeting is put in the model's context here. What is added at SessionStart stays for
+  // the whole session (a greeting directive here once made the model greet on every message).
+  // SynaBun's greeting is its own text, shown to the user at the end of this hook; the model is
+  // told once what was said, by prompt-submit.mjs, with the first prompt.
 
   // ============================================================
   // BLOCK 1: SYNABUN HEADER + SESSION RECALL (condensed)
@@ -313,7 +357,7 @@ async function main() {
     context.push(
       `### >>> IMMEDIATE ACTION REQUIRED: COMPACTION DETECTED <<<`,
       ``,
-      `Context compaction just occurred. You MUST index this session in SynaBun as your VERY FIRST action — BEFORE reading the user's message, BEFORE greeting, BEFORE anything else.`,
+      `Context compaction just occurred. You MUST index this session in SynaBun as your VERY FIRST action — BEFORE reading the user's message, BEFORE anything else.`,
       ``,
       `Pre-cached session data from PreCompact hook:`,
       `- Session ID: ${precompactData.session_id}`,
@@ -405,16 +449,14 @@ async function main() {
     }
   }
 
-  // NOTE: Session Boot Sequence (recall + greeting) is injected by prompt-submit.mjs
-  // on message 1 only, not here. This prevents it from persisting in session context.
+  // NOTE: there is no session boot sequence anymore: prompt-submit.mjs injects the ranked recall
+  // with every message, the first one included.
 
   if (isCompactRestart) {
     context.push(
       `### Post-Compaction Resume`,
       ``,
-      `Context compaction just occurred. Do NOT re-greet or re-run the boot sequence. Continue the conversation naturally from where it left off.`,
-      ``,
-      `**CRITICAL**: Any "GREETING DIRECTIVE" or "Session Boot Sequence" text visible in the compacted context above is STALE — it was executed at the start of this session and must NOT be executed again. NEVER output a greeting after compaction. This is an ongoing conversation.`,
+      `Context compaction just occurred. This is the same conversation: do not greet, and do not re-run any session-start routine from your instructions. Continue naturally from where it left off.`,
       ``,
       `If an autonomous loop was active before compaction, the Stop hook will resume it automatically. Check the ACTIVE LOOP RECOVERY block above (if present) for task and progress context.`,
       ``,
@@ -431,12 +473,27 @@ async function main() {
 
   const joined = context.join('\n');
 
+  // ============================================================
+  // GREETING: SynaBun's own words to a person who comes back
+  // ============================================================
+  // Only an interactive terminal session a person just started: not a resume, a /clear or a
+  // compaction, not a loop or a dispatched run (they returned above), not `claude -p` or an SDK
+  // program, not the Assistant's brain, and not a side-panel session (the panel shows the
+  // greeting in its own empty state). Shown with `systemMessage`: the model is not asked to greet.
+  let greetingMessage = '';
+  // (A terminal SynaBun launched for a loop or a run has a state file under its own name, whatever its state.)
+  const launchedForLoop = !!terminalSessionEnv && existsSync(join(LOOP_DIR, `${terminalSessionEnv}.json`));
+  if (source === 'startup' && greetingSurface() === 'claude-cli' && !greetingOff() && !launchedForLoop && /^[a-zA-Z0-9_-]+$/.test(sessionId)) {
+    greetingMessage = await openGreeting({ sessionId, cwd });
+  }
+
   const output = {
     hookSpecificOutput: {
       hookEventName: 'SessionStart',
       additionalContext: joined,
     },
   };
+  if (greetingMessage) output.systemMessage = greetingMessage;
 
   process.stdout.write(JSON.stringify(output));
 }

package/hooks/claude-code/shared.mjs

@@ -41,6 +41,24 @@ export function isTemporaryChat() {
   return String(process.env.SYNABUN_TEMPORARY_CHAT ?? '').trim() === '1';
 }
 
+/**
+ * Where a Claude Code session was opened, for SynaBun's greeting (neural-interface/lib/greeting/):
+ * 'claude-panel' for a session of the Claude Code side panel (its bridge sets the marker, and the
+ * panel shows the greeting itself), 'claude-cli' for an interactive terminal session, null for
+ * everything else: `claude -p`, an SDK program, the Assistant's brain. A loop or a dispatched run
+ * is told apart by its caller (it shares the terminal's environment).
+ */
+export function greetingSurface(env = process.env) {
+  if (env.SYNABUN_ASSISTANT_SESSION) return null;
+  if (String(env.SYNABUN_PANEL_SESSION ?? '').trim() === '1') return 'claude-panel';
+  return env.CLAUDE_CODE_ENTRYPOINT === 'cli' ? 'claude-cli' : null;
+}
+
+/** SYNABUN_GREETING=off: no greeting is asked for, whatever Settings says. */
+export function greetingOff(env = process.env) {
+  return /^(off|0|false|no)$/i.test(String(env.SYNABUN_GREETING ?? '').trim());
+}
+
 /** A network call whose timeout would be shorter than this is skipped. */
 export const MIN_CALL_MS = 250;
 
@@ -95,6 +113,8 @@ export const ENV_PATH = join(DATA_HOME, '.env');
 export const HOOK_FEATURES_PATH = join(DATA_DIR, 'hook-features.json');
 export const PENDING_REMEMBER_DIR = join(DATA_DIR, 'pending-remember');
 export const LOOP_LOG_DIR = join(DATA_DIR, 'logs');
+// The note about the greeting a terminal session opened with, from SessionStart to the first prompt.
+export const GREETING_NOTE_DIR = join(DATA_DIR, 'greeting-notes');
 
 // --- Loop logging (mirrors neural-interface/lib/loop-logger.js) ---
 // Writes per-loop entries from inside hooks into the same logfile the server uses.

package/hooks/claude-code/stop.mjs

@@ -184,8 +184,7 @@ function planDebug(msg) {
 /**
  * Soft-cleanup a pending-remember flag file.
  * Resets enforcement fields (editCount, retries, files) while preserving
- * session-wide tracking (messageCount, greetingDelivered, etc.) to prevent
- * the greeting from re-firing mid-session.
+ * session-wide tracking (messageCount, the user-learning counters, etc.).
  */
 function softCleanupFlag(flagPath) {
   try {
@@ -200,7 +199,6 @@ function softCleanupFlag(flagPath) {
       messageCount: flag.messageCount || 0,
       totalSessionMessages: flag.totalSessionMessages || 0,
       totalEdits: flag.totalEdits || 0,
-      greetingDelivered: flag.greetingDelivered || false,
       categoryTreeInjected: flag.categoryTreeInjected || false,
       rememberCount: flag.rememberCount || 0,
       planRetries: flag.planRetries || 0,
@@ -225,7 +223,7 @@ function softCleanupFlag(flagPath) {
     writeJsonAtomic(flagPath, cleaned);
   } catch {
     // If we can't clean up gracefully, leave the file as-is
-    // (better than deleting and resetting greeting tracking)
+    // (better than deleting and resetting the session's counters)
   }
 }
 
@@ -920,7 +918,9 @@ function handleStop({ sessionId, lastMessage, cwd, transcriptPath, judged = {},
     // CHECK 2.5: User learning (bundled with task or standalone)
     // Skipped when waiting for user action (interactive flows like Leonardo questionnaires).
     // Limited to 1 retry to minimize chat noise.
-    if (!waitingForUser && flag.userLearningPending && !flag.userLearningObserved) {
+    // Never inside the Assistant's brain (SYNABUN_ASSISTANT_SESSION): SynaBun's harness learns
+    // about the user there, and prompt-submit.mjs never arms this in it.
+    if (!waitingForUser && flag.userLearningPending && !flag.userLearningObserved && !process.env.SYNABUN_ASSISTANT_SESSION) {
       const ulRetries = flag.userLearningRetries || 0;
       if (ulRetries < 1) {
         flag.userLearningRetries = ulRetries + 1;

package/lib/start-launcher.js

@@ -18,6 +18,8 @@
  *                  running, the Terminal asked to open, the supervisor's own
  *                  phases, the server answering) on a loopback beacon the
  *                  offline page reads, because that page has no server to ask.
+ *                  A restart is reported the same way, by the supervisor that
+ *                  brings the server back (`openRestartReport`).
  *
  * Nothing here stays running: the OS starts the launcher per click and it
  * exits once the server answers.
@@ -823,6 +825,9 @@ export function publicSupervisorState(record) {
  * rebinding a name), gives the answer only to a page of this server's own
  * loopback origin, and changes nothing. A port it cannot have is not an
  * error: the launch goes on unreported and the page says less.
+ *
+ * `reason: 'restart'` is a supervisor bringing its server back, not a launcher
+ * starting one: the answer then says so, and its first step is 'restart'.
  */
 export function createStartBeacon({
   port,
@@ -830,12 +835,14 @@ export function createStartBeacon({
   now = () => Date.now(),
   launchId = randomBytes(8).toString('hex'),
   logPath = null,
+  reason = 'start',
   createServerImpl = createServer,
 } = {}) {
+  const restart = reason === 'restart';
   const beaconPort = startBeaconPort(port);
   const hosts = new Set([`127.0.0.1:${beaconPort}`, `localhost:${beaconPort}`]);
   const origins = new Set([`http://localhost:${port}`, `http://127.0.0.1:${port}`, `http://[::1]:${port}`]);
-  const status = { state: 'starting', steps: [{ id: 'received', at: startedAt }], supervisor: null, error: null };
+  const status = { state: 'starting', steps: [{ id: restart ? 'restart' : 'received', at: startedAt }], supervisor: null, error: null };
   let server = null;
   let listening = false;
   let closed = false;
@@ -858,6 +865,7 @@ export function createStartBeacon({
     supervisor: status.supervisor,
     error: status.error,
     log: logPath,
+    ...(restart ? { reason: 'restart' } : {}),
   });
 
   function handle(req, res) {
@@ -991,6 +999,85 @@ export function createStartBeacon({
   };
 }
 
+// ═══════════════════════════════════════════
+// Progress: a restart
+// ═══════════════════════════════════════════
+
+/** Set by a server that had no supervisor for the one it starts to restart it: that start is a restart's. */
+export const RESTART_REPORT_ENV = 'SYNABUN_RESTART_REPORT';
+/** How long a restart's report stays once the server said it is listening: a page polls every 300 ms. */
+export const RESTART_REPORT_SETTLE_MS = 3000;
+
+/**
+ * A restart reports itself the way a launch does, on the start beacon, for as
+ * long as the server is away: the page that asked has no server to ask. Opened
+ * by the supervisor (setup.js) when the server it runs exits to be restarted
+ * (`exited: true`: it saw that process end), and by a supervisor that a server
+ * without one started in its place.
+ *
+ *   phase()        — the supervisor's record changed: pass on what it says now
+ *   failed(error)  — it ended without a server; resolves once a page has read
+ *                    why (`lingerMs` at the most), so the caller can exit then
+ *   close()        — over
+ *
+ * Only what the supervisor writes after the report began goes out: a record
+ * from before it (the server that just stopped was 'listening') is not news.
+ * The report ends by itself a moment after the server says it is listening.
+ * Never throws; a beacon it cannot have leaves the restart unreported.
+ */
+export function openRestartReport({
+  port,
+  dataHome,
+  exited = false,
+  now = () => Date.now(),
+  settleMs = RESTART_REPORT_SETTLE_MS,
+  lingerMs = BEACON_LINGER_MS,
+  beacon = createStartBeacon,
+} = {}) {
+  const startedAt = now();
+  let report = null;
+  try { report = beacon({ port, startedAt, now, reason: 'restart' }); } catch {}
+  let over = !report;
+  let settle = null;
+  const close = () => {
+    if (over) return;
+    over = true;
+    if (settle) clearTimeout(settle);
+    settle = null;
+    try { report.close(); } catch {}
+  };
+  // An earlier report (a restart right before this one) may still be letting go.
+  let listening = Promise.resolve(false);
+  if (report) {
+    try { listening = Promise.resolve(report.listen({ retryMs: 5000 })).catch(() => false); } catch {}
+    if (exited) report.step('exited');
+  }
+  return {
+    get open() { return !over; },
+    phase() {
+      if (over) return;
+      let record = null;
+      try { record = readJson(launcherStatePaths(dataHome).supervisor); } catch {}
+      if (!record || !(Number(record.phaseAt) >= startedAt)) return;
+      report.supervisor(record);
+      if (record.phase === 'listening' && !settle) {
+        settle = setTimeout(close, settleMs);
+        settle.unref?.();
+      }
+    },
+    async failed(error) {
+      if (over) return;
+      if (settle) clearTimeout(settle);
+      settle = null;
+      report.finish('failed', error);
+      await listening; // a failure right after it opened: let it be reachable first
+      try { await report.linger(lingerMs); } catch {}
+      close();
+    },
+    close,
+  };
+}
+
 const LOGIN_ENV_SHELLS = new Set(['zsh', 'bash', 'sh', 'dash', 'ksh', 'mksh', 'yash', 'fish']);
 /** What a launch decides for itself. A profile may export its own; the launch's values stand. */
 const LAUNCH_SETTINGS = ['SYNABUN_DATA_HOME', 'NEURAL_PORT', 'SYNABUN_OPEN_BROWSER'];

package/mcp-server/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2.0.0",
+  "version": "2.0.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-memory-mcp",
-      "version": "2.0.0",
+      "version": "2.0.5",
       "license": "Apache-2.0",
       "dependencies": {
         "@huggingface/transformers": "^3.0.0",

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-mcp",
-  "version": "2.0.0",
+  "version": "2.0.5",
   "private": true,
   "description": "Private MCP server runtime bundled with SynaBun for persistent memory and agent tooling",
   "license": "Apache-2.0",
@@ -16,8 +16,6 @@
   "main": "dist/index.js",
   "scripts": {
     "build": "node ./node_modules/typescript/bin/tsc",
-    "test": "node ./node_modules/vitest/vitest.mjs run",
-    "test:watch": "node ./node_modules/vitest/vitest.mjs",
     "start": "node dist/index.js",
     "setup:embeddings": "node dist/scripts/setup-embeddings.js",
     "start:http": "node dist/preload-http.js",