synabun 1.3.0 → 2.0.0

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

@@ -10,15 +10,11 @@ import { z } from 'zod';
 import * as ni from '../services/neural-interface.js';
 import { text } from './response.js';
 
-const LEO_BASE = 'https://app.leonardo.ai';
+const tabIdField = z.string().optional().describe('Target a specific tab within the session. Auto-resolved from environment if omitted.');
 
-// ── Helper: resolve or create session ─────────────────────────
+const LEO_BASE = 'https://app.leonardo.ai';
 
-async function getSession(): Promise<string | null> {
-  const resolved = await ni.resolveSession(undefined, { url: LEO_BASE });
-  if ('error' in resolved) return null;
-  return resolved.sessionId;
-}
+// ── Helper ────────────────────────────────────────────────────
 
 async function wait(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
@@ -31,14 +27,16 @@ export const browserNavigateSchema = {
     'home', 'library', 'image', 'video', 'upscaler',
     'blueprints', 'flow-state', 'models',
   ] as const).describe('Leonardo.ai page to navigate to.'),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
 };
 
 export const browserNavigateDescription =
   'Navigate the browser to a specific Leonardo.ai page. Always use this as the first step before any browser-based generation.';
 
-export async function handleBrowserNavigate(args: { page: string }) {
-  const sessionId = await getSession();
-  if (!sessionId) return text('No browser session available. Open Leonardo.ai in the browser first using browser_navigate or the Apps menu.');
+export async function handleBrowserNavigate(args: { page: string; sessionId?: string; tabId?: string }) {
+  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
+  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai in the browser first using browser_navigate or the Apps menu.');
 
   const paths: Record<string, string> = {
     'home': '/',
@@ -52,7 +50,7 @@ export async function handleBrowserNavigate(args: { page: string }) {
   };
 
   const path = paths[args.page] || '/';
-  const res = await ni.navigate(sessionId, `${LEO_BASE}${path}`);
+  const res = await ni.navigate(resolved.sessionId, `${LEO_BASE}${path}`, resolved.tabId);
   if (res.error) return text(`Navigation failed: ${res.error}`);
 
   // Wait for page to settle
@@ -66,6 +64,8 @@ export async function handleBrowserNavigate(args: { page: string }) {
 export const browserGenerateSchema = {
   prompt: z.string().describe('The generation prompt to type into Leonardo.ai.'),
   type: z.enum(['image', 'video'] as const).optional().describe('Generation type. Default: image.'),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
 };
 
 export const browserGenerateDescription =
@@ -74,31 +74,33 @@ export const browserGenerateDescription =
 export async function handleBrowserGenerate(args: {
   prompt: string;
   type?: string;
+  sessionId?: string;
+  tabId?: string;
 }) {
-  const sessionId = await getSession();
-  if (!sessionId) return text('No browser session available. Open Leonardo.ai first.');
+  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
+  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai first.');
 
   const genType = args.type || 'image';
 
   // Check current URL — navigate only if not already on the right page
-  const snapshot = await ni.snapshot(sessionId);
+  const snapshot = await ni.snapshot(resolved.sessionId, resolved.tabId);
   const currentUrl = (snapshot as any)?.url || '';
   const targetPath = genType === 'video' ? '/image-generation/video' : '/image-generation';
 
   if (!currentUrl.includes(targetPath)) {
-    const navRes = await ni.navigate(sessionId, `${LEO_BASE}${targetPath}`);
+    const navRes = await ni.navigate(resolved.sessionId, `${LEO_BASE}${targetPath}`, resolved.tabId);
     if (navRes.error) return text(`Navigation failed: ${navRes.error}`);
     await wait(3000);
   }
 
   // Clear and fill the prompt textbox
-  const fillRes = await ni.fill(sessionId, '[aria-label="Prompt"], textbox[name="Prompt"], textarea', args.prompt);
+  const fillRes = await ni.fill(resolved.sessionId, '[aria-label="Prompt"], textbox[name="Prompt"], textarea', args.prompt, undefined, resolved.tabId);
   if (fillRes.error) return text(`Failed to fill prompt: ${fillRes.error}`);
 
   await wait(500);
 
   // Click the Generate button
-  const clickRes = await ni.click(sessionId, 'button[aria-label="Generate"], button:has-text("Generate")');
+  const clickRes = await ni.click(resolved.sessionId, 'button[aria-label="Generate"], button:has-text("Generate")', undefined, resolved.tabId);
   if (clickRes.error) return text(`Failed to click Generate: ${clickRes.error}`);
 
   return text(`Generation started (${genType}).\n\nPrompt: "${args.prompt.substring(0, 120)}${args.prompt.length > 120 ? '...' : ''}"\n\nThe generation is processing in Leonardo.ai. Use browser_snapshot or browser_screenshot to check progress and see results. Results also appear in the library.`);
@@ -109,24 +111,26 @@ export async function handleBrowserGenerate(args: {
 export const browserLibrarySchema = {
   action: z.enum(['view', 'search'] as const).describe('Action: view (open library) or search (search for a term).'),
   query: z.string().optional().describe('Search query (for search action).'),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
 };
 
 export const browserLibraryDescription =
   'Open or search Leonardo.ai\'s library to view past generations. Use browser_snapshot after to see results.';
 
-export async function handleBrowserLibrary(args: { action: string; query?: string }) {
-  const sessionId = await getSession();
-  if (!sessionId) return text('No browser session available.');
+export async function handleBrowserLibrary(args: { action: string; query?: string; sessionId?: string; tabId?: string }) {
+  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
+  if ('error' in resolved) return text('No browser session available.');
 
-  const navRes = await ni.navigate(sessionId, `${LEO_BASE}/library`);
+  const navRes = await ni.navigate(resolved.sessionId, `${LEO_BASE}/library`, resolved.tabId);
   if (navRes.error) return text(`Navigation failed: ${navRes.error}`);
 
   await wait(2000);
 
   if (args.action === 'search' && args.query) {
-    const fillRes = await ni.fill(sessionId, 'input[placeholder*="Search" i]', args.query);
+    const fillRes = await ni.fill(resolved.sessionId, 'input[placeholder*="Search" i]', args.query, undefined, resolved.tabId);
     if (fillRes.error) return text(`Failed to search: ${fillRes.error}`);
-    await ni.pressKey(sessionId, 'Enter');
+    await ni.pressKey(resolved.sessionId, 'Enter', resolved.tabId);
     return text(`Searched Leonardo.ai library for: "${args.query}". Use browser_snapshot to see results.`);
   }
 
@@ -137,17 +141,19 @@ export async function handleBrowserLibrary(args: { action: string; query?: strin
 
 export const browserDownloadSchema = {
   action: z.enum(['screenshot'] as const).describe('Action: screenshot (capture current Leonardo.ai page state).'),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
 };
 
 export const browserDownloadDescription =
   'Capture a screenshot of the current Leonardo.ai page. Use to verify generation results or UI state.';
 
-export async function handleBrowserDownload(args: { action: string }) {
-  const sessionId = await getSession();
-  if (!sessionId) return text('No browser session available.');
+export async function handleBrowserDownload(args: { action: string; sessionId?: string; tabId?: string }) {
+  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
+  if ('error' in resolved) return text('No browser session available.');
 
   if (args.action === 'screenshot') {
-    const res = await ni.screenshot(sessionId);
+    const res = await ni.screenshot(resolved.sessionId, resolved.tabId);
     if (res.error) return text(`Screenshot failed: ${res.error}`);
     return text('Screenshot captured of the current Leonardo.ai page.');
   }
@@ -171,6 +177,8 @@ export const browserReferenceSchema = {
   autoClear: z.boolean().optional().describe(
     'Auto-delete the source images from data/images/ after successful upload. Default: true.',
   ),
+  sessionId: z.string().optional().describe('Browser session ID. If omitted, auto-selects the only open session.'),
+  tabId: tabIdField,
 };
 
 export const browserReferenceDescription =
@@ -183,9 +191,11 @@ export async function handleBrowserReference(args: {
   type: string;
   filePaths: string[];
   autoClear?: boolean;
+  sessionId?: string;
+  tabId?: string;
 }) {
-  const sessionId = await getSession();
-  if (!sessionId) return text('No browser session available. Open Leonardo.ai first.');
+  const resolved = await ni.resolveSession(args.sessionId, { url: LEO_BASE }, args.tabId, { platform: true });
+  if ('error' in resolved) return text('No browser session available. Open Leonardo.ai first.');
 
   const { type, filePaths, autoClear = true } = args;
   const isVideo = type === 'start_frame' || type === 'end_frame';
@@ -195,7 +205,7 @@ export async function handleBrowserReference(args: {
 
   if (isVideo) {
     // Video: click "Add Image Guidance to generation" button
-    openResult = await ni.evaluate(sessionId, `(() => {
+    openResult = await ni.evaluate(resolved.sessionId, `(() => {
       const btns = document.querySelectorAll('button');
       for (const b of btns) {
         if (b.textContent.includes('Image Guidance') || b.textContent.includes('Add Image')) {
@@ -203,10 +213,10 @@ export async function handleBrowserReference(args: {
         }
       }
       return 'not found';
-    })()`);
+    })()`, resolved.tabId);
   } else {
     // Image: click "Add elements" button
-    openResult = await ni.evaluate(sessionId, `(() => {
+    openResult = await ni.evaluate(resolved.sessionId, `(() => {
       const btns = document.querySelectorAll('button');
       for (const b of btns) {
         if (b.textContent.includes('Add elements') || b.textContent.includes('Add Elements')) {
@@ -214,7 +224,7 @@ export async function handleBrowserReference(args: {
         }
       }
       return 'not found';
-    })()`);
+    })()`, resolved.tabId);
   }
 
   if (openResult.error) return text(`Failed to open reference panel: ${openResult.error}`);
@@ -233,23 +243,23 @@ export async function handleBrowserReference(args: {
     const labels = typeLabels[type] || [type];
     const labelSearch = labels.map(l => `b.textContent.includes('${l}')`).join(' || ');
 
-    const selectResult = await ni.evaluate(sessionId, `(() => {
+    const selectResult = await ni.evaluate(resolved.sessionId, `(() => {
       const btns = document.querySelectorAll('button, [role="tab"], [role="menuitem"]');
       for (const b of btns) {
         if (${labelSearch}) { b.click(); return 'selected'; }
       }
       return 'not found — use browser_snapshot to see available options';
-    })()`);
+    })()`, resolved.tabId);
 
     if (selectResult.error) return text(`Failed to select reference type: ${selectResult.error}. Use browser_snapshot to see the panel.`);
     await wait(1000);
   }
 
   // Step 3: Find file input and upload
-  const uploadResult = await ni.upload(sessionId, 'input[type="file"]', filePaths);
+  const uploadResult = await ni.upload(resolved.sessionId, 'input[type="file"]', filePaths, undefined, resolved.tabId);
   if (uploadResult.error) {
     // Fallback: try broader selector
-    const fallback = await ni.upload(sessionId, 'input[accept*="image"]', filePaths);
+    const fallback = await ni.upload(resolved.sessionId, 'input[accept*="image"]', filePaths, undefined, resolved.tabId);
     if (fallback.error) {
       return text(
         `Failed to upload reference image(s): ${uploadResult.error}. ` +

package/mcp-server/src/tools/leonardo.ts

@@ -20,9 +20,11 @@ import {
  * Use the /leonardo skill for the full guided creation experience.
  */
 export function registerLeonardoTools(server: McpServer) {
-  server.tool('leonardo_browser_navigate', browserNavigateDescription, browserNavigateSchema, handleBrowserNavigate);
-  server.tool('leonardo_browser_generate', browserGenerateDescription, browserGenerateSchema, handleBrowserGenerate);
-  server.tool('leonardo_browser_library', browserLibraryDescription, browserLibrarySchema, handleBrowserLibrary);
-  server.tool('leonardo_browser_download', browserDownloadDescription, browserDownloadSchema, handleBrowserDownload);
-  server.tool('leonardo_browser_reference', browserReferenceDescription, browserReferenceSchema, handleBrowserReference);
+  return [
+    server.tool('leonardo_browser_navigate', browserNavigateDescription, browserNavigateSchema, handleBrowserNavigate),
+    server.tool('leonardo_browser_generate', browserGenerateDescription, browserGenerateSchema, handleBrowserGenerate),
+    server.tool('leonardo_browser_library', browserLibraryDescription, browserLibrarySchema, handleBrowserLibrary),
+    server.tool('leonardo_browser_download', browserDownloadDescription, browserDownloadSchema, handleBrowserDownload),
+    server.tool('leonardo_browser_reference', browserReferenceDescription, browserReferenceSchema, handleBrowserReference),
+  ];
 }

package/mcp-server/src/tools/loop.ts

@@ -1,16 +1,17 @@
 import { z } from 'zod';
 import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync, readdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { text } from './response.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const DATA_DIR = join(__dirname, '..', '..', 'data');
-// Loop state files and templates live in the project root data dir (Synabun/data/)
-const PROJECT_ROOT = process.env.SYNABUN_ROOT || join(__dirname, '..', '..', '..');
-const NI_DATA_DIR = join(PROJECT_ROOT, 'data');
+import { join } from 'path';
+import { text } from './response.js';
+import { getIdentity, effectivePins } from '../services/identity.js';
+import { config } from '../config.js';
+
+// Loop state files and templates live in DATA_HOME/data/
+const DATA_HOME = process.env.SYNABUN_DATA_HOME || process.env.SYNABUN_ROOT || config.dataHome;
+const NI_DATA_DIR = join(DATA_HOME, 'data');
 const LOOP_DIR = join(NI_DATA_DIR, 'loop');
-const LOOP_TEMPLATES_PATH = join(NI_DATA_DIR, 'loop-templates.json');
+const LOOP_TEMPLATES_FILE = 'loop-templates.json';
+const LOOP_TEMPLATES_PATH = join(NI_DATA_DIR, LOOP_TEMPLATES_FILE);
+const LOOP_TEMPLATES_PATTERN = /^loop-templates.*\.json$/;
 
 const MAX_ITERATIONS = 50;
 const DEFAULT_ITERATIONS = 10;
@@ -23,29 +24,58 @@ function ensureLoopDir() {
   }
 }
 
+const STALE_LOOP_MS = 45 * 60 * 1000;
+const ACTIVE_POINTER_PATH = join(LOOP_DIR, 'active-pointer.json');
+
+function isFreshActive(data: any): boolean {
+  if (!data?.active) return false;
+  const lastAct = new Date(data.lastIterationAt || data.startedAt || 0).getTime();
+  if (!lastAct) return true;
+  return Date.now() - lastAct <= STALE_LOOP_MS;
+}
+
 /**
  * Resolve the session ID for loop state file.
- * Priority: explicit param > CLAUDE_SESSION_ID env > SYNABUN_TERMINAL_SESSION env > scan.
+ * Priority:
+ *   1. explicit param
+ *   2. CLAUDE_SESSION_ID env (only if matching active flag exists)
+ *   3. SYNABUN_TERMINAL_SESSION env → terminalSessionId scan
+ *   4. active-pointer.json fallback (written by stop hook on claim)
+ *   5. legacy unclaimed loops without terminalSessionId
+ *   6. exactly-one-active fallback (single hook-driven loop)
  *
- * When SYNABUN_TERMINAL_SESSION is set (server-launched loop), find the loop file
- * by matching the terminalSessionId field. This survives /clear (which changes
- * CLAUDE_SESSION_ID) and prevents cross-loop contamination with multiple automations.
+ * Verifying flag existence before trusting CLAUDE_SESSION_ID is what fixes the
+ * "No active loop" regression after /clear renamed the flag file but the env
+ * var still pointed to the pre-clear session ID.
  */
 function resolveSessionId(explicit?: string): string | null {
   if (explicit) return explicit;
-  if (process.env.CLAUDE_SESSION_ID) return process.env.CLAUDE_SESSION_ID;
 
   ensureLoopDir();
 
-  // Priority: find loop file owned by this terminal session (survives /clear)
-  const terminalSessionEnv = process.env.SYNABUN_TERMINAL_SESSION;
+  const claudeSessionEnv = process.env.CLAUDE_SESSION_ID;
+  if (claudeSessionEnv) {
+    const path = getLoopPath(claudeSessionEnv);
+    if (existsSync(path)) {
+      try {
+        const data = JSON.parse(readFileSync(path, 'utf-8'));
+        if (isFreshActive(data)) return claudeSessionEnv;
+      } catch { /* fall through */ }
+    }
+  }
+
+  // Strategy A: terminalSessionId match (survives /clear). Over HTTP the loop's
+  // terminal id arrives via the X-Synabun-Terminal header (identity context);
+  // for stdio it's the inherited env var — effectivePins covers both.
+  const terminalSessionEnv = effectivePins(getIdentity()).terminalSessionId
+    || process.env.SYNABUN_TERMINAL_SESSION;
   if (terminalSessionEnv) {
     try {
-      const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-'));
+      const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-') && f !== 'active-pointer.json');
       for (const file of files) {
         try {
           const data = JSON.parse(readFileSync(join(LOOP_DIR, file), 'utf-8'));
-          if (data?.active && data.terminalSessionId === terminalSessionEnv) {
+          if (isFreshActive(data) && data.terminalSessionId === terminalSessionEnv) {
             return file.replace('.json', '');
           }
         } catch { /* skip corrupt files */ }
@@ -53,17 +83,42 @@ function resolveSessionId(explicit?: string): string | null {
     } catch { /* dir read failed */ }
   }
 
-  // Fallback: scan for any active loop file (legacy — no terminal scoping)
+  // Strategy A3: active-pointer.json (written by stop hook on flag claim)
+  if (existsSync(ACTIVE_POINTER_PATH)) {
+    try {
+      const ptr = JSON.parse(readFileSync(ACTIVE_POINTER_PATH, 'utf-8'));
+      const candidatePath = getLoopPath(ptr.sessionId);
+      if (ptr.sessionId && existsSync(candidatePath)) {
+        const data = JSON.parse(readFileSync(candidatePath, 'utf-8'));
+        if (isFreshActive(data)) return ptr.sessionId;
+      }
+    } catch { /* ignore corrupt pointer */ }
+  }
+
+  // Strategy B: legacy unclaimed loops without terminalSessionId
   try {
-    const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json'));
+    const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-') && f !== 'active-pointer.json');
     for (const file of files) {
       try {
         const data = JSON.parse(readFileSync(join(LOOP_DIR, file), 'utf-8'));
-        if (data?.active) return file.replace('.json', '');
+        if (isFreshActive(data) && !data.terminalSessionId) return file.replace('.json', '');
       } catch { /* skip corrupt files */ }
     }
   } catch { /* dir read failed */ }
 
+  // Strategy A2: exactly-one-fresh-active fallback
+  try {
+    const files = readdirSync(LOOP_DIR).filter(f => f.endsWith('.json') && !f.startsWith('pending-') && f !== 'active-pointer.json');
+    const matches: string[] = [];
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(LOOP_DIR, file), 'utf-8'));
+        if (isFreshActive(data)) matches.push(file.replace('.json', ''));
+      } catch { /* skip corrupt files */ }
+    }
+    if (matches.length === 1) return matches[0];
+  } catch { /* dir read failed */ }
+
   return null;
 }
 
@@ -114,11 +169,49 @@ export const loopDescription =
 
 // ── Start ──────────────────────────────────────────────────────
 
+function sortLoopTemplateFiles(a: string, b: string): number {
+  if (a === LOOP_TEMPLATES_FILE) return -1;
+  if (b === LOOP_TEMPLATES_FILE) return 1;
+  return a.localeCompare(b);
+}
+
+function listLoopTemplatePaths(): string[] {
+  try {
+    if (!existsSync(NI_DATA_DIR)) return existsSync(LOOP_TEMPLATES_PATH) ? [LOOP_TEMPLATES_PATH] : [];
+    return readdirSync(NI_DATA_DIR)
+      .filter(file => LOOP_TEMPLATES_PATTERN.test(file))
+      .sort(sortLoopTemplateFiles)
+      .map(file => join(NI_DATA_DIR, file));
+  } catch {
+    return existsSync(LOOP_TEMPLATES_PATH) ? [LOOP_TEMPLATES_PATH] : [];
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readLoopTemplates(): Record<string, unknown>[] {
+  const byId = new Map<string, Record<string, unknown>>();
+  const withoutId: Record<string, unknown>[] = [];
+  for (const path of listLoopTemplatePaths()) {
+    try {
+      const data = JSON.parse(readFileSync(path, 'utf-8'));
+      const list = Array.isArray(data) ? data : (isRecord(data) && Array.isArray(data.templates) ? data.templates : []);
+      for (const item of list) {
+        if (!isRecord(item)) continue;
+        const id = typeof item.id === 'string' ? item.id : '';
+        if (id) byId.set(id, item);
+        else withoutId.push(item);
+      }
+    } catch { /* skip corrupt template files */ }
+  }
+  return [...byId.values(), ...withoutId];
+}
+
 function loadTemplate(nameOrId: string): Record<string, unknown> | null {
   try {
-    if (!existsSync(LOOP_TEMPLATES_PATH)) return null;
-    const templates = JSON.parse(readFileSync(LOOP_TEMPLATES_PATH, 'utf-8'));
-    if (!Array.isArray(templates)) return null;
+    const templates = readLoopTemplates();
     const lower = nameOrId.toLowerCase();
     return templates.find((t: Record<string, unknown>) =>
       (t.id as string) === nameOrId ||

package/mcp-server/src/tools/memories.ts

@@ -1,16 +1,32 @@
 import { z } from 'zod';
-import { scrollMemories, getMemoryStats } from '../services/sqlite.js';
+import { scrollMemories, getMemoryStats, getMemory, rowToSessionChunkPayload } from '../services/sqlite.js';
 import { validateCategory } from '../services/categories.js';
 import type { MemoryPayload } from '../types.js';
 import { text } from './response.js';
+import { getDb } from '../services/sqlite.js';
+import { memoryRevision, memoryHistory, undoRevision, maintenanceStatus, pauseMaintenance, feedback, projectContext } from '../services/memory-maintenance.js';
+import { triageMemories } from '../services/memory-triage.js';
+
+function coerceIds() { return z.array(z.string().uuid()).max(50).optional().describe('UUIDs for get-batch; maximum 50.'); }
 
 export function buildMemoriesSchema() {
   return {
     action: z
-      .enum(['recent', 'stats', 'by-category', 'by-project'] as const)
+      .enum(['recent', 'stats', 'by-category', 'by-project', 'get', 'get-batch', 'history', 'undo', 'maintenance', 'feedback', 'context', 'triage'] as const)
       .describe(
-        'recent=latest memories, stats=counts and health, by-category=filter by type, by-project=filter by project.'
+        'recent=latest memories, stats=counts and health, by-category=filter by type, by-project=filter by project, get=FULL untruncated content of one memory by id (no vector search), triage=forget candidates (duplicates, old never-recalled notes) ranked by how little they would be missed — nothing is deleted.'
       ),
+    token_budget: z.coerce.number().int().min(100).max(16000).optional().describe('Estimated token budget for context; default 1500.'),
+    ids: coerceIds(),
+    revision: z.coerce.number().int().min(1).optional().describe('Revision to restore for undo.'),
+    expected_revision: z.coerce.number().int().min(1).optional().describe('Required current revision for undo.'),
+    operation: z.enum(['status','pause','resume','retry','undo-relation']).optional().describe('Maintenance operation; default status.'),
+    relation_id: z.string().uuid().optional().describe('Relationship to undo.'),
+    feedback: z.enum(['useful','irrelevant','incorrect']).optional().describe('Feedback signal; never treated as proof of correctness.'),
+    id: z
+      .string()
+      .optional()
+      .describe('Memory id (required for action "get"). Returns that memory\'s full content untruncated — use to fetch a consolidated/large memory directly.'),
     category: z
       .string()
       .optional()
@@ -31,7 +47,7 @@ export function buildMemoriesSchema() {
 export const memoriesSchema = buildMemoriesSchema();
 
 export const memoriesDescription =
-  'Browse recent memories or get statistics. Use this to see what you remember about a project, review recent learnings, or check memory health.';
+  'Browse recent memories, get statistics, or fetch one memory in FULL by id. Use action "get" with an id to pull a large/consolidated memory untruncated (list actions truncate content to 150 chars). Use to see what you remember about a project, review recent learnings, or check memory health.';
 
 function formatAge(isoDate: string): string {
   const diffMs = Date.now() - new Date(isoDate).getTime();
@@ -45,7 +61,9 @@ function formatAge(isoDate: string): string {
 }
 
 export async function handleMemories(args: {
-  action: string;
+  action: string; ids?: string[]; revision?: number; expected_revision?: number;
+  operation?: string; relation_id?: string; feedback?: string; token_budget?: number;
+  id?: string;
   category?: string;
   project?: string;
   limit?: number;
@@ -55,6 +73,48 @@ export async function handleMemories(args: {
   const project = args.project;
   const limit = args.limit ?? 10;
 
+  try {
+    if (action === 'context') return text(projectContext(args.project || '',args.token_budget ?? 1500));
+    if (action === 'triage') {
+      const result = await triageMemories({ project: args.project, limit, origin: 'tool' });
+      if (!result.rows.length) return text(`No forget candidates found${args.project ? ` for "${args.project}"` : ''}.`);
+      const lines = result.rows.map((r, i) => `${i + 1}. [${r.id}] ${r.category} | ${r.project} | imp:${r.importance} | recalled ${r.access_count}× | ${formatAge(r.created_at)}` +
+        `${r.expendability !== null ? ` | expendability ${r.expendability.toFixed(1)} (${r.level})` : ''}\n   why: ${r.reasons.join('; ')}\n   ${r.preview}${r.preview.length >= 240 ? '…' : ''}`);
+      const unjudged = result.judged ? result.rows.filter(r => r.expendability === null).length : 0;
+      return text(`Forget candidates (${result.rows.length} of ${result.candidates} found${result.judged ? ', ranked by judged expendability' : ', fallback ordering — judgment unavailable'}${unjudged ? `; ${unjudged} could not be judged this time (listed after the judged ones)` : ''}). Nothing was deleted; use \`forget\` on the ids you agree with.\n\n${lines.join('\n\n')}`);
+    }
+    if (action === 'get-batch') {
+      if (!args.ids?.length) return text('get-batch requires ids.');
+      const rows = [];
+      for (const id of args.ids) { const m = await getMemory(id); const session = !m && getDb().prepare('SELECT * FROM session_chunks WHERE id=?').get(id); rows.push(m ? {...m,revision:memoryRevision(id)} : session ? {id,type:'session',payload:rowToSessionChunkPayload(session)} : {id,error:'not found'}); }
+      return text(JSON.stringify(rows));
+    }
+    if (action === 'history') return text(JSON.stringify(memoryHistory(args.id || '',limit)));
+    if (action === 'undo') {
+      if (!args.id || !args.revision || !args.expected_revision) return text('undo requires id, revision, and expected_revision.');
+      return text(`Restored [${args.id}] as revision ${undoRevision(args.id,args.revision,args.expected_revision)}.`);
+    }
+    if (action === 'feedback') { feedback(args.id || '',args.feedback || ''); return text('Feedback recorded.'); }
+    if (action === 'maintenance') {
+      if (args.operation === 'pause' || args.operation === 'resume') pauseMaintenance(args.operation === 'pause');
+      if (args.operation === 'retry') getDb().exec("UPDATE memory_jobs SET status='pending',attempts=0,error=NULL WHERE status='failed'");
+      if (args.operation === 'undo-relation') getDb().prepare('UPDATE memory_relations SET active=0 WHERE id=?').run(args.relation_id || '');
+      return text(JSON.stringify(maintenanceStatus()));
+    }
+  } catch (error) { return { ...text((error as Error).message), isError: true }; }
+  if (action === 'get') {
+    if (!args.id) return text('action "get" requires an "id".');
+    const mem = await getMemory(args.id);
+    if (!mem) {
+      const session=getDb().prepare('SELECT * FROM session_chunks WHERE id=?').get(args.id);
+      return session ? text(`[${args.id}] Session ${session.session_id} | ${session.project}\n\n${session.content}`) : text(`No memory found with id "${args.id}".`);
+    }
+    const p = mem.payload;
+    const tagStr = p.tags?.length ? ` [${p.tags.join(', ')}]` : '';
+    const sub = p.subcategory ? `/${p.subcategory}` : '';
+    return text(`[${mem.id}] ${p.category}${sub} | ${p.project} | imp:${p.importance}${tagStr} | revision:${memoryRevision(args.id)}\n\n${p.content}`);
+  }
+
   if (category) {
     const catCheck = validateCategory(category);
     if (!catCheck.valid) {

package/mcp-server/src/tools/morelogin.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import * as ni from '../services/neural-interface.js';
+import { text } from './response.js';
+
+// ═══════════════════════════════════════════
+// morelogin — MoreLogin anti-detect browser MCP tool
+// ═══════════════════════════════════════════
+
+export const moreloginSchema = {
+  action: z.enum(['status', 'list', 'create', 'start', 'stop', 'use_default']).describe(
+    'MoreLogin action. "status" = installed/running + current default. "list" = browser profiles (environments). "create" = new profile. "start"/"stop" = launch/close a profile. "use_default" = make a profile the default AI browser so every browser_* tool drives it.'
+  ),
+  envId: z.string().optional().describe(
+    'MoreLogin environment (profile) id — required for start, stop, and use_default. Get ids from the "list" action.'
+  ),
+  name: z.string().optional().describe(
+    'Name for a new profile ("create" action). Defaults to "SynaBun".'
+  ),
+};
+
+export const moreloginDescription =
+  'Manage MoreLogin (anti-detect, multi-account browser) profiles. Actions: "status" (is MoreLogin installed/running, which profile is the default AI browser), "list" (profiles), "create" (new profile), "start"/"stop" (launch/close a profile), "use_default" (set a profile as the default AI browser — afterwards all browser_* tools automatically drive that MoreLogin profile). Requires the MoreLogin desktop app to be running with its local API enabled.';
+
+interface MlEnv { id: string; name: string; status?: string }
+
+export async function handleMoreLogin(args: { action: string; envId?: string; name?: string }) {
+  switch (args.action) {
+    case 'status': {
+      const r = await ni.moreloginStatus();
+      if (r.error) return text(`MoreLogin unreachable: ${r.error}`);
+      if (!r.installed) return text('MoreLogin is not installed. Install it from https://www.morelogin.com.');
+      if (!r.running) return text(`MoreLogin is installed but its local API is not running on port ${r.port}. Open the MoreLogin app and enable Settings → API & MCP.`);
+      const def = r.isDefault && r.defaultEnvId ? `default AI browser = env ${r.defaultEnvId}` : 'no MoreLogin default set';
+      return text(`MoreLogin running on port ${r.port}. ${r.profileCount} profile(s). ${def}.`);
+    }
+    case 'list': {
+      const r = await ni.moreloginProfiles();
+      if (r.error) return text(`MoreLogin list failed: ${r.error}`);
+      const envs = (r.envs || []) as MlEnv[];
+      if (!envs.length) return text('No MoreLogin profiles found. Create one with action "create" (or one is auto-created on first use).');
+      return text('MoreLogin profiles:\n' + envs.map(e => `  • ${e.name} (id ${e.id})${e.status ? ` — ${e.status}` : ''}`).join('\n'));
+    }
+    case 'create': {
+      const r = await ni.moreloginCreate(args.name);
+      if (r.error) return text(`Create failed: ${r.error}`);
+      const ids = (r.ids || []) as string[];
+      return text(`Created MoreLogin profile${ids.length ? ` (id ${ids.join(', ')})` : ''}.`);
+    }
+    case 'start': {
+      if (!args.envId) return text('envId is required for the "start" action. Use "list" to get ids.');
+      const r = await ni.moreloginStart(args.envId);
+      if (r.error) return text(`Start failed: ${r.error}`);
+      return text(`Started MoreLogin env ${args.envId} (debug port ${r.debugPort}).`);
+    }
+    case 'stop': {
+      if (!args.envId) return text('envId is required for the "stop" action.');
+      const r = await ni.moreloginStop(args.envId);
+      if (r.error) return text(`Stop failed: ${r.error}`);
+      return text(`Stopped MoreLogin env ${args.envId}.`);
+    }
+    case 'use_default': {
+      if (!args.envId) return text('envId is required for the "use_default" action.');
+      const r = await ni.moreloginUseDefault(args.envId);
+      if (r.error) return text(`use_default failed: ${r.error}`);
+      return text(`MoreLogin env ${args.envId} is now the default AI browser — every browser_* tool will drive it.`);
+    }
+    default:
+      return text(`Unknown action: ${args.action}`);
+  }
+}
+
+/**
+ * Register the MoreLogin MCP tool on the given server instance.
+ * Single tool with action-based dispatch: status, list, create, start, stop, use_default.
+ */
+export function registerMoreLoginTools(server: McpServer) {
+  return [
+    server.tool('morelogin', moreloginDescription, moreloginSchema, handleMoreLogin),
+  ];
+}