synabun 2026.4.21 → 2026.4.25-beta.2

package/README.md

@@ -151,7 +151,7 @@ synabun
 ### Or clone from GitHub
 
 ```bash
-git clone https://github.com/danilokhury/Synabun.git
+git clone --depth=1 https://github.com/danilokhury/Synabun.git
 cd Synabun
 npm start
 ```

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

@@ -20,7 +20,7 @@ import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, ren
 import { execSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { detectProject, DATA_DIR } from './shared.mjs';
+import { detectProject, DATA_DIR, appendLoopLog } from './shared.mjs';
 
 // Cross-platform safety: catch uncaught errors and output valid hook JSON
 process.on('uncaughtException', () => { try { process.stdout.write('{}'); } catch {} process.exit(0); });
@@ -236,14 +236,15 @@ function buildBrowserNote(state) {
     '=== BROWSER ENFORCEMENT (MANDATORY) ===',
     'This automation REQUIRES the SynaBun internal browser. You MUST:',
   ];
-  // Session and tab are auto-routed via SYNABUN_BROWSER_SESSION / SYNABUN_BROWSER_TAB env vars.
-  // Display IDs for debugging visibility but no manual pass-through needed.
+  // HTTP MCP is shared across all loops — env-var pinning does NOT route tool calls.
+  // Claude must pass sessionId/tabId explicitly on every browser tool call, or a
+  // concurrent loop will hijack the tab.
   if (state.browserSessionId) {
     lines.push(`YOUR BROWSER SESSION: ${state.browserSessionId}`);
     if (state.browserTabId) {
       lines.push(`YOUR BROWSER TAB: ${state.browserTabId}`);
     }
-    lines.push('Your session and tab are auto-configured via environment. All browser tool calls will target your dedicated tab automatically — no need to pass sessionId or tabId manually.');
+    lines.push(`CRITICAL: Pass sessionId: "${state.browserSessionId}"${state.browserTabId ? ` and tabId: "${state.browserTabId}"` : ''} to EVERY browser tool call (browser_navigate, browser_click, browser_snapshot, browser_extract_*, etc.). Omitting them will cause your tool calls to hijack another loop's tab. No exceptions.`);
   }
   lines.push(
     '1. Call `browser_navigate` with your target URL to create or reuse a browser session',
@@ -720,28 +721,39 @@ async function main() {
 
   // --- Loop marker detection (BEFORE greeting — loops must bypass greeting) ---
   const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
+  if (terminalSessionEnv) {
+    appendLoopLog(terminalSessionEnv, 'prompt-submit:enter', 'UserPromptSubmit fired inside loop terminal', {
+      sessionId, isLoopMarker: /^\[SynaBun Loop\]/i.test(trimmed), promptPreview: trimmed.slice(0, 200),
+    });
+  }
   if (sessionId && /^\[SynaBun Loop\]/i.test(trimmed)) {
     try {
       if (existsSync(LOOP_DIR)) {
         const pending = readdirSync(LOOP_DIR)
           .filter(f => f.startsWith('pending-') && f.endsWith('.json'));
-        // Filter by terminalSessionId when available (multi-loop isolation).
-        // Without the env var, fall back to first match (legacy behavior).
+        // STRICT multi-loop isolation: only claim a pending file whose
+        // terminalSessionId matches our SYNABUN_TERMINAL_SESSION env.
+        // Legacy "match first pending" fallback was removed — it silently
+        // stole loops across concurrent sessions (sidepanel plan ↔ scheduled
+        // CLI loop in same cwd). Loop spawners MUST set the env var.
+        // Legacy pending files without terminalSessionId are still claimable
+        // when this session also has no env (ancient manual-loop compat).
         let matchedPending = null;
-        if (terminalSessionEnv) {
-          for (const pf of pending) {
-            try {
-              const ps = JSON.parse(readFileSync(join(LOOP_DIR, pf), 'utf-8'));
+        for (const pf of pending) {
+          try {
+            const ps = JSON.parse(readFileSync(join(LOOP_DIR, pf), 'utf-8'));
+            if (terminalSessionEnv) {
               if (ps.terminalSessionId === terminalSessionEnv) { matchedPending = pf; break; }
-            } catch { continue; }
-          }
-        } else if (pending.length > 0) {
-          matchedPending = pending[0];
+            } else {
+              if (!ps.terminalSessionId) { matchedPending = pf; break; }
+            }
+          } catch { continue; }
         }
         if (matchedPending) {
           const pendingPath = join(LOOP_DIR, matchedPending);
           const targetPath = join(LOOP_DIR, `${sessionId}.json`);
           renameSync(pendingPath, targetPath);
+          appendLoopLog(terminalSessionEnv, 'prompt-submit:claim', 'pending loop renamed to active', { from: matchedPending, to: `${sessionId}.json` });
 
           const state = JSON.parse(readFileSync(targetPath, 'utf-8'));
           delete state.pending;
@@ -751,6 +763,7 @@ async function main() {
           state.currentIteration = 1;
           // Preserve terminalSessionId — loop driver needs it for session isolation
           writeFileSync(targetPath, JSON.stringify(state, null, 2));
+          appendLoopLog(terminalSessionEnv, 'prompt-submit:inject', 'iteration 1 context built — emitting additionalContext', { task: state.task?.slice(0, 200), totalIterations: state.totalIterations, usesBrowser: !!state.usesBrowser });
 
           const browserNote = buildBrowserNote(state);
           const blockerRule = state.usesBrowser
@@ -782,8 +795,11 @@ async function main() {
           try { state = JSON.parse(readFileSync(existingPath, 'utf-8')); } catch { /* skip */ }
         }
         // Fallback: scan loop files for an active loop (session ID may have changed after /clear).
-        // When SYNABUN_TERMINAL_SESSION is set, only match loops owned by this terminal.
-        // Without the env var, fall back to first active loop (legacy behavior).
+        // STRICT isolation: only match our terminal's loop.
+        //   - env set → require exact terminalSessionId match
+        //   - env unset → only match loops WITHOUT terminalSessionId (legacy manual loops)
+        // Previously the filter was disabled when env was empty, letting any
+        // Claude session grab any active loop in the same LOOP_DIR.
         if (!state?.active || !(state?.currentIteration > 0)) {
           const now = Date.now();
           const allLoopFiles = readdirSync(LOOP_DIR)
@@ -793,8 +809,12 @@ async function main() {
               const fullPath = join(LOOP_DIR, f);
               const candidate = JSON.parse(readFileSync(fullPath, 'utf-8'));
               if (candidate.active && candidate.currentIteration > 0) {
-                // Multi-loop isolation: only match OUR terminal's loop
-                if (terminalSessionEnv && candidate.terminalSessionId && candidate.terminalSessionId !== terminalSessionEnv) continue;
+                // Multi-loop isolation
+                if (terminalSessionEnv) {
+                  if (candidate.terminalSessionId !== terminalSessionEnv) continue;
+                } else {
+                  if (candidate.terminalSessionId) continue;
+                }
                 // Validate the loop hasn't exceeded its own time cap + grace
                 // Skip loops inactive for >45 minutes (stuck)
                 const lastAct = new Date(candidate.lastIterationAt || candidate.startedAt || 0).getTime();
@@ -807,6 +827,7 @@ async function main() {
           }
         }
         if (state?.active && state?.currentIteration > 0) {
+            appendLoopLog(terminalSessionEnv, 'prompt-submit:inject', 'subsequent iteration context built', { iter: state.currentIteration, total: state.totalIterations, usesBrowser: !!state.usesBrowser });
             const formattingRules = extractFormattingRules(state.task);
             const browserNote = buildBrowserNote(state);
             const blockerRule2 = state.usesBrowser

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

@@ -171,9 +171,16 @@ async function main() {
           if (data.stopped === true || data.finishedAt) continue;
           // Active loop detected (pending or already running)
           if (data.active || data.pending) {
-            // Multi-loop isolation: only match OUR terminal's loop
-            // If the loop belongs to a specific terminal, only match if this session is that same terminal
-            if (data.terminalSessionId && data.terminalSessionId !== terminalSessionEnv) continue;
+            // STRICT multi-loop isolation:
+            //   - 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.
+            if (terminalSessionEnv) {
+              if (data.terminalSessionId !== terminalSessionEnv) continue;
+            } else {
+              if (data.terminalSessionId) continue;
+            }
             isLoopSession = true;
             break;
           }

package/hooks/claude-code/shared.mjs

@@ -5,8 +5,8 @@
  * post-remember, pre-compact, and stop hooks.
  */
 
-import { readFileSync, existsSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { dirname, join, basename } from 'node:path';
+import { readFileSync, existsSync, writeFileSync, readdirSync, unlinkSync, appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join, basename, resolve as pathResolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getDataHome } from '../../lib/paths.js';
 
@@ -17,6 +17,43 @@ export const MCP_DATA_DIR = join(DATA_HOME, 'mcp-data');
 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');
+
+// --- Loop logging (mirrors neural-interface/lib/loop-logger.js) ---
+// Writes per-loop entries from inside hooks into the same logfile the server uses.
+
+let _loopLogDirEnsured = false;
+function ensureLoopLogDir() {
+  if (_loopLogDirEnsured) return;
+  try {
+    if (!existsSync(LOOP_LOG_DIR)) mkdirSync(LOOP_LOG_DIR, { recursive: true });
+    _loopLogDirEnsured = true;
+  } catch { /* ok */ }
+}
+
+function safeJsonInline(obj) {
+  try {
+    return JSON.stringify(obj, (_k, v) => {
+      if (typeof v === 'string' && v.length > 800) return v.slice(0, 800) + `…(+${v.length - 800})`;
+      return v;
+    });
+  } catch { return '<unserializable>'; }
+}
+
+/**
+ * Append one log entry to the per-loop logfile and stderr.
+ * tsid may be null/undefined; will fall back to SYNABUN_TERMINAL_SESSION env.
+ */
+export function appendLoopLog(tsid, tag, msg, meta = undefined) {
+  const sid = tsid || process.env.SYNABUN_TERMINAL_SESSION || null;
+  const line = `${new Date().toISOString()} | hook:${tag} | ${msg}${meta ? ' | ' + safeJsonInline(meta) : ''}\n`;
+  try { process.stderr.write(`[loop:hook:${tag}] ${msg}${meta ? ' ' + safeJsonInline(meta) : ''}\n`); } catch { /* ok */ }
+  if (!sid) return;
+  ensureLoopLogDir();
+  try {
+    appendFileSync(pathResolve(LOOP_LOG_DIR, `loop-${sid}.log`), line);
+  } catch { /* ok */ }
+}
 
 // --- Stdin ---
 

package/hooks/claude-code/stop.mjs

@@ -31,7 +31,7 @@
 import { readFileSync, writeFileSync, existsSync, unlinkSync, appendFileSync, readdirSync, renameSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { cleanupStaleLoops, detectProject, DATA_DIR } from './shared.mjs';
+import { cleanupStaleLoops, detectProject, DATA_DIR, appendLoopLog } from './shared.mjs';
 
 // Cross-platform safety: catch uncaught errors and output valid hook JSON
 process.on('uncaughtException', () => { try { process.stdout.write('{}'); } catch {} process.exit(0); });
@@ -282,6 +282,7 @@ async function main() {
   // loops owned by THIS terminal — prevents other automations from suppressing
   // compaction in unrelated sessions.
   const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION || '';
+  appendLoopLog(terminalSessionEnv || null, 'stop:enter', 'Stop hook fired', { sessionId, hasEnv: !!terminalSessionEnv });
   let hasActiveLoop = false;
   try {
     if (existsSync(LOOP_DIR)) {
@@ -290,8 +291,16 @@ async function main() {
         try {
           const candidate = JSON.parse(readFileSync(join(LOOP_DIR, f), 'utf-8'));
           if (candidate.active && (candidate.currentIteration || 0) > 0) {
-            // When running inside a loop terminal, only match OUR loop
-            if (terminalSessionEnv && candidate.terminalSessionId && candidate.terminalSessionId !== terminalSessionEnv) continue;
+            // STRICT isolation. Before: `terminalSessionEnv &&` gated the
+            // mismatch check, so a session with no env would pick up ANY
+            // loop and wrongly suppress its own compaction. Now:
+            //   - env set → require exact terminalSessionId match
+            //   - env unset → only count loops WITHOUT terminalSessionId
+            if (terminalSessionEnv) {
+              if (candidate.terminalSessionId !== terminalSessionEnv) continue;
+            } else {
+              if (candidate.terminalSessionId) continue;
+            }
             hasActiveLoop = true;
             break;
           }
@@ -410,9 +419,17 @@ async function main() {
             loop = candidate;
             const newPath = join(LOOP_DIR, `${sessionId}.json`);
             if (fp !== newPath) {
-              try { renameSync(fp, newPath); loopFlagPath = newPath; } catch { loopFlagPath = fp; }
+              try {
+                renameSync(fp, newPath);
+                loopFlagPath = newPath;
+                appendLoopLog(terminalSessionEnv, 'stop:claim', 'matched loop via Strategy A (env), renamed', { from: f, to: `${sessionId}.json`, currentIteration: candidate.currentIteration });
+              } catch (err) {
+                loopFlagPath = fp;
+                appendLoopLog(terminalSessionEnv, 'stop:claim', 'matched loop via Strategy A (env), rename FAILED', { from: f, err: err.message });
+              }
             } else {
               loopFlagPath = fp;
+              appendLoopLog(terminalSessionEnv, 'stop:claim', 'matched loop via Strategy A (env), already named correctly', { file: f, currentIteration: candidate.currentIteration });
             }
             break;
           }
@@ -505,7 +522,12 @@ async function main() {
 
       // Signal server loop driver to send /clear + next iteration prompt
       loop.awaitingNext = true;
-      try { writeFileSync(loopFlagPath, JSON.stringify(loop, null, 2)); } catch { /* ok */ }
+      try {
+        writeFileSync(loopFlagPath, JSON.stringify(loop, null, 2));
+        appendLoopLog(loop.terminalSessionId || terminalSessionEnv, 'stop:awaitingNext', 'set awaitingNext=true', { iter: loop.currentIteration, total: loop.totalIterations, file: loopFlagPath });
+      } catch (err) {
+        appendLoopLog(loop.terminalSessionId || terminalSessionEnv, 'stop:awaitingNext', 'write FAILED', { err: err.message });
+      }
 
       // Reset edit tracking for fresh iteration context
       const rememberFlagForReset = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
@@ -530,7 +552,12 @@ async function main() {
       }
 
       loop.awaitingNext = true;
-      try { writeFileSync(loopFlagPath, JSON.stringify(loop, null, 2)); } catch { /* ok */ }
+      try {
+        writeFileSync(loopFlagPath, JSON.stringify(loop, null, 2));
+        appendLoopLog(loop.terminalSessionId || terminalSessionEnv, 'stop:awaitingNext', 'set awaitingNext=true', { iter: loop.currentIteration, total: loop.totalIterations, file: loopFlagPath });
+      } catch (err) {
+        appendLoopLog(loop.terminalSessionId || terminalSessionEnv, 'stop:awaitingNext', 'write FAILED', { err: err.message });
+      }
 
       const rememberFlagForReset = join(PENDING_REMEMBER_DIR, `${sessionId}.json`);
       if (existsSync(rememberFlagForReset)) {

package/mcp-server/src/index.ts

@@ -86,12 +86,20 @@ Use "category" with action "list" to see valid category names before using remem
     instructions += `\n\nLeonardo tools are 100% browser-based — no API key needed. Use leonardo_browser_navigate to go to the right page, then use generic browser tools (browser_click, browser_fill, browser_snapshot) to configure settings (model, style, dimensions, motion controls), and leonardo_browser_generate to fill the prompt and click Generate. Use the /leonardo skill for the full guided creation experience.`;
   }
 
+  // Dedupe this log — buildServerInstructions runs on every HTTP MCP request
+  // (fresh server per request), which would otherwise spam this line forever.
   const profileName = getActiveProfileName();
-  console.error(`[SynaBun] Profile: ${profileName} (${activeGroups.size} groups, instructions: ${instructions.length} chars)`);
+  const sig = `${profileName}|${activeGroups.size}|${instructions.length}`;
+  if (sig !== _lastInstructionsSig) {
+    _lastInstructionsSig = sig;
+    console.error(`[SynaBun] Profile: ${profileName} (${activeGroups.size} groups, instructions: ${instructions.length} chars)`);
+  }
 
   return instructions;
 }
 
+let _lastInstructionsSig: string | null = null;
+
 // Register ALL tools on a given McpServer instance.
 // All groups are always registered; applyProfile() enables/disables them.
 export function registerTools(server: McpServer) {

package/mcp-server/src/services/neural-interface.ts

@@ -10,6 +10,14 @@ const DEFAULT_TIMEOUT = 10_000;
 const LONG_TIMEOUT = 30_000;
 const SESSION_CREATE_TIMEOUT = 70_000;
 
+export function isBrowserFastMode(): boolean {
+  return process.env.SYNABUN_BROWSER_FAST === '1';
+}
+
+export function isBrowserCompactMode(): boolean {
+  return process.env.SYNABUN_BROWSER_COMPACT === '1' || isBrowserFastMode();
+}
+
 export interface BrowserSessionInfo {
   id: string;
   url: string;
@@ -82,8 +90,14 @@ export async function resolveSession(
   autoCreate?: { url?: string },
   tabId?: string
 ): Promise<{ sessionId: string; tabId?: string } | { error: string }> {
-  // Resolve tab ID from explicit param or environment variable
-  const resolvedTabId = tabId || process.env.SYNABUN_BROWSER_TAB || undefined;
+  // Resolve tab ID from explicit param or environment variable.
+  // When SYNABUN_BROWSER_TAB is pinned (loop/agent context), the env value wins
+  // even if caller passes a different tabId — prevents tab-leak across loops.
+  const pinnedTab = process.env.SYNABUN_BROWSER_TAB || undefined;
+  const resolvedTabId = pinnedTab || tabId || undefined;
+  if (pinnedTab && tabId && tabId !== pinnedTab) {
+    console.error(`[MCP] tabId override ignored: pinned=${pinnedTab} requested=${tabId}`);
+  }
 
   // Agent/loop-scoped browser session — set by the orchestrator to pin
   // this MCP instance to a specific browser session (multi-session isolation).
@@ -121,6 +135,17 @@ export async function resolveSession(
     return { sessionId, tabId: resolvedTabId };
   }
 
+  // Codex fast mode favors one direct create call on first navigate. This avoids
+  // the list-sessions round trip that dominates short browser flows.
+  if (autoCreate && isBrowserFastMode()) {
+    const created = await request('POST', '/api/browser/sessions', {
+      url: autoCreate.url || 'about:blank',
+    }, SESSION_CREATE_TIMEOUT);
+    if (created.error) return { error: `Failed to auto-create session: ${created.error}` };
+    _affinitySessionId = created.sessionId as string;
+    return { sessionId: _affinitySessionId, tabId: resolvedTabId };
+  }
+
   // List sessions (single GET used for both affinity check and auto-selection)
   const data = await request('GET', '/api/browser/sessions');
   if (data.error) return { error: data.error };
@@ -212,21 +237,22 @@ export async function navigate(
 ): Promise<NiResponse> {
   return request('POST', `/api/browser/sessions/${sessionId}/navigate`, {
     url,
+    ...(isBrowserCompactMode() && { compact: true }),
     ...(returnSnapshot && { returnSnapshot }),
     ...(tabId && { tabId }),
   }, LONG_TIMEOUT);
 }
 
 export async function goBack(sessionId: string, tabId?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/back`, { ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/back`, { ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function goForward(sessionId: string, tabId?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/forward`, { ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/forward`, { ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function reload(sessionId: string, tabId?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/reload`, { ...(tabId && { tabId }) }, LONG_TIMEOUT);
+  return request('POST', `/api/browser/sessions/${sessionId}/reload`, { ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) }, LONG_TIMEOUT);
 }
 
 // ── Interaction (selector-based) ──
@@ -243,29 +269,31 @@ export async function click(
     selector,
     ...(nthMatch !== undefined && { nthMatch }),
     ...(textHint && { textHint }),
+    ...(isBrowserCompactMode() && { compact: true }),
     ...(returnSnapshot && { returnSnapshot }),
     ...(tabId && { tabId }),
   });
 }
 
 export async function fill(sessionId: string, selector: string, value: string, nthMatch?: number, tabId?: string, textHint?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/fill`, { selector, value, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/fill`, { selector, value, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
-export async function type(sessionId: string, selector: string | null, text: string, nthMatch?: number, tabId?: string, textHint?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/type`, { selector, text, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(tabId && { tabId }) });
+export async function type(sessionId: string, selector: string | null, text: string, nthMatch?: number, tabId?: string, textHint?: string, mode?: 'sequential' | 'insert'): Promise<NiResponse> {
+  const resolvedMode = mode || (isBrowserFastMode() ? 'insert' : 'sequential');
+  return request('POST', `/api/browser/sessions/${sessionId}/type`, { selector, text, mode: resolvedMode, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function hover(sessionId: string, selector: string, nthMatch?: number, tabId?: string, textHint?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/hover`, { selector, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/hover`, { selector, ...(nthMatch !== undefined && { nthMatch }), ...(textHint && { textHint }), ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function selectOption(sessionId: string, selector: string, value: string, nthMatch?: number, tabId?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/select`, { selector, value, ...(nthMatch !== undefined && { nthMatch }), ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/select`, { selector, value, ...(nthMatch !== undefined && { nthMatch }), ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function pressKey(sessionId: string, key: string, tabId?: string): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/press`, { key, ...(tabId && { tabId }) });
+  return request('POST', `/api/browser/sessions/${sessionId}/press`, { key, ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) });
 }
 
 export async function scroll(
@@ -273,7 +301,7 @@ export async function scroll(
   opts: { direction: string; distance?: number; selector?: string; returnSnapshot?: { mode?: string; selector?: string; viewport?: boolean } },
   tabId?: string
 ): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/scroll`, { ...opts, ...(tabId && { tabId }) } as Record<string, unknown>);
+  return request('POST', `/api/browser/sessions/${sessionId}/scroll`, { ...opts, ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) } as Record<string, unknown>);
 }
 
 export async function upload(
@@ -283,7 +311,7 @@ export async function upload(
   nthMatch?: number,
   tabId?: string
 ): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/upload`, { selector, filePaths, ...(nthMatch !== undefined && { nthMatch }), ...(tabId && { tabId }) }, LONG_TIMEOUT);
+  return request('POST', `/api/browser/sessions/${sessionId}/upload`, { selector, filePaths, ...(nthMatch !== undefined && { nthMatch }), ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) }, LONG_TIMEOUT);
 }
 
 // ── Observation ──
@@ -338,7 +366,7 @@ export async function waitFor(
   opts: { selector?: string; state?: string; loadState?: string; timeout?: number },
   tabId?: string
 ): Promise<NiResponse> {
-  return request('POST', `/api/browser/sessions/${sessionId}/wait`, { ...opts, ...(tabId && { tabId }) }, LONG_TIMEOUT);
+  return request('POST', `/api/browser/sessions/${sessionId}/wait`, { ...opts, ...(isBrowserCompactMode() && { compact: true }), ...(tabId && { tabId }) }, LONG_TIMEOUT);
 }
 
 // ── Whiteboard ──

package/mcp-server/src/services/profiles.ts

@@ -14,6 +14,7 @@ const ALL_BROWSER_GROUPS = ['browser', 'browser_twitter', 'browser_facebook', 'b
 export const PROFILE_PRESETS: Record<string, string[]> = {
   core:       ['git', 'image'],
   standard:   ['git', 'image', 'whiteboard', 'card', 'tictactoe'],
+  'codex-browser': ['git', 'image', 'browser', 'browser_twitter'],
   twitter:    ['git', 'image', 'browser', 'browser_twitter'],
   facebook:   ['git', 'image', 'browser', 'browser_facebook'],
   tiktok:     ['git', 'image', 'browser', 'browser_tiktok'],
@@ -116,21 +117,21 @@ export function applyProfile(profileName: string): { profile: string; enabled: s
     if (!shouldEnable && _activeGroups.has(group)) disabled.push(group);
   }
 
+  const prevProfileName = _activeProfileName;
   _activeGroups = newGroups;
   _activeProfileName = profileName.toLowerCase().trim();
 
   // Count enabled tools (core + enabled groups)
-  let totalTools = 10; // core memory tools + profile tool
-  for (const [, tools] of _toolGroups) {
-    if (_activeGroups.has([..._toolGroups].find(([, t]) => t === tools)?.[0] ?? '')) totalTools += tools.length;
-  }
-  // Simpler recount
-  totalTools = 10;
+  let totalTools = 10;
   for (const [group, tools] of _toolGroups) {
     if (_activeGroups.has(group)) totalTools += tools.length;
   }
 
-  console.error(`[SynaBun] Profile switched to "${_activeProfileName}" (${_activeGroups.size} groups, ${totalTools} tools, +${enabled.join(',') || 'none'}, -${disabled.join(',') || 'none'})`);
+  // Only log on an actual change — HTTP MCP creates a fresh server per request,
+  // which would otherwise spam this line twice per request forever.
+  if (prevProfileName !== _activeProfileName || enabled.length > 0 || disabled.length > 0) {
+    console.error(`[SynaBun] Profile switched to "${_activeProfileName}" (${_activeGroups.size} groups, ${totalTools} tools, +${enabled.join(',') || 'none'}, -${disabled.join(',') || 'none'})`);
+  }
   return { profile: _activeProfileName, enabled, disabled, totalTools };
 }
 

package/mcp-server/src/tools/browser-advanced.ts

@@ -71,16 +71,18 @@ export async function handleBrowserWait(args: {
     loadState: args.loadState,
     timeout: args.timeout,
   }, resolved.tabId);
-  if (result.error) return text(`Wait failed: ${result.error}`);
-
-  if (args.loadState) {
-    return text(`Page reached "${args.loadState}" — now at ${result.url} "${result.title}"`);
-  }
-  if (args.selector) {
-    return text(`"${args.selector}" is now ${result.state}`);
-  }
-  return text(`Waited ${args.timeout || 1000}ms — now at ${result.url} "${result.title}"`);
-}
+  if (result.error) return text(`Wait failed: ${result.error}`);
+
+  if (args.loadState) {
+    if (ni.isBrowserCompactMode()) return text(`Page reached "${args.loadState}"`);
+    return text(`Page reached "${args.loadState}" — now at ${result.url} "${result.title}"`);
+  }
+  if (args.selector) {
+    return text(`"${args.selector}" is now ${result.state}`);
+  }
+  if (ni.isBrowserCompactMode()) return text(`Waited ${args.timeout || 1000}ms`);
+  return text(`Waited ${args.timeout || 1000}ms — now at ${result.url} "${result.title}"`);
+}
 
 // ── browser_session ──