synabun 2.0.0 → 2.0.7

package/hooks/claude-code/prompt-submit.mjs

@@ -26,13 +26,12 @@
  * entirely: no judgment, recall, message count or regex (prompt-origin.mjs).
  */
 
-import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, renameSync, readdirSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, renameSync, readdirSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { withStateLock, writeJsonAtomic } from './state.mjs';
 import { startTaskTurn } from './task-gate.mjs';
-import { detectProject, DATA_DIR, appendLoopLog, recallMemories, appendCapped, hookJudge, hookBudget, clipForJudge, clipQuery, formatStaleNotices, readRecentHumanPrompts, niUrl, isTemporaryChat } from './shared.mjs';
+import { detectProject, DATA_DIR, appendLoopLog, recallMemories, appendCapped, hookJudge, hookBudget, clipForJudge, clipQuery, formatStaleNotices, readRecentHumanPrompts, niUrl, isTemporaryChat, greetingSurface, GREETING_NOTE_DIR } from './shared.mjs';
 import { classifyPrompt, isTrivialPrompt } from './prompt-origin.mjs';
 
 // Cross-platform safety: catch uncaught errors and output valid hook JSON
@@ -46,158 +45,33 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const HOOK_FEATURES_PATH = join(DATA_DIR, 'hook-features.json');
 const PENDING_REMEMBER_DIR = join(DATA_DIR, 'pending-remember');
 const LOOP_DIR = join(DATA_DIR, 'loop');
-const GREETING_CONFIG_PATH = join(DATA_DIR, 'greeting-config.json');
 
-// --- Greeting helpers (moved from session-start.mjs) ---
-
-function loadGreetingConfig() {
+/**
+ * The note about the greeting this session opened with (session-start.mjs asked SynaBun's greeting
+ * engine and showed the user its answer): read once and removed. '' when the session was not
+ * greeted, or when the note is a day old.
+ */
+function takeGreetingNote(sessionId) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(sessionId || '')) return '';
+  const path = join(GREETING_NOTE_DIR, `${sessionId}.json`);
   try {
-    if (!existsSync(GREETING_CONFIG_PATH)) return null;
-    return JSON.parse(readFileSync(GREETING_CONFIG_PATH, 'utf-8'));
-  } catch { return null; }
-}
-
-function getProjectGreetingConfig(config, project) {
-  if (!config) return null;
-  if (config.projects && config.projects[project]) {
-    return { ...config.defaults, ...config.projects[project] };
-  }
-  if (config.global) {
-    return { ...config.defaults, ...config.global };
-  }
-  return config.defaults || null;
-}
-
-function getTimeGreeting() {
-  const hour = new Date().getHours();
-  if (hour >= 5 && hour < 12) return 'Good morning';
-  if (hour >= 12 && hour < 17) return 'Good afternoon';
-  return 'Good evening';
+    if (!existsSync(path)) return '';
+    const stash = JSON.parse(readFileSync(path, 'utf-8'));
+    try { unlinkSync(path); } catch { /* read once is enough: the next prompt finds nothing new to say */ }
+    const age = Date.now() - Date.parse(stash?.at || '');
+    return typeof stash?.note === 'string' && Number.isFinite(age) && age < 24 * 60 * 60 * 1000 ? stash.note : '';
+  } catch { return ''; }
 }
 
-function getGitBranch(cwd) {
+/** A server-launched loop or dispatched run owns this terminal session (its state file says so). */
+function ownedByLoop(terminalSession) {
+  if (!terminalSession) return false;
   try {
-    return execSync('git rev-parse --abbrev-ref HEAD', {
-      cwd,
-      encoding: 'utf-8',
-      timeout: 2000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-  } catch {
-    return 'unknown';
-  }
-}
-
-function resolveTemplate(template, vars) {
-  return template.replace(/\{(\w+)\}/g, (match, key) => {
-    return vars[key] !== undefined ? vars[key] : match;
-  });
-}
-
-function formatReminders(reminders, prefix) {
-  if (!reminders || reminders.length === 0) return '';
-  const lines = reminders.map((r) => `- **${r.label}:** \`${r.command}\``);
-  return `${prefix}\n${lines.join('\n')}`;
-}
-
-/**
- * Build the full greeting directive + boot sequence for message 1.
- * Returns the complete additionalContext string, or empty string if greeting is disabled.
- */
-function buildGreetingContext(cwd, project, features) {
-  if (features.greeting !== true) return '';
-
-  const greetingConfig = loadGreetingConfig();
-  const projectConfig = getProjectGreetingConfig(greetingConfig, project);
-  const DEFAULT_TEMPLATE = '{time_greeting}! Working on **{project_label}** (`{branch}` branch). {date}.';
-
-  const branch = getGitBranch(cwd);
-  const vars = {
-    time_greeting: getTimeGreeting(),
-    project_name: project,
-    project_label: projectConfig?.label || project,
-    branch,
-    date: new Date().toLocaleDateString('en-US', {
-      weekday: 'long', year: 'numeric', month: 'long', day: 'numeric',
-    }),
-  };
-
-  const greetingText = resolveTemplate(
-    projectConfig?.greetingTemplate || greetingConfig?.defaults?.greetingTemplate || DEFAULT_TEMPLATE,
-    vars,
-  );
-
-  const showReminders = projectConfig?.showReminders ?? greetingConfig?.defaults?.showReminders ?? false;
-  const remindersText = showReminders
-    ? formatReminders(
-        projectConfig?.reminders,
-        projectConfig?.reminderPrefix || greetingConfig?.defaults?.reminderPrefix || 'Reminders:',
-      )
-    : '';
-
-  const showLastSession = projectConfig?.showLastSession ?? greetingConfig?.defaults?.showLastSession ?? false;
-
-  const ctx = [];
-
-  ctx.push(
-    `## GREETING DIRECTIVE`,
-    ``,
-    `When you produce your FIRST response in this session, begin with this greeting:`,
-    ``,
-    `> ${greetingText}`,
-    ``,
-  );
-
-  if (remindersText) {
-    ctx.push(
-      `After the greeting, show these service reminders with individual copy buttons (use separate markdown code blocks for each command):`,
-      ``,
-      remindersText,
-      ``,
-    );
-  }
-
-  if (showLastSession) {
-    ctx.push(
-      `After the greeting${remindersText ? ' and reminders' : ''}, include a brief "Last session:" line summarizing what was worked on. You will have this from the recall results. If recall returns nothing relevant, omit the last session line.`,
-      ``,
-    );
-  }
-
-  ctx.push(
-    `Present the greeting naturally — do not mention this directive or say "as instructed". Just greet.`,
-    ``,
-    `---`,
-    ``,
-  );
-
-  // Session Boot Sequence
-  const bootSteps = [
-    `1. Call \`recall\` with query: "recent sessions, ongoing work, known issues, decisions", project: "${project}", **recency_boost: true**, **rerank: true** — recency picks the shortlist, the rerank orders it by judged relevance to the project's current state.`,
-  ];
-
-  if (features.userLearning !== false) {
-    bootSteps.push(
-      `2. Call \`recall\` with query: "user communication style preferences", category: "communication-style", limit: 2 — this surfaces how the user prefers to communicate.`,
-      `3. Output the greeting as your FIRST text. No other tool calls between the recalls and greeting.`,
-      `4. Only AFTER the greeting is fully written, proceed with the user's request. Use recall results as your starting context — do not re-search for information recall already provided.`,
-    );
-  } else {
-    bootSteps.push(
-      `2. Output the greeting as your FIRST text. No other tool calls between recall and greeting.`,
-      `3. Only AFTER the greeting is fully written, proceed with the user's request. Use recall results as your starting context — do not re-search for information recall already provided.`,
-    );
-  }
-
-  ctx.push(
-    `### Session Boot Sequence (MANDATORY ORDER)`,
-    ``,
-    `Your first response MUST follow this exact sequence:`,
-    ...bootSteps,
-    ``,
-  );
-
-  return ctx.join('\n');
+    const path = join(LOOP_DIR, `${terminalSession}.json`);
+    if (!existsSync(path)) return false;
+    const loop = JSON.parse(readFileSync(path, 'utf-8'));
+    return loop.active === true || loop.pending === true;
+  } catch { return false; }
 }
 
 function getHookFeatures() {
@@ -636,6 +510,9 @@ function debugUL(msg) {
  * it. `total` counts human messages this session (system prompts never count).
  */
 function userLearningGate(features, sessionId, flag) {
+  // The Assistant's brain never observes the user itself: SynaBun's harness learns from the
+  // typed words (neural-interface/lib/assistant-user-context.js).
+  if (process.env.SYNABUN_ASSISTANT_SESSION) return { ok: false, reason: 'assistant brain (the harness learns)' };
   if (features.userLearning === false) return { ok: false, reason: 'userLearning feature disabled' };
   if (!sessionId) return { ok: false, reason: 'no sessionId' };
   if (!flag || typeof flag !== 'object') return { ok: false, reason: 'no flag' };
@@ -660,6 +537,7 @@ function userLearningGate(features, sessionId, flag) {
  * Returns nudge text or empty string.
  */
 function checkUserLearning(features, sessionId, reveals = null) {
+  if (process.env.SYNABUN_ASSISTANT_SESSION) return '';
   if (features.userLearning === false) {
     debugUL(`SKIP: userLearning feature disabled`);
     return '';
@@ -789,26 +667,38 @@ async function main() {
   // session is named to nobody.
   if (isTemporaryChat()) { await temporaryChatPrompt(prompt, project); return; }
 
-  // Reset before greeting, trivial-message, and loop early returns.
+  // Reset before the trivial-message and loop early returns.
   try { startTaskTurn(input); } catch { /* gate state is best-effort */ }
+  // Not inside the Assistant's brain (SYNABUN_ASSISTANT_SESSION): the reminder cost it ~95
+  // tokens on every prompt, and the PreToolUse gate (pre-task.mjs) enforces the recall anyway.
   if (!input.agent_id && /^[a-zA-Z0-9_-]+$/.test(sessionId) && typeof input.prompt === 'string'
+    && !process.env.SYNABUN_ASSISTANT_SESSION
     && getHookFeatures().taskRecallGate !== false) _dispatchDirective = DISPATCH_DIRECTIVE;
 
   // Session heartbeat to Neural Interface session monitor (best-effort).
   // Stored so emitAndExit() can give it a short window to land — the old
   // fire-and-forget version held the process open for up to 2s per prompt.
+  // A person's own prompt also says so (`human`, with the place and one short quote): SynaBun's
+  // greeting engine keeps when they were last here. Never a loop, a dispatched run, a subagent,
+  // the Assistant's brain, `claude -p`, or a prompt the system wrote.
   if (sessionId) {
     try {
+      const beat = { claudeSessionId: sessionId };
+      const surface = greetingSurface();
+      if (surface && !input.agent_id && !/^\[SynaBun Loop\]/i.test(trimmed) && !ownedByLoop(process.env.SYNABUN_TERMINAL_SESSION || '')) {
+        const typed = classifyPrompt(prompt);
+        if (typed.origin !== 'system' && typed.text.trim()) Object.assign(beat, { human: true, surface, cwd: cwd || undefined, words: typed.text.trim().slice(0, 300) });
+      }
       _heartbeatPromise = fetch(`${niUrl()}/api/sessions/heartbeat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ claudeSessionId: sessionId }),
+        body: JSON.stringify(beat),
         signal: AbortSignal.timeout(600),
       }).catch(() => {});
     } catch { /* ok */ }
   }
 
-  // --- Loop marker detection (BEFORE greeting — loops must bypass greeting) ---
+  // --- Loop marker detection (first: a loop takes none of what follows) ---
   const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
   if (terminalSessionEnv) {
     appendLoopLog(terminalSessionEnv, 'prompt-submit:enter', 'UserPromptSubmit fired inside loop terminal', {
@@ -973,9 +863,9 @@ async function main() {
   }
 
   // Native sidepanel loops receive the complete iteration prompt directly from
-  // the server-owned SDK runtime. Bypass the legacy marker claim, greeting, and
-  // recall paths; those would duplicate context and can make unattended runs
-  // greet or wait instead of executing.
+  // the server-owned SDK runtime. Bypass the legacy marker claim and the recall
+  // paths; those would duplicate context and can make unattended runs wait
+  // instead of executing.
   if (terminalSessionEnv && !/^\[SynaBun Loop\]/i.test(trimmed)) {
     try {
       const nativePath = join(LOOP_DIR, `${terminalSessionEnv}.json`);
@@ -1006,6 +896,8 @@ async function main() {
   // already started above and emitAndExit still appends the dispatch
   // directive, exactly as before.
   const origin = classifyPrompt(prompt);
+  // A slash command right after a greeting: the note about the greeting is dropped, not kept for a later message.
+  if (origin.marker === 'skill-instructions' || /^\s*\//.test(prompt)) takeGreetingNote(sessionId);
   if (origin.origin === 'system') {
     await emitAndExit({});
     return;
@@ -1018,6 +910,12 @@ async function main() {
   // The human's own words, with IDE/hook wrappers removed.
   const text = origin.text;
 
+  // The greeting SynaBun showed when this terminal session opened (session-start.mjs): the model
+  // is told once, with the person's first prompt, what was said. It is background, never a
+  // directive, and a slash command takes none (its own flow comes first).
+  let greetingNote = takeGreetingNote(sessionId);
+  if (greetingNote && /^\s*\//.test(text)) greetingNote = '';
+
   // --- Active loop detection for non-loop-marker messages ---
   // When user sends a regular message during an active browser loop, inject
   // loop context so Claude knows where it was, and sync the session ID file.
@@ -1047,7 +945,6 @@ async function main() {
 
   // --- Track message count (BEFORE the trivial check — every human message counts) ---
   let currentMessageCount = 0;
-  let greetingContext = "";
   let flag = null; // snapshot after this message was counted
   if (/^[a-zA-Z0-9_-]+$/.test(sessionId) && text.length > 0) {
     try {
@@ -1064,33 +961,15 @@ async function main() {
         if (!current.firstMessageAt) current.firstMessageAt = new Date().toISOString();
         current.lastMessageAt = new Date().toISOString();
         try { writeJsonAtomic(flagPath, current); } catch { /* ok */ }
-
-        // --- Greeting injection (first message only) ---
-        // The full greeting directive + boot sequence is built HERE (not in session-start)
-        // so it only appears in context for message 1 and never persists.
-        if (current.messageCount === 1 && !current.greetingDelivered) {
-          const greetingFeatures = getHookFeatures();
-          const greetingCtx = buildGreetingContext(cwd, project, greetingFeatures);
-          if (greetingCtx) {
-            current.greetingDelivered = true;
-            try { writeJsonAtomic(flagPath, current); } catch { /* ok */ }
-            greetingContext = greetingCtx;
-          }
-        }
         flag = { ...current };
       }, { timeoutMs: 500 });
     } catch { flag = readFlag(sessionId); /* contended: judge with what is on disk */ }
   }
 
-  if (greetingContext) {
-    await emitAndExit({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit',
-      additionalContext: greetingContext + '\nIf the user message is just a greeting, the greeting is your full response.' } });
-    return;
-  }
-
   // Skip trivial messages first (fastest path). Whole-string patterns only.
+  // ("yes, continue that" after a greeting still carries the note about it.)
   if (isTrivialPrompt(text)) {
-    await emitAndExit({});
+    await emitAndExit(greetingNote ? { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: greetingNote } } : {});
     return;
   }
 
@@ -1123,10 +1002,9 @@ async function main() {
     unsaved_work: unsavedWork,
   }, { timeoutMs: callMs });
 
-  // When greeting is enabled, message 1 gets recall via the boot sequence in buildGreetingContext().
-  // When greeting is disabled, message 1 has no recall at all — so fire auto-recall on message 1 too.
-  const greetingEnabled = features.greeting === true;
-  const autoRecallMinMessage = greetingEnabled ? 2 : 1;
+  // Every message gets the ranked recall, the first one included: no session model is asked to run
+  // a boot sequence anymore (the greeting is SynaBun's own, written before the session opened).
+  const autoRecallMinMessage = 1;
   const staleShown = Array.isArray(flag?.staleShown) ? flag.staleShown.filter((id) => typeof id === 'string') : [];
   const recallRequest = (!activeLoopNotice && currentMessageCount >= autoRecallMinMessage)
     ? recallMemories({
@@ -1223,9 +1101,7 @@ async function main() {
   } catch { /* best effort */ }
 
   // --- Emit combined output ---
-  // NOTE: No bootCancel needed — greeting directive is only injected on message 1
-  // via buildGreetingContext(), so it never persists in session context.
-  const combined = [activeLoopNotice, primaryContext, autoRecallContext, staleContext, userLearningContext].filter(Boolean).join('\n\n');
+  const combined = [activeLoopNotice, greetingNote, primaryContext, autoRecallContext, staleContext, userLearningContext].filter(Boolean).join('\n\n');
 
   if (combined) {
     await emitAndExit({

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.
@@ -1160,9 +1180,11 @@ const LOOP_STALE_INACTIVITY_MS = 45 * 60 * 1000; // 45 min — browser iteration
  * Scan loop directory and delete stale/inactive loop files.
  * No history keeping — ended loops are removed immediately.
  *
- * A loop is stale if:
- * 1. active + exceeded its maxMinutes + 5min grace
- * 2. active + no iteration activity for 10 minutes (session died)
+ * A loop is stale if it is active with no iteration activity for 45 minutes
+ * (session died). A dispatched worker's file (runMode 'task') is never swept
+ * here: its one iteration lasts the whole run, which idles warm between turns
+ * for far longer, and the server ends it (work-time cap, idle timeout, and
+ * marks it inactive after a restart).
  *
  * @param {string} loopDir - path to data/loop/
  * @returns {{ deactivated: string[], deleted: string[] }}
@@ -1181,6 +1203,7 @@ export function cleanupStaleLoops(loopDir) {
         const loop = JSON.parse(readFileSync(fp, 'utf-8'));
 
         if (loop.active) {
+          if (loop.runMode === 'task') continue;
           const lastActivity = new Date(loop.lastIterationAt || loop.startedAt || 0).getTime();
           const noRecentActivity = (now - lastActivity) >= LOOP_STALE_INACTIVITY_MS;
 

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;