sapper-iq 1.1.39 → 1.2.0

package/sapper.mjs

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import ollama from 'ollama';
 import fs from 'fs';
+import os from 'os';
 import { spawn } from 'child_process';
 import chalk from 'chalk';
 import ora from 'ora';
 import readline from 'readline';
 import { fileURLToPath } from 'url';
-import { dirname, join, isAbsolute, resolve as pathResolve } from 'path';
+import { dirname, join, isAbsolute, resolve as pathResolve, extname } from 'path';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { highlight as highlightCode } from 'cli-highlight';
@@ -15,6 +16,32 @@ import * as acorn from 'acorn';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+function safeCwd() {
+  try {
+    return process.cwd();
+  } catch (error) {
+    const pwdCandidate = process.env.PWD;
+    const homeCandidate = process.env.HOME;
+    const fallback = [pwdCandidate, homeCandidate, __dirname].find((value) => value && fs.existsSync(value));
+
+    if (fallback) {
+      try {
+        process.chdir(fallback);
+      } catch (chdirError) {
+        // Ignore and continue to final fallback return.
+      }
+    }
+
+    try {
+      return process.cwd();
+    } catch (cwdError) {
+      return __dirname;
+    }
+  }
+}
+
+const PROJECT_ROOT = safeCwd();
+
 // Prevent process from exiting on unhandled errors
 process.on('uncaughtException', (err) => {
   console.error(chalk.red('\n❌ Uncaught exception:'), err.message);
@@ -76,6 +103,7 @@ const spinner = ora();
 const SAPPER_DIR = '.sapper';
 const CONTEXT_FILE = `${SAPPER_DIR}/context.json`;
 const EMBEDDINGS_FILE = `${SAPPER_DIR}/embeddings.json`;
+const LONG_MEMORY_FILE = `${SAPPER_DIR}/long-memory.md`;
 const WORKSPACE_FILE = `${SAPPER_DIR}/workspace.json`;
 const CONFIG_FILE = `${SAPPER_DIR}/config.json`;
 const AGENTS_DIR = `${SAPPER_DIR}/agents`;
@@ -184,7 +212,7 @@ function appendLogToFile(entry) {
     if (!existed) {
       line += `# Sapper Session Log\n`;
       line += `**Started:** ${new Date(entry.timestamp).toLocaleString()}\n`;
-      line += `**Working Directory:** \`${process.cwd()}\`\n\n`;
+      line += `**Working Directory:** \`${safeCwd()}\`\n\n`;
       line += `---\n\n`;
     }
 
@@ -590,6 +618,12 @@ const TOOL_NAME_MAP = {
   'search': 'SEARCH',
   'grep': 'GREP',
   'find': 'FIND',
+  'regex': 'REGEX',
+  'regex_search': 'REGEX',
+  'rx': 'REGEX',
+  'chunk': 'READ_CHUNK',
+  'read_chunk': 'READ_CHUNK',
+  'read_range': 'READ_CHUNK',
   'shell': 'SHELL',
   'mkdir': 'MKDIR',
   'rmdir': 'RMDIR',
@@ -607,6 +641,12 @@ const TOOL_NAME_MAP = {
   'memory': 'MEMORY',
   'recall': 'MEMORY',
   'recall_memory': 'MEMORY',
+  'save_memory_note': 'MEMORY',
+  'search_memory_notes': 'MEMORY',
+  'read_memory_notes': 'MEMORY',
+  'memory_note_save': 'MEMORY',
+  'memory_note_search': 'MEMORY',
+  'memory_note_read': 'MEMORY',
   'open': 'OPEN',
   'browser': 'OPEN',
   'open_url': 'OPEN',
@@ -623,6 +663,8 @@ const TOOL_ALLOWED_BY = {
   SEARCH: ['SEARCH', 'GREP'],
   GREP: ['SEARCH', 'GREP'],
   FIND: ['FIND'],
+  REGEX: ['REGEX'],
+  READ_CHUNK: ['READ_CHUNK', 'READ', 'CAT', 'HEAD', 'TAIL'],
   WRITE: ['WRITE'],
   PATCH: ['PATCH'],
   MKDIR: ['MKDIR'],
@@ -981,28 +1023,137 @@ function buildSystemPrompt(agentContent = null, skillContents = []) {
   const promptConfig = getPromptConfig();
   const promptPrepend = promptConfig.prepend.trim();
   const promptAppend = promptConfig.append.trim();
-  const corePrompt = promptConfig.coreOverride.trim() || `You are Sapper, an intelligent AI assistant with access to the local filesystem and shell.
+  const corePrompt = promptConfig.coreOverride.trim() || getPromptTemplate('system.core', '', {
+    date: dateStr,
+    time: timeStr,
+  });
+  let prompt = promptPrepend
+    ? `${wrapPromptCustomizationBlock('CUSTOM PROMPT PREPEND', promptPrepend, false)}\n\n${corePrompt}`
+    : corePrompt;
+
+  if (_useNativeToolsFlag) {
+    prompt += `\n\n${getPromptTemplate('system.nativeTools')}`;
+  } else {
+    prompt += `\n\n${getPromptTemplate('system.legacyTools')}`;
+  }
+
+  prompt += `\n\n${getPromptTemplate('system.importantContext')}`;
+
+  if (chunkingEnabled()) {
+    const ctx = chunkingContextLines();
+    prompt += `\n\nCONTEXT-WINDOW STRATEGY (chunked reading is ON):\n` +
+      `- Do NOT load entire large files. The context window is limited and full-file reads waste it.\n` +
+      `- Two-step approach: (1) SEARCH with grep / regex_search to find the relevant lines, then (2) CHUNK with read_chunk(path, start, end) to pull just those lines plus ~${ctx} lines of surrounding context.\n` +
+      `- For files larger than ~${chunkingAutoAboveLines()} lines, always prefer read_chunk over read_file unless the user explicitly asks for the whole file.\n` +
+      `- regex_search already groups nearby hits into chunks (±${ctx} lines) — read those first before opening anything else.`;
+  }
+
+  if (agentContent) {
+    prompt += `\n\n${getPromptTemplate('system.activeAgentWrapper', '', { agentContent })}`;
+    
+    // If the active agent has tool restrictions, inform the AI
+    if (currentAgentTools && currentAgentTools.length > 0) {
+      const allTools = ['READ', 'WRITE', 'PATCH', 'LIST', 'SEARCH', 'SHELL', 'MKDIR'];
+      const forbidden = allTools.filter(t => !currentAgentTools.includes(t));
+      prompt += `\n\n${getPromptTemplate('system.agentRestriction', '', {
+        allowedTools: currentAgentTools.join(', '),
+        forbiddenTools: forbidden.join(', '),
+      })}`;
+    }
+  }
+
+  if (skillContents.length > 0) {
+    const skillBlock = skillContents.map(skill => `${skill}\n---`).join('\n');
+    prompt += `\n\n${getPromptTemplate('system.loadedSkillsWrapper', '', { skillBlock })}`;
+  }
+
+  if (promptAppend) {
+    prompt += wrapPromptCustomizationBlock('CUSTOM PROMPT APPEND', promptAppend);
+  }
+
+  return prompt;
+}
+
+// Track active agent
+let currentAgent = null; // null = default Sapper, or agent name string
+let currentAgentTools = null; // null = all tools allowed, or array of allowed tool names
+let loadedSkills = []; // array of skill names currently loaded
+
+const DEFAULT_CONFIG = Object.freeze({
+  defaultModel: null,
+  defaultAgent: null,
+  autoAttach: true,
+  debug: false,
+  contextLimit: null,
+  toolRoundLimit: 40,
+  patchRetries: 3,
+  maxFileSize: 100000,
+  maxScanSize: 1000000,
+  maxUrlSize: 200000,
+  summaryPhases: true,
+  summarizeTriggerPercent: 65,
+  shell: Object.freeze({
+    streamToModel: true,
+    backgroundMode: 'auto',
+    backgroundAfterSeconds: 8,
+    outputChunkChars: 4000,
+  }),
+  streaming: Object.freeze({
+    showPhaseStatus: true,
+    showHeartbeat: true,
+    idleNoticeSeconds: 4,
+  }),
+  thinking: Object.freeze({
+    mode: 'auto',
+  }),
+  ui: Object.freeze({
+    compactMode: 'auto',
+    style: 'sapper',
+  }),
+  chunking: Object.freeze({
+    enabled: true,           // Master toggle — agent prefers chunked reads/searches
+    contextLines: 20,        // Lines of context above & below each match
+    maxChunksPerFile: 5,     // Max chunk groups returned per file
+    autoChunkAboveLines: 400,// read_file warns + suggests chunking above this many lines
+  }),
+  voice: Object.freeze({
+    enabled: true,                                                      // Feature available (still triggered manually via /voice)
+    whisperBin: 'whisper-cli',                                          // whisper.cpp CLI binary on PATH
+    whisperStreamBin: 'whisper-stream',                                 // whisper.cpp streaming binary (live mode)
+    model: join(os.homedir(), 'models', 'ggml-medium.bin'),            // Path to a ggml-*.bin (whisper.cpp format) — use /v model to pick
+    language: 'auto',                                                   // 'auto' for detection, or 'en' / 'ar' / etc.
+    recorder: 'ffmpeg',                                                 // 'ffmpeg' or 'sox'
+    recordSeconds: 8,                                                   // Default mic-record duration
+    device: ':0',                                                       // ffmpeg avfoundation audio input (macOS: ':0' default mic)
+    sampleRate: 16000,                                                  // Whisper expects 16kHz mono
+    translate: false,                                                   // True = translate non-English speech to English
+    autoSend: false,                                                    // If true, transcript is sent to the AI immediately (no confirm prompt)
+    liveStepMs: 500,                                                    // Live mode: re-decode every N ms (lower = snappier, more CPU)
+    liveLengthMs: 5000,                                                 // Live mode: sliding window length in ms
+    liveKeepMs: 200,                                                    // Live mode: ms of audio to carry over between steps
+    archive: true,                                                      // Save every recording (audio + transcript) to disk
+    archiveDir: '.sapper/voice',                                        // Folder for archive (relative to cwd or absolute). A YYYY-MM-DD subfolder is auto-created.
+  }),
+  prompt: Object.freeze({
+    prepend: '',
+    append: '',
+    coreOverride: '',
+    system: Object.freeze({
+      core: `You are Sapper, an intelligent AI assistant with access to the local filesystem and shell.
 You can help with ANY task - coding, writing, research, planning, analysis, and more.
 Adapt your personality and expertise based on the active agent role and loaded skills.
 
-CURRENT DATE AND TIME: ${dateStr}, ${timeStr}
+CURRENT DATE AND TIME: {date}, {time}
 
 RULES:
 1. EXPLORE FIRST: Use list and read to understand files before making changes.
 2. THINK IN STEPS: Explain what you found and what you plan to do before acting.
 3. BE PRECISE: When using patch, ensure the 'old_text' matches exactly.
 4. VERIFY: After making changes, verify they work (run tests, check output, etc).
-5. NO HALLUCINATIONS: If a file doesn't exist, don't guess its content. List the directory instead.`;
-  let prompt = promptPrepend
-    ? `${wrapPromptCustomizationBlock('CUSTOM PROMPT PREPEND', promptPrepend, false)}\n\n${corePrompt}`
-    : corePrompt;
-
-  if (_useNativeToolsFlag) {
-    prompt += `
-
-TOOLS:
+5. NO HALLUCINATIONS: If a file doesn't exist, don't guess its content. List the directory instead.`,
+      nativeTools: `TOOLS:
 You have function-calling tools available. Call them directly — do NOT use [TOOL:...] text markers.
-Available tools: list_directory, read_file, search_files, write_file, patch_file, create_directory, ls, cat, head, tail, grep, find, pwd, cd, rmdir, changes, fetch_web, recall_memory, open_url, run_shell.
+Available tools: list_directory, read_file, search_files, write_file, patch_file, create_directory, ls, cat, head, tail, grep, find, regex_search, read_chunk, pwd, cd, rmdir, changes, fetch_web, recall_memory, save_memory_note, search_memory_notes, read_memory_notes, open_url, run_shell.
 
 PATCH TIPS:
 - For patch_file, set old_text to "LINE:<number>" to replace a specific line by number (most reliable).
@@ -1013,21 +1164,23 @@ EXTRA TOOL TIPS:
 - ls lists directory contents using the current tool working directory when path is omitted.
 - cat reads a full file, while head and tail read the first or last N lines.
 - grep searches file contents, and find searches file or directory names.
+- regex_search runs advanced JS-regex search across source code with capture groups; supports /pattern/flags syntax and an optional include filter (e.g. "js,ts" or "src/").
+- read_chunk reads a specific line range from a file (e.g. lines 40-80). Prefer this over read_file for large files — search first with grep/regex_search, then read_chunk the surrounding window instead of the whole file. This keeps the context window small and responses fast.
 - pwd shows the current tool working directory, and cd changes it for later tool calls.
 - rmdir removes a directory recursively and always asks for approval.
 - changes shows git status and diff output for the current repository or an optional path.
 - fetch_web fetches a web page and returns readable text content.
 - recall_memory searches Sapper's saved conversation memory.
+- save_memory_note appends a durable markdown note for recurring patterns, decisions, or fixes.
+- search_memory_notes searches markdown long-memory notes in .sapper/long-memory.md.
+- read_memory_notes reads the full markdown long-memory file.
 - open_url opens a URL in the default browser and always asks for approval.
 
 SHELL TIPS:
 - run_shell may keep long-running commands in a background session depending on config.
 - If a shell result returns a session id, inspect more output with run_shell command "__shell_read__ <session_id>".
-- Use run_shell command "__shell_list__" to list sessions and "__shell_stop__ <session_id>" to stop one.`;
-  } else {
-    prompt += `
-
-TOOL SYNTAX (use these to interact with files and system):
+- Use run_shell command "__shell_list__" to list sessions and "__shell_stop__ <session_id>" to stop one.`,
+      legacyTools: `TOOL SYNTAX (use these to interact with files and system):
 - [TOOL:LIST]dir[/TOOL] - List directory contents
 - [TOOL:LS]dir[/TOOL] - Alias for LIST
 - [TOOL:READ]file_path[/TOOL] - Read file contents
@@ -1037,6 +1190,10 @@ TOOL SYNTAX (use these to interact with files and system):
 - [TOOL:SEARCH]pattern[/TOOL] - Search files for pattern
 - [TOOL:GREP]pattern[/TOOL] - Alias for SEARCH
 - [TOOL:FIND]name_or_fragment[/TOOL] - Find files and directories by name
+- [TOOL:REGEX]/pattern/flags[/TOOL] - Advanced regex search across source code (returns file:line:col + capture groups)
+- [TOOL:REGEX]/pattern/flags:::js,ts[/TOOL] - Same, restricted to file extensions or path substrings
+- [TOOL:CHUNK]path:::40-80[/TOOL] - Read a specific line range from a file (preferred over READ for big files)
+- [TOOL:CHUNK]path:::40-80:::10[/TOOL] - Same with 10 extra context lines above & below the range
 - [TOOL:WRITE]path:::content[/TOOL] - Create/overwrite file
 - [TOOL:PATCH]path:::old|||new[/TOOL] - Edit existing file (exact match, trimmed, or fuzzy)
 - [TOOL:PATCH]path:::LINE:number|||new text[/TOOL] - Replace a specific line by number (PREFERRED — more reliable)
@@ -1046,6 +1203,9 @@ TOOL SYNTAX (use these to interact with files and system):
 - [TOOL:CHANGES]path[/TOOL] - Show git status and diffs for the repository or a path
 - [TOOL:FETCH]https://example.com[/TOOL] - Fetch a web page and return readable content
 - [TOOL:MEMORY]query[/TOOL] - Search saved conversation memory
+- [TOOL:MEMORY_NOTE_SAVE]title:::note:::tag1,tag2[/TOOL] - Save a durable markdown note
+- [TOOL:MEMORY_NOTE_SEARCH]query[/TOOL] - Search markdown long memory notes
+- [TOOL:MEMORY_NOTE_READ][/TOOL] - Read markdown long memory file
 - [TOOL:OPEN]https://example.com[/TOOL] - Open a URL in the default browser (asks for approval)
 - [TOOL:SHELL]command[/TOOL] - Run shell command
 
@@ -1060,86 +1220,94 @@ SHELL TIPS:
 - Use [TOOL:SHELL]__shell_list__[/TOOL] to list sessions and [TOOL:SHELL]__shell_stop__ <session_id>[/TOOL] to stop one.
 
 You MUST use the [TOOL:...][/TOOL] syntax above to perform actions. This is how you interact with the filesystem and shell - there is no other way. When you want to read a file, output [TOOL:READ]path[/TOOL] in your response. When you want to list a directory, output [TOOL:LIST].[/TOOL]. Always actually use the tools - do not just describe what you would do.
-Do NOT show tool syntax as examples or documentation to the user. Only use them to perform real actions.`;
-  }
-
-  prompt += `
-
-IMPORTANT CONTEXT:
+Do NOT show tool syntax as examples or documentation to the user. Only use them to perform real actions.`,
+      importantContext: `IMPORTANT CONTEXT:
 - The current working directory is the user's project folder.
 - Sapper has a built-in agent/skill system. Agents are managed via /agents, /agent create, /newagent commands - NOT by you creating files manually.
 - Do NOT try to build agent frameworks, projects, or directory structures when the user mentions agents. The agent system is already built into Sapper.
 - When the user asks you to do something, work within their current project directory.
 - Use "." for the current directory when listing, not "/" or "agent/".
 
-When no agent is active, you are a general-purpose assistant. When an agent role is loaded, fully adopt that role.`;
+When no agent is active, you are a general-purpose assistant. When an agent role is loaded, fully adopt that role.`,
+      activeAgentWrapper: `═══ ACTIVE AGENT ROLE ═══
+{agentContent}
+═══ END AGENT ROLE ═══
+
+IMPORTANT: You are now operating as the agent described above. Adopt its persona, expertise, and communication style while still having access to Sapper tools.`,
+      agentRestriction: `TOOL RESTRICTION: This agent can ONLY use these tools: {allowedTools}.
+FORBIDDEN TOOLS (DO NOT USE): {forbiddenTools}. You MUST NOT attempt to use forbidden tools. If you need a forbidden tool, tell the user you cannot perform that action with your current role.`,
+      loadedSkillsWrapper: `═══ LOADED SKILLS ═══
+{skillBlock}
+═══ END SKILLS ═══
+
+Use the knowledge from the loaded skills above when relevant to the user's request.`,
+    }),
+    ui: Object.freeze({
+      bannerTitle: 'Sapper',
+      bannerSubtitle: 'terminal coding workspace',
+      bannerTagline: 'Model selection, live tools, and focused sessions in one loop',
+      quickStartTitle: 'Quick Start',
+      quickStartSubtitle: '@file attach · /commands palette · /agents modes',
+      cleanFrontendHint: 'clean frontend active  ·  /ui style sapper to switch back',
+      ultraFrontendHint: 'ultra frontend active  /ui style sapper to switch back',
+      modelPickerUltraTitle: 'models',
+      modelPickerCleanTitle: 'model picker',
+      modelPickerTitle: 'Model selection',
+      modelPickerSectionTitle: 'Model',
+      modelPickerSubtitle: 'use ↑↓ or j/k, enter to confirm',
+      unknownCommandTitle: 'Unknown Command',
+      uiUsage: '  Usage: /ui style [sapper|clean|ultra]  |  /ui compact [auto|on|off]  |  /ui reset',
+      fetchStatus: 'Fetching {url}...',
+      webPageContentTitle: 'WEB PAGE CONTENT',
+      symbolSearchStatus: 'Searching for: "{query}"...',
+      memorySearchStatus: 'Searching memory for: "{query}"...',
+      scanStatus: 'Scanning codebase...',
+    }),
+    questions: Object.freeze({
+      resumeSession: 'Resume session',
+      removeDirectory: 'Remove directory',
+      openUrlInBrowser: 'Open URL in browser',
+      runShellCommand: 'Run shell command',
+      stopBackgroundShellSession: 'Stop background shell session {id}',
+      reviewChange: 'Review change [k]eep/[i]gnore/[d]iff/[f]eedback/[e]dit: ',
+      feedbackForSapper: 'Feedback for Sapper: ',
+      editInstructionForSapper: 'Edit instruction for Sapper: ',
+      addFirstMatchFileToContext: 'Add first match file to context? (y/n): ',
+      addFileAndRelatedToContext: 'Add this file + related to context? (y/n): ',
+      addMemoryToCurrentContext: 'Add to current context? (y/n): ',
+      agentName: '\nAgent name (lowercase, no spaces): ',
+      agentTitle: 'Agent title/role: ',
+      agentExpertise: 'Areas of expertise (comma-separated): ',
+      agentStyle: 'Communication style (e.g., professional, casual, technical): ',
+      agentTools: 'Allowed tools (comma-sep, or Enter for all): read,read_chunk,edit,write,list,ls,search,grep,find,regex,shell,mkdir,rmdir,pwd,cd,cat,head,tail,changes,fetch,memory,open: ',
+      skillName: '\nSkill name (lowercase, no spaces): ',
+      skillTitle: 'Skill title: ',
+      skillDescription: 'Brief description (for /skills listing): ',
+      skillArgumentHint: 'Argument hint (optional, e.g. "Describe what to do"): ',
+      skillKnowledge: 'Skill knowledge (or Enter for template): ',
+      promptForFiles: 'Your prompt for these files: ',
+      stepContinue: '[STEP] Press Enter to let AI think...',
+    }),
+  }),
+});
 
-  if (agentContent) {
-    prompt += `\n\n═══ ACTIVE AGENT ROLE ═══\n${agentContent}\n═══ END AGENT ROLE ═══\n\nIMPORTANT: You are now operating as the agent described above. Adopt its persona, expertise, and communication style while still having access to Sapper tools.`;
-    
-    // If the active agent has tool restrictions, inform the AI
-    if (currentAgentTools && currentAgentTools.length > 0) {
-      const allTools = ['READ', 'WRITE', 'PATCH', 'LIST', 'SEARCH', 'SHELL', 'MKDIR'];
-      const forbidden = allTools.filter(t => !currentAgentTools.includes(t));
-      prompt += `\n\nTOOL RESTRICTION: This agent can ONLY use these tools: ${currentAgentTools.join(', ')}.
-FORBIDDEN TOOLS (DO NOT USE): ${forbidden.join(', ')}. You MUST NOT attempt to use forbidden tools. If you need a forbidden tool, tell the user you cannot perform that action with your current role.`;
-    }
+function normalizePromptTree(inputValue, defaultValue) {
+  if (typeof defaultValue === 'string') {
+    return normalizePromptText(inputValue === undefined ? defaultValue : inputValue);
   }
 
-  if (skillContents.length > 0) {
-    prompt += `\n\n═══ LOADED SKILLS ═══`;
-    for (const skill of skillContents) {
-      prompt += `\n${skill}\n---`;
-    }
-    prompt += `\n═══ END SKILLS ═══\n\nUse the knowledge from the loaded skills above when relevant to the user's request.`;
+  if (!defaultValue || typeof defaultValue !== 'object' || Array.isArray(defaultValue)) {
+    return inputValue === undefined ? defaultValue : inputValue;
   }
 
-  if (promptAppend) {
-    prompt += wrapPromptCustomizationBlock('CUSTOM PROMPT APPEND', promptAppend);
+  const source = inputValue && typeof inputValue === 'object' && !Array.isArray(inputValue) ? inputValue : {};
+  const output = {};
+  for (const [key, nestedDefault] of Object.entries(defaultValue)) {
+    output[key] = normalizePromptTree(source[key], nestedDefault);
   }
-
-  return prompt;
+  return output;
 }
 
-// Track active agent
-let currentAgent = null; // null = default Sapper, or agent name string
-let currentAgentTools = null; // null = all tools allowed, or array of allowed tool names
-let loadedSkills = []; // array of skill names currently loaded
-
-const DEFAULT_CONFIG = Object.freeze({
-  defaultModel: null,
-  defaultAgent: null,
-  autoAttach: true,
-  debug: false,
-  contextLimit: null,
-  toolRoundLimit: 40,
-  patchRetries: 3,
-  maxFileSize: 100000,
-  maxScanSize: 1000000,
-  maxUrlSize: 200000,
-  summaryPhases: true,
-  summarizeTriggerPercent: 65,
-  shell: Object.freeze({
-    streamToModel: true,
-    backgroundMode: 'auto',
-    backgroundAfterSeconds: 8,
-    outputChunkChars: 4000,
-  }),
-  streaming: Object.freeze({
-    showPhaseStatus: true,
-    showHeartbeat: true,
-    idleNoticeSeconds: 4,
-  }),
-  thinking: Object.freeze({
-    mode: 'auto',
-  }),
-  prompt: Object.freeze({
-    prepend: '',
-    append: '',
-    coreOverride: '',
-  }),
-});
-
 function normalizeBoolean(value, fallback) {
   if (typeof value === 'boolean') return value;
   if (typeof value === 'string') {
@@ -1242,6 +1410,101 @@ function normalizeStreamingConfig(streamingConfig = {}) {
   };
 }
 
+function normalizeUICompactMode(value) {
+  if (typeof value === 'boolean') return value ? 'on' : 'off';
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (['on', 'true', '1', 'yes', 'enable', 'enabled', 'always', 'compact'].includes(normalized)) return 'on';
+  if (['off', 'false', '0', 'no', 'disable', 'disabled', 'never', 'full'].includes(normalized)) return 'off';
+  return 'auto';
+}
+
+function normalizeUIStyle(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (['ultra', 'minimal', 'min', 'ultra-clean', 'ultraclean'].includes(normalized)) return 'ultra';
+  if (['clean', 'minimal', 'codex', 'opencode'].includes(normalized)) return 'clean';
+  if (['sapper', 'classic', 'default'].includes(normalized)) return 'sapper';
+  return DEFAULT_CONFIG.ui.style;
+}
+
+function normalizeUIConfig(uiConfig = {}) {
+  if (typeof uiConfig === 'boolean' || typeof uiConfig === 'string') {
+    return {
+      compactMode: normalizeUICompactMode(uiConfig),
+      style: DEFAULT_CONFIG.ui.style,
+    };
+  }
+
+  if (!uiConfig || typeof uiConfig !== 'object' || Array.isArray(uiConfig)) {
+    return { ...DEFAULT_CONFIG.ui };
+  }
+
+  return {
+    compactMode: normalizeUICompactMode(uiConfig.compactMode),
+    style: normalizeUIStyle(uiConfig.style),
+  };
+}
+
+function normalizeChunkingConfig(chunkingConfig = {}) {
+  if (typeof chunkingConfig === 'boolean') {
+    return { ...DEFAULT_CONFIG.chunking, enabled: chunkingConfig };
+  }
+  if (typeof chunkingConfig === 'string') {
+    return { ...DEFAULT_CONFIG.chunking, enabled: normalizeBoolean(chunkingConfig, DEFAULT_CONFIG.chunking.enabled) };
+  }
+  if (!chunkingConfig || typeof chunkingConfig !== 'object' || Array.isArray(chunkingConfig)) {
+    return { ...DEFAULT_CONFIG.chunking };
+  }
+  return {
+    enabled: normalizeBoolean(chunkingConfig.enabled, DEFAULT_CONFIG.chunking.enabled),
+    contextLines: normalizeIntegerInRange(chunkingConfig.contextLines, DEFAULT_CONFIG.chunking.contextLines, 0, 200),
+    maxChunksPerFile: normalizeIntegerInRange(chunkingConfig.maxChunksPerFile, DEFAULT_CONFIG.chunking.maxChunksPerFile, 1, 50),
+    autoChunkAboveLines: normalizeIntegerInRange(chunkingConfig.autoChunkAboveLines, DEFAULT_CONFIG.chunking.autoChunkAboveLines, 50, 10000),
+  };
+}
+
+function normalizeVoiceConfig(voiceConfig = {}) {
+  if (typeof voiceConfig === 'boolean') {
+    return { ...DEFAULT_CONFIG.voice, enabled: voiceConfig };
+  }
+  if (typeof voiceConfig === 'string') {
+    return { ...DEFAULT_CONFIG.voice, enabled: normalizeBoolean(voiceConfig, DEFAULT_CONFIG.voice.enabled) };
+  }
+  if (!voiceConfig || typeof voiceConfig !== 'object' || Array.isArray(voiceConfig)) {
+    return { ...DEFAULT_CONFIG.voice };
+  }
+  const recorder = String(voiceConfig.recorder ?? '').trim().toLowerCase();
+  return {
+    enabled: normalizeBoolean(voiceConfig.enabled, DEFAULT_CONFIG.voice.enabled),
+    whisperBin: typeof voiceConfig.whisperBin === 'string' && voiceConfig.whisperBin.trim()
+      ? voiceConfig.whisperBin.trim()
+      : DEFAULT_CONFIG.voice.whisperBin,
+    whisperStreamBin: typeof voiceConfig.whisperStreamBin === 'string' && voiceConfig.whisperStreamBin.trim()
+      ? voiceConfig.whisperStreamBin.trim()
+      : DEFAULT_CONFIG.voice.whisperStreamBin,
+    model: typeof voiceConfig.model === 'string' && voiceConfig.model.trim()
+      ? voiceConfig.model.trim()
+      : DEFAULT_CONFIG.voice.model,
+    language: typeof voiceConfig.language === 'string' && voiceConfig.language.trim()
+      ? voiceConfig.language.trim().toLowerCase()
+      : DEFAULT_CONFIG.voice.language,
+    recorder: ['ffmpeg', 'sox'].includes(recorder) ? recorder : DEFAULT_CONFIG.voice.recorder,
+    recordSeconds: normalizeIntegerInRange(voiceConfig.recordSeconds, DEFAULT_CONFIG.voice.recordSeconds, 1, 300),
+    device: typeof voiceConfig.device === 'string' && voiceConfig.device
+      ? voiceConfig.device
+      : DEFAULT_CONFIG.voice.device,
+    sampleRate: normalizeIntegerInRange(voiceConfig.sampleRate, DEFAULT_CONFIG.voice.sampleRate, 8000, 48000),
+    translate: normalizeBoolean(voiceConfig.translate, DEFAULT_CONFIG.voice.translate),
+    autoSend: normalizeBoolean(voiceConfig.autoSend, DEFAULT_CONFIG.voice.autoSend),
+    liveStepMs: normalizeIntegerInRange(voiceConfig.liveStepMs, DEFAULT_CONFIG.voice.liveStepMs, 100, 5000),
+    liveLengthMs: normalizeIntegerInRange(voiceConfig.liveLengthMs, DEFAULT_CONFIG.voice.liveLengthMs, 1000, 30000),
+    liveKeepMs: normalizeIntegerInRange(voiceConfig.liveKeepMs, DEFAULT_CONFIG.voice.liveKeepMs, 0, 2000),
+    archive: normalizeBoolean(voiceConfig.archive, DEFAULT_CONFIG.voice.archive),
+    archiveDir: typeof voiceConfig.archiveDir === 'string' && voiceConfig.archiveDir.trim()
+      ? voiceConfig.archiveDir.trim()
+      : DEFAULT_CONFIG.voice.archiveDir,
+  };
+}
+
 function normalizePromptText(value) {
   if (typeof value === 'string') return value;
   if (value === null || value === undefined) return '';
@@ -1250,21 +1513,20 @@ function normalizePromptText(value) {
 
 function normalizePromptConfig(promptConfig = {}) {
   if (!promptConfig || typeof promptConfig !== 'object' || Array.isArray(promptConfig)) {
-    return {
-      ...DEFAULT_CONFIG.prompt,
-      append: normalizePromptText(promptConfig),
-    };
+    const normalized = normalizePromptTree({}, DEFAULT_CONFIG.prompt);
+    normalized.append = normalizePromptText(promptConfig);
+    return normalized;
   }
 
   const coreOverride = promptConfig.coreOverride !== undefined
     ? promptConfig.coreOverride
     : promptConfig.override;
 
-  return {
-    prepend: normalizePromptText(promptConfig.prepend),
-    append: normalizePromptText(promptConfig.append),
-    coreOverride: normalizePromptText(coreOverride),
-  };
+  const normalized = normalizePromptTree(promptConfig, DEFAULT_CONFIG.prompt);
+  normalized.prepend = normalizePromptText(promptConfig.prepend);
+  normalized.append = normalizePromptText(promptConfig.append);
+  normalized.coreOverride = normalizePromptText(coreOverride);
+  return normalized;
 }
 
 function normalizeConfig(config = {}) {
@@ -1285,19 +1547,156 @@ function normalizeConfig(config = {}) {
     shell: normalizeShellConfig(config.shell),
     streaming: normalizeStreamingConfig(config.streaming),
     thinking: normalizeThinkingConfig(config.thinking),
+    ui: normalizeUIConfig(config.ui),
+    chunking: normalizeChunkingConfig(config.chunking),
+    voice: normalizeVoiceConfig(config.voice),
     prompt: normalizePromptConfig(config.prompt),
   };
 }
 
+function stripJsonComments(text = '') {
+  let result = '';
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    const next = text[index + 1];
+
+    if (inLineComment) {
+      if (char === '\n') {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index++;
+      }
+      continue;
+    }
+
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inLineComment = true;
+      index++;
+      continue;
+    }
+
+    if (char === '/' && next === '*') {
+      inBlockComment = true;
+      index++;
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+function appendConfigProperty(lines, name, value, { indent = 2, trailingComma = true } = {}) {
+  const pad = ' '.repeat(indent);
+  const serialized = JSON.stringify(value, null, 2).split('\n');
+  lines.push(`${pad}"${name}": ${serialized[0]}`);
+  for (const line of serialized.slice(1)) {
+    lines.push(`${pad}${line}`);
+  }
+  if (trailingComma) {
+    lines[lines.length - 1] += ',';
+  }
+}
+
+function renderConfigFile(config) {
+  const lines = [
+    '// Sapper configuration file',
+    '// This file supports JSON-style comments. Edit values and restart only when a command explicitly says so.',
+    '{',
+    '  // Core runtime behavior',
+  ];
+
+  appendConfigProperty(lines, 'defaultModel', config.defaultModel);
+  appendConfigProperty(lines, 'defaultAgent', config.defaultAgent);
+  appendConfigProperty(lines, 'autoAttach', config.autoAttach);
+  appendConfigProperty(lines, 'debug', config.debug);
+  appendConfigProperty(lines, 'contextLimit', config.contextLimit);
+  appendConfigProperty(lines, 'toolRoundLimit', config.toolRoundLimit);
+  appendConfigProperty(lines, 'patchRetries', config.patchRetries);
+  appendConfigProperty(lines, 'maxFileSize', config.maxFileSize);
+  appendConfigProperty(lines, 'maxScanSize', config.maxScanSize);
+  appendConfigProperty(lines, 'maxUrlSize', config.maxUrlSize);
+  appendConfigProperty(lines, 'summaryPhases', config.summaryPhases);
+  appendConfigProperty(lines, 'summarizeTriggerPercent', config.summarizeTriggerPercent);
+
+  lines.push('');
+  lines.push('  // Shell execution settings');
+  appendConfigProperty(lines, 'shell', config.shell);
+
+  lines.push('');
+  lines.push('  // Model response visibility');
+  appendConfigProperty(lines, 'thinking', config.thinking);
+  appendConfigProperty(lines, 'streaming', config.streaming);
+
+  lines.push('');
+  lines.push('  // Frontend style and layout');
+  appendConfigProperty(lines, 'ui', config.ui);
+
+  lines.push('');
+  lines.push('  // Chunked / windowed reading');
+  lines.push('  // Keeps context small: agent reads relevant line ranges (e.g. 40-80) instead of whole files.');
+  lines.push('  // Set enabled to false to disable chunk grouping in regex_search and the read_chunk tool.');
+  appendConfigProperty(lines, 'chunking', config.chunking);
+
+  lines.push('');
+  lines.push('  // Voice input (Whisper)');
+  lines.push('  // Requires whisper.cpp `whisper-cli` and ffmpeg (or sox) on PATH, plus a ggml-*.bin model file.');
+  lines.push('  // Trigger from the chat with /voice record [seconds] or /voice file <path>.');
+  appendConfigProperty(lines, 'voice', config.voice);
+
+  lines.push('');
+  lines.push('  // Prompt customization');
+  lines.push('  // prompt.system.* controls the assistant system prompt blocks');
+  lines.push('  // prompt.ui.* controls startup/model-picker/help labels');
+  lines.push('  // prompt.questions.* controls interactive questions and confirmations');
+  appendConfigProperty(lines, 'prompt', config.prompt, { trailingComma: false });
+
+  lines.push('}');
+  lines.push('');
+  return lines.join('\n');
+}
+
 // Load config (settings like autoAttach and context summarization)
 function loadConfig() {
   try {
     ensureSapperDir();
     if (fs.existsSync(CONFIG_FILE)) {
-      const rawConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      const fileText = fs.readFileSync(CONFIG_FILE, 'utf8');
+      const rawConfig = JSON.parse(stripJsonComments(fileText));
       const normalizedConfig = normalizeConfig(rawConfig);
       if (JSON.stringify(rawConfig) !== JSON.stringify(normalizedConfig)) {
-        fs.writeFileSync(CONFIG_FILE, JSON.stringify(normalizedConfig, null, 2));
+        fs.writeFileSync(CONFIG_FILE, renderConfigFile(normalizedConfig));
       }
       return normalizedConfig;
     }
@@ -1307,7 +1706,7 @@ function loadConfig() {
   try {
     ensureSapperDir();
     if (!fs.existsSync(CONFIG_FILE)) {
-      fs.writeFileSync(CONFIG_FILE, JSON.stringify(defaultConfig, null, 2));
+      fs.writeFileSync(CONFIG_FILE, renderConfigFile(defaultConfig));
     }
   } catch (e) {}
   return defaultConfig;
@@ -1316,7 +1715,7 @@ function loadConfig() {
 function saveConfig(config) {
   ensureSapperDir();
   const normalizedConfig = normalizeConfig(config);
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(normalizedConfig, null, 2));
+  fs.writeFileSync(CONFIG_FILE, renderConfigFile(normalizedConfig));
   sapperConfig = normalizedConfig;
 }
 
@@ -1410,6 +1809,32 @@ function getPromptConfig() {
   return normalizePromptConfig(sapperConfig.prompt);
 }
 
+function getPromptTemplate(path, fallback = '', variables = {}) {
+  const promptConfig = getPromptConfig();
+  const value = String(path || '')
+    .split('.')
+    .filter(Boolean)
+    .reduce((current, key) => {
+      if (!current || typeof current !== 'object') return undefined;
+      return current[key];
+    }, promptConfig);
+
+  const template = typeof value === 'string' && value.trim() ? value : fallback;
+  return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, key) => {
+    const replacement = variables[key];
+    return replacement === undefined || replacement === null ? '' : String(replacement);
+  });
+}
+
+function promptQuestion(path, fallback, variables = {}, tone = 'cyan') {
+  const resolved = getPromptTemplate(path, fallback, variables);
+  return tone === 'cyan' ? chalk.cyan(resolved) : resolved;
+}
+
+function promptLabel(path, fallback, variables = {}) {
+  return getPromptTemplate(path, fallback, variables);
+}
+
 function getThinkingConfig() {
   return normalizeThinkingConfig(sapperConfig.thinking);
 }
@@ -1418,6 +1843,59 @@ function getStreamingConfig() {
   return normalizeStreamingConfig(sapperConfig.streaming);
 }
 
+function getUIConfig() {
+  return normalizeUIConfig(sapperConfig.ui);
+}
+
+function uiCompactMode() {
+  const mode = getUIConfig().compactMode;
+  if (mode === 'on') return true;
+  if (mode === 'off') return false;
+  const cols = process.stdout.columns || 100;
+  const rows = process.stdout.rows || 30;
+  return cols <= 100 || rows <= 28;
+}
+
+function uiStyle() {
+  return getUIConfig().style;
+}
+
+function uiCleanMode() {
+  return uiStyle() === 'clean' || uiStyle() === 'ultra';
+}
+
+function uiUltraCleanMode() {
+  return uiStyle() === 'ultra';
+}
+
+function getChunkingConfig() {
+  return normalizeChunkingConfig(sapperConfig.chunking);
+}
+
+function chunkingEnabled() {
+  return getChunkingConfig().enabled;
+}
+
+function chunkingContextLines() {
+  return getChunkingConfig().contextLines;
+}
+
+function chunkingMaxPerFile() {
+  return getChunkingConfig().maxChunksPerFile;
+}
+
+function chunkingAutoAboveLines() {
+  return getChunkingConfig().autoChunkAboveLines;
+}
+
+function getVoiceConfig() {
+  return normalizeVoiceConfig(sapperConfig.voice);
+}
+
+function voiceEnabled() {
+  return getVoiceConfig().enabled;
+}
+
 function streamPhaseStatusEnabled() {
   return getStreamingConfig().showPhaseStatus;
 }
@@ -1608,6 +2086,27 @@ function saveWorkspaceGraph(workspace) {
   fs.writeFileSync(WORKSPACE_FILE, JSON.stringify(workspace, null, 2));
 }
 
+async function buildWorkspaceGraph(dir = '.') {
+  const scanResult = scanCodebase(dir);
+  const files = {};
+  const graph = {};
+
+  for (const file of scanResult.files) {
+    if (file.skipped || !file.content) continue;
+
+    const symbols = extractSymbolsWithRegex(file.content, file.path);
+    const deps = extractDependencies(file.content, file.path);
+    const exports = extractExports(file.content, file.path);
+
+    files[file.path] = { symbols, exports, size: file.size };
+    graph[file.path] = deps;
+  }
+
+  const workspace = { indexed: new Date().toISOString(), files, graph };
+  saveWorkspaceGraph(workspace);
+  return workspace;
+}
+
 // Extract imports/requires from file content
 function extractDependencies(content, filePath) {
   const deps = new Set();
@@ -1649,18 +2148,9 @@ function extractExports(content, filePath) {
   if (['js', 'jsx', 'ts', 'tsx', 'mjs'].includes(ext)) {
     // export function/class/const name
     const namedExports = content.matchAll(/export\s+(?:function|class|const|let|var|async function)\s+(\w+)/g);
-    for (const m of namedExports) exports.add(m[1]);
-    
-    // export { name }
-    const bracketExports = content.matchAll(/export\s*\{([^}]+)\}/g);
-    for (const m of bracketExports) {
-      m[1].split(',').forEach(e => {
-        const name = e.trim().split(/\s+as\s+/)[0].trim();
-        if (name) exports.add(name);
-      });
+    for (const m of namedExports) {
+      exports.add(m[1]);
     }
-    
-    // export default
     if (content.includes('export default')) exports.add('default');
   }
   
@@ -1668,85 +2158,6 @@ function extractExports(content, filePath) {
 }
 
 // Resolve relative import to actual file path
-function resolveImportPath(importPath, fromFile) {
-  if (!importPath.startsWith('.')) return null;
-  
-  const fromDir = dirname(fromFile);
-  let resolved = join(fromDir, importPath).replace(/\\/g, '/');
-  
-  // Try common extensions
-  const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '.mjs', '/index.js', '/index.ts'];
-  for (const ext of extensions) {
-    const fullPath = resolved + ext;
-    if (fs.existsSync(fullPath)) {
-      return fullPath.replace(/^\.\//, '');
-    }
-  }
-  return null;
-}
-
-// Build workspace graph from codebase
-async function buildWorkspaceGraph(showProgress = true) {
-  const workspace = { indexed: new Date().toISOString(), files: {}, graph: {} };
-  
-  function scanDir(dir, depth = 0) {
-    if (depth > 5) return;
-    
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const fullPath = dir === '.' ? entry.name : `${dir}/${entry.name}`;
-        
-        if (entry.isDirectory()) {
-          if (shouldIgnore(entry.name) || entry.name.startsWith('.')) continue;
-          scanDir(fullPath, depth + 1);
-        } else {
-          if (shouldIgnore(fullPath) || shouldIgnore(entry.name)) continue;
-          const ext = entry.name.includes('.') ? '.' + entry.name.split('.').pop() : '';
-          if (!CODE_EXTENSIONS.has(ext.toLowerCase())) continue;
-          
-          try {
-            const stats = fs.statSync(fullPath);
-            if (stats.size > getMaxFileSize()) continue;
-            
-            const content = fs.readFileSync(fullPath, 'utf8');
-            const deps = extractDependencies(content, fullPath);
-            const exports = extractExports(content, fullPath);
-            
-            // Generate brief summary (first meaningful lines)
-            const lines = content.split('\n').filter(l => l.trim() && !l.trim().startsWith('//') && !l.trim().startsWith('#'));
-            const summary = lines.slice(0, 3).join(' ').substring(0, 150);
-            
-            workspace.files[fullPath] = {
-              size: stats.size,
-              modified: stats.mtime.toISOString(),
-              imports: deps,
-              exports: exports,
-              symbols: parseFileSymbols(content, fullPath), // AST-extracted symbols
-              summary: summary || '(no summary)'
-            };
-            
-            // Build dependency graph
-            workspace.graph[fullPath] = [];
-            for (const dep of deps) {
-              const resolved = resolveImportPath(dep, fullPath);
-              if (resolved) {
-                workspace.graph[fullPath].push(resolved);
-              }
-            }
-          } catch (e) {}
-        }
-      }
-    } catch (e) {}
-  }
-  
-  scanDir('.');
-  saveWorkspaceGraph(workspace);
-  return workspace;
-}
-
-// Get related files for a given file (imports + files that import it)
 function getRelatedFiles(filePath, workspace, depth = 1) {
   const related = new Set();
   
@@ -1763,10 +2174,9 @@ function getRelatedFiles(filePath, workspace, depth = 1) {
   
   // Second level if depth > 1
   if (depth > 1) {
-    const firstLevel = Array.from(related);
-    for (const f of firstLevel) {
-      const secondImports = workspace.graph[f] || [];
-      secondImports.forEach(sf => related.add(sf));
+    for (const imported of imports) {
+      const secondLevel = workspace.graph[imported] || [];
+      secondLevel.forEach(f => related.add(f));
     }
   }
   
@@ -2118,6 +2528,119 @@ async function addToEmbeddings(text, embeddings) {
   }
 }
 
+function longMemoryTemplate() {
+  return `# Sapper Long Memory
+
+This file stores durable project notes, patterns, and decisions.
+Sapper can write and search this file with /memory commands and memory-note tools.
+
+## Notes
+
+`;
+}
+
+function ensureLongMemoryFile() {
+  ensureSapperDir();
+  if (!fs.existsSync(LONG_MEMORY_FILE)) {
+    fs.writeFileSync(LONG_MEMORY_FILE, longMemoryTemplate());
+  }
+}
+
+function loadLongMemoryText() {
+  try {
+    ensureLongMemoryFile();
+    return fs.readFileSync(LONG_MEMORY_FILE, 'utf8');
+  } catch (error) {
+    return longMemoryTemplate();
+  }
+}
+
+function normalizeMemoryTags(tags) {
+  const rawTags = Array.isArray(tags)
+    ? tags
+    : String(tags ?? '').split(',');
+  return Array.from(new Set(
+    rawTags
+      .map(tag => String(tag ?? '').trim().toLowerCase())
+      .filter(tag => tag.length > 0)
+      .map(tag => tag.replace(/\s+/g, '-'))
+  )).slice(0, 8);
+}
+
+function inferMemoryTitle(content) {
+  const singleLine = String(content ?? '').replace(/\s+/g, ' ').trim();
+  if (!singleLine) return 'Untitled note';
+  const sentence = singleLine.split(/[.!?]/)[0].trim();
+  return (sentence || singleLine).slice(0, 80);
+}
+
+function getLongMemorySections() {
+  const raw = loadLongMemoryText();
+  return raw
+    .split(/\n(?=##\s)/g)
+    .map(section => section.trim())
+    .filter(section => section.startsWith('## '));
+}
+
+function appendLongMemoryNote({ title, content, tags = [], source = 'manual' } = {}) {
+  const cleanContent = String(content ?? '').trim();
+  if (!cleanContent) {
+    return { ok: false, error: 'Note content is required.' };
+  }
+
+  const cleanTitle = String(title ?? '').trim() || inferMemoryTitle(cleanContent);
+  const cleanTags = normalizeMemoryTags(tags);
+  const timestamp = new Date().toISOString();
+  const lines = [
+    `## ${timestamp} | ${cleanTitle}`,
+    `- Tags: ${cleanTags.length ? cleanTags.join(', ') : 'general'}`,
+    `- Source: ${source}`,
+    `- Project: ${PROJECT_ROOT}`,
+    '',
+    cleanContent,
+  ];
+
+  ensureLongMemoryFile();
+  const existing = loadLongMemoryText().trimEnd();
+  fs.writeFileSync(LONG_MEMORY_FILE, `${existing}\n\n${lines.join('\n')}\n`);
+
+  return {
+    ok: true,
+    title: cleanTitle,
+    tags: cleanTags,
+    timestamp,
+    path: LONG_MEMORY_FILE,
+  };
+}
+
+function searchLongMemoryNotes(query, limit = 5) {
+  const cleanQuery = String(query ?? '').trim().toLowerCase();
+  if (!cleanQuery) return [];
+
+  const words = Array.from(new Set(cleanQuery.split(/[^a-z0-9_]+/i).filter(Boolean)));
+  const sections = getLongMemorySections();
+  const scored = sections.map((section) => {
+    const lowered = section.toLowerCase();
+    let score = 0;
+    if (lowered.includes(cleanQuery)) score += 5;
+    for (const word of words) {
+      if (word.length >= 2 && lowered.includes(word)) score += 1;
+    }
+    return { section, score };
+  }).filter(item => item.score > 0);
+
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, Math.max(1, limit)).map(item => item.section);
+}
+
+function listLongMemoryNotes(limit = 8) {
+  return getLongMemorySections()
+    .slice(-Math.max(1, limit))
+    .reverse()
+    .map(section => section.split('\n')[0]?.replace(/^##\s*/, '').trim())
+    .filter(Boolean);
+}
+
 // ═══════════════════════════════════════════════════════════════
 // SMART CONTEXT SUMMARIZATION
 // ═══════════════════════════════════════════════════════════════
@@ -2435,13 +2958,21 @@ function formatRelativeTime(value) {
   return 'just now';
 }
 
-const BANNER = [
-  `${chalk.hex('#c8ecff').bold('Sapper')} ${UI.slate('terminal workspace')}`,
-  UI.slate('Local models, live tools, and focused coding in one loop')
-].join('\n');
+function bannerText() {
+  return [
+    `${chalk.hex('#c8ecff').bold(promptLabel('ui.bannerTitle', 'Sapper'))} ${UI.slate(promptLabel('ui.bannerSubtitle', 'terminal coding workspace'))}`,
+    UI.slate(promptLabel('ui.bannerTagline', 'Model selection, live tools, and focused sessions in one loop')),
+  ].join('\n');
+}
 
 function box(content, title = '', tone = 'cyan', options = {}) {
   const width = Math.max(28, Math.min(options.width || terminalWidth(72), terminalWidth(72)));
+  if (uiCleanMode()) {
+    const cleanTitle = String(title || '').replace(/[^\x20-\x7E]/g, '').replace(/\s+/g, ' ').trim();
+    const line = UI.slate('-'.repeat(Math.max(12, width)));
+    const header = cleanTitle ? `${chalk.white(cleanTitle)}\n${line}\n` : '';
+    return `${header}${String(content ?? '')}\n${line}`;
+  }
   const header = title ? `${toneColor(tone).bold(title)}\n${divider('─', tone, width)}\n` : '';
   return `${header}${String(content ?? '')}\n${divider('─', tone, width)}`;
 }
@@ -2463,10 +2994,158 @@ function keyValue(label, value, width = 12) {
   return `${padAnsi(UI.slate(label), width)} ${value}`;
 }
 
+function piRow(label, value, width = 13) {
+  return `${padAnsi(UI.slate(`[${label}]`), width)} ${value}`;
+}
+
 function commandRow(command, description, width = 18) {
   return `${padAnsi(UI.accent(command), width)} ${UI.slate('—')} ${UI.ink(description)}`;
 }
 
+const COMMAND_GROUPS = Object.freeze([
+  {
+    title: 'Core',
+    subtitle: 'daily workflow',
+    tone: 'cyan',
+    rows: [
+      ['@ or /attach', 'Pick files to attach interactively'],
+      ['@file', 'Attach a file inline, for example @src/app.js'],
+      ['/scan', 'Scan the codebase into context'],
+      ['/index', 'Rebuild the workspace graph'],
+      ['/graph file', 'Show related files from the graph'],
+      ['/symbol name', 'Search indexed functions and classes'],
+      ['/auto', 'Toggle automatic related-file attach'],
+    ],
+  },
+  {
+    title: 'Context',
+    subtitle: 'memory and visibility',
+    tone: 'cyan',
+    rows: [
+      ['/model', 'Open model picker to switch AI mid-session'],
+      ['/model <name>', 'Switch directly to a named model (e.g. /model llama3.2)'],
+      ['/recall', 'Search memory for relevant context'],
+      ['/memory', 'Manage markdown long-memory notes and patterns'],
+      ['/memory add title ::: note', 'Save a durable note to .sapper/long-memory.md'],
+      ['/fetch <url>', 'Fetch a web page into context'],
+      ['/reset /clear', 'Clear all current context'],
+      ['/prune', 'Summarize long context and store memory'],
+      ['/summary', 'Show or change auto-summary settings'],
+      ['/chunking', 'Toggle chunked reading (search-then-window) and context size'],
+      ['/voice, /v', 'Voice input via Whisper (record from mic or transcribe a file)'],
+      ['/v live', 'Live preview while you speak, clean final transcript on stop'],
+      ['/v models', 'List available Whisper models and pick one interactively'],
+      ['/v record', 'Record — press any key to stop, then transcribe'],
+      ['/v record <secs>', 'Record for a fixed duration, then transcribe'],
+      ['/ui', 'Show or change frontend style and compact mode'],
+      ['/ui style clean', 'Switch to a clean Codex/OpenCode-like frontend'],
+      ['/ui style ultra', 'Switch to an ultra-clean single-line frontend'],
+      ['/shell', 'Inspect shell config and background sessions'],
+      ['/shell read <id>', 'Read output from a tracked shell session'],
+      ['/shell stop <id>', 'Stop a tracked shell session'],
+      ['/context', 'Inspect token usage, summary trigger, and model window'],
+      ['/ctx <limit>', 'Set context window limit (e.g. /ctx 64k)'],
+      ['/debug', 'Toggle regex and tool debug output'],
+      ['/log', 'Show the session activity timeline'],
+      ['/log stats', 'Show session statistics'],
+      ['/log file', 'Show log file path and history'],
+      ['/help', 'Open command guide'],
+      ['/commands', 'Alias for /help'],
+      ['exit', 'Quit Sapper'],
+    ],
+  },
+  {
+    title: 'Agents',
+    subtitle: 'specialist modes and skills',
+    tone: 'cyan',
+    rows: [
+      ['/agents', 'List available agents'],
+      ['/skills', 'List available skills'],
+      ['/agentname', 'Switch to an agent such as /reviewer'],
+      ['/default', 'Return to the default Sapper role'],
+      ['/use skill', 'Load a skill into the session'],
+      ['/unload skill', 'Unload a previously loaded skill'],
+      ['/newagent', 'Create a new agent'],
+      ['/newskill', 'Create a new skill'],
+    ],
+  },
+]);
+
+const COMMAND_LOOKUP = Object.freeze(
+  Array.from(new Set(COMMAND_GROUPS.flatMap(group => group.rows.map(([command]) => command))))
+);
+
+function renderCommandPalette() {
+  const lines = [];
+  for (const group of COMMAND_GROUPS) {
+    if (lines.length > 0) lines.push('');
+    lines.push(sectionTitle(group.title, group.subtitle, group.tone));
+    for (const [command, description] of group.rows) {
+      lines.push(commandRow(command, description));
+    }
+  }
+
+  lines.push(divider());
+  lines.push(UI.slate('  Summary settings: /summary  |  /summary phases off  |  /summary trigger 60'));
+  lines.push(UI.slate('  Tool config: .sapper/config.json -> toolRoundLimit (default 40)'));
+  lines.push(UI.slate('  Shell config: .sapper/config.json -> shell.streamToModel, shell.backgroundMode [off|auto|on], shell.backgroundAfterSeconds, shell.outputChunkChars'));
+  lines.push(UI.slate('  Want to see all live shell output? Set shell.backgroundMode to off. thinking.mode only controls model reasoning.'));
+  lines.push(UI.slate('  Streaming config: .sapper/config.json -> streaming.showPhaseStatus, streaming.showHeartbeat, streaming.idleNoticeSeconds'));
+  lines.push(UI.slate('  Thinking config: .sapper/config.json -> thinking.mode [auto|on|off]'));
+  lines.push(UI.slate('  UI config: .sapper/config.json -> ui.style [sapper|clean|ultra], ui.compactMode [auto|on|off]'));
+  lines.push(UI.slate('  Prompt config: .sapper/config.json -> prompt.prepend, prompt.append, prompt.coreOverride, prompt.system.*, prompt.ui.*, prompt.questions.*'));
+
+  return lines.join('\n');
+}
+
+function levenshteinDistance(a = '', b = '') {
+  const left = String(a);
+  const right = String(b);
+  if (left === right) return 0;
+  if (!left.length) return right.length;
+  if (!right.length) return left.length;
+
+  const previous = Array.from({ length: right.length + 1 }, (_, i) => i);
+  const current = new Array(right.length + 1);
+
+  for (let i = 1; i <= left.length; i++) {
+    current[0] = i;
+    for (let j = 1; j <= right.length; j++) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      current[j] = Math.min(
+        current[j - 1] + 1,
+        previous[j] + 1,
+        previous[j - 1] + cost
+      );
+    }
+    for (let j = 0; j <= right.length; j++) {
+      previous[j] = current[j];
+    }
+  }
+
+  return previous[right.length];
+}
+
+function suggestSlashCommands(inputValue = '', maxSuggestions = 4) {
+  const normalized = inputValue.trim().toLowerCase().replace(/^\/+/, '');
+  if (!normalized) return [];
+
+  const scored = COMMAND_LOOKUP.map(command => {
+    const token = command.toLowerCase().replace(/^\/+/, '').split(/\s+/)[0];
+    const score = token.startsWith(normalized)
+      ? 0
+      : normalized.startsWith(token)
+        ? 1
+        : levenshteinDistance(normalized, token);
+    return { command, score };
+  }).sort((a, b) => a.score - b.score || a.command.length - b.command.length);
+
+  return scored
+    .filter(item => item.score <= Math.max(2, Math.ceil(normalized.length / 2)))
+    .slice(0, maxSuggestions)
+    .map(item => item.command);
+}
+
 function renderViewport(content, { verticalAlign = 'top', minTopPadding = 0 } = {}) {
   const text = String(content ?? '').replace(/\n+$/, '');
   const rows = Math.max(12, process.stdout.rows || 24);
@@ -2499,7 +3178,11 @@ function ellipsis(text = '', max = 48) {
 }
 
 function promptShell(label, detail = '') {
-  return `${UI.slate(label)}${detail ? `\n${detail}` : ''}\n${UI.accent('› ')} `;
+  if (uiCleanMode()) {
+    const body = detail ? `${UI.slate(label)}\n${UI.slate(detail)}` : UI.slate(label);
+    return `${body}\n${UI.accent('› ')} `;
+  }
+  return `${UI.slate(label)}${detail ? `\n${detail}` : ''}\n${UI.accent('> ')} `;
 }
 
 function renderedTerminalLineCount(text = '', width = process.stdout.columns || 80) {
@@ -2758,7 +3441,7 @@ async function handleShellSessionCommand(command = '') {
     }
 
     console.log();
-    const confirmation = await safeQuestion(confirmPrompt(`Stop background shell session ${session.id}`, 'error', '[y/N] '));
+    const confirmation = await safeQuestion(confirmPrompt(promptLabel('questions.stopBackgroundShellSession', 'Stop background shell session {id}', { id: session.id }), 'error', '[y/N] '));
     if (!['y', 'yes'].includes(String(confirmation ?? '').trim().toLowerCase())) {
       return `Stop request cancelled for shell session ${session.id}.`;
     }
@@ -3009,6 +3692,39 @@ let modelContextLength = null;  // Detected from ollama.show() model_info
 let lastPromptTokens = 0;      // prompt_eval_count from last response
 let lastEvalTokens = 0;        // eval_count from last response
 
+const SLASH_COMPLETION_COMMANDS = Object.freeze(Array.from(new Set(
+  COMMAND_GROUPS
+    .flatMap(group => group.rows.map(([command]) => command))
+    .flatMap(command => (String(command).match(/\/[a-z0-9-]+/gi) || []).map(token => token.toLowerCase()))
+    .concat(['/commands', '/cmd'])
+)).sort());
+
+function buildReadlineCompleter() {
+  return (line) => {
+    const raw = String(line || '');
+    const trimmed = raw.trimStart();
+
+    if (!trimmed.startsWith('/')) {
+      return [[], line];
+    }
+
+    // Complete only the first token (command) to avoid interfering with free-form args.
+    const commandToken = trimmed.split(/\s+/)[0].toLowerCase();
+    const hits = SLASH_COMPLETION_COMMANDS.filter(cmd => cmd.startsWith(commandToken));
+    return [hits.length ? hits : SLASH_COMPLETION_COMMANDS, commandToken];
+  };
+}
+
+function createReadlineInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    historySize: 100,
+    completer: buildReadlineCompleter(),
+  });
+}
+
 // Estimate token count from text (~4 chars per token for English, ~3 for code)
 // This is a rough heuristic - actual counts come from Ollama response stats
 function estimateTokens(text) {
@@ -3030,21 +3746,11 @@ function estimateMessagesTokens(messages) {
   }
   return total;
 }
-let rl = readline.createInterface({ 
-  input: process.stdin, 
-  output: process.stdout,
-  terminal: true,
-  historySize: 100
-});
+let rl = createReadlineInterface();
 
 function recreateReadline() {
   if (rl) rl.close();
-  rl = readline.createInterface({ 
-    input: process.stdin, 
-    output: process.stdout,
-    terminal: true,
-    historySize: 100
-  });
+  rl = createReadlineInterface();
   // Force resume stdin to keep process alive
   process.stdin.resume();
 }
@@ -3668,7 +4374,12 @@ async function pickModel(models) {
   if (!models || models.length === 0) return null;
 
   let cursor = 0;
-  const pageSize = Math.max(5, Math.min(8, (process.stdout.rows || 24) - 14));
+  const compact = uiCompactMode();
+  const clean = uiCleanMode();
+  const ultra = uiUltraCleanMode();
+  const pageSize = compact
+    ? Math.max(4, Math.min(7, (process.stdout.rows || 24) - 16))
+    : Math.max(5, Math.min(8, (process.stdout.rows || 24) - 14));
 
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true);
@@ -3677,13 +4388,27 @@ async function pickModel(models) {
 
   const render = () => {
     const current = models[cursor];
-    const lines = [
-      BANNER,
-      `${UI.slate(process.cwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`,
-      divider(),
-      sectionTitle('Model selection', 'use ↑↓ or j/k, enter to confirm', 'cyan'),
-      ''
-    ];
+    const lines = ultra
+      ? [
+          `${chalk.white(promptLabel('ui.bannerTitle', 'Sapper'))} ${UI.slate(promptLabel('ui.modelPickerUltraTitle', 'models'))}`,
+          `${UI.slate(safeCwd())}`,
+          ''
+        ]
+      : clean
+      ? [
+          `${chalk.white(promptLabel('ui.bannerTitle', 'Sapper'))} ${UI.slate(promptLabel('ui.modelPickerCleanTitle', 'model picker'))}`,
+          `${UI.slate(safeCwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`,
+          divider('─', 'gray', terminalWidth(70)),
+          sectionTitle(promptLabel('ui.modelPickerSectionTitle', 'Model'), promptLabel('ui.modelPickerSubtitle', 'use ↑↓ or j/k, enter to confirm'), 'gray'),
+          ''
+        ]
+      : [
+          bannerText(),
+          `${UI.slate(safeCwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`,
+          divider(),
+          sectionTitle(promptLabel('ui.modelPickerTitle', 'Model selection'), promptLabel('ui.modelPickerSubtitle', 'use ↑↓ or j/k, enter to confirm'), 'cyan'),
+          ''
+        ];
 
     const startIdx = Math.max(0, Math.min(cursor - Math.floor(pageSize / 2), models.length - pageSize));
     const endIdx = Math.min(startIdx + pageSize, models.length);
@@ -3717,14 +4442,30 @@ async function pickModel(models) {
     const family = current.details?.family || current.details?.format || current.details?.parameter_size || 'local model';
     const quant = current.details?.quantization_level || current.details?.quantization || 'default';
     lines.push('');
-    lines.push(box(
-      `${keyValue('Selected', chalk.white.bold(current.name), 10)}\n` +
-      `${keyValue('Footprint', UI.ink(current.size ? formatBytes(current.size) : 'unknown'), 10)}\n` +
-      `${keyValue('Updated', UI.ink(current.modified_at ? formatRelativeTime(current.modified_at) : 'unknown'), 10)}\n` +
-      `${keyValue('Profile', UI.ink(family), 10)}\n` +
-      `${keyValue('Quant', UI.ink(quant), 10)}`,
-      'Preview', 'gray'
-    ));
+    if (ultra) {
+      lines.push(
+        `${UI.slate('selected')} ${chalk.white.bold(current.name)} ${UI.slate('·')} ` +
+        `${UI.slate(current.size ? formatBytes(current.size) : 'unknown')} ${UI.slate('·')} ` +
+        `${UI.slate(current.modified_at ? formatRelativeTime(current.modified_at) : 'unknown')}`
+      );
+      lines.push(UI.slate('enter confirm  ·  q cancel'));
+    } else if (clean) {
+      lines.push(
+        `${UI.slate('selected')} ${chalk.white.bold(current.name)} ${UI.slate('·')} ` +
+        `${UI.slate('size')} ${UI.ink(current.size ? formatBytes(current.size) : 'unknown')} ${UI.slate('·')} ` +
+        `${UI.slate('updated')} ${UI.ink(current.modified_at ? formatRelativeTime(current.modified_at) : 'unknown')} ${UI.slate('·')} ` +
+        `${UI.slate('profile')} ${UI.ink(family)} ${UI.slate('·')} ${UI.slate('quant')} ${UI.ink(quant)}`
+      );
+    } else {
+      lines.push(box(
+        `${keyValue('Selected', chalk.white.bold(current.name), 10)}\n` +
+        `${keyValue('Footprint', UI.ink(current.size ? formatBytes(current.size) : 'unknown'), 10)}\n` +
+        `${keyValue('Updated', UI.ink(current.modified_at ? formatRelativeTime(current.modified_at) : 'unknown'), 10)}\n` +
+        `${keyValue('Profile', UI.ink(family), 10)}\n` +
+        `${keyValue('Quant', UI.ink(quant), 10)}`,
+        'Preview', 'gray'
+      ));
+    }
 
     renderViewport(lines.join('\n'), { verticalAlign: 'center' });
   };
@@ -3774,10 +4515,10 @@ async function pickModel(models) {
   });
 }
 
-let toolWorkingDirectory = process.cwd();
+let toolWorkingDirectory = PROJECT_ROOT;
 
 function getToolWorkingDirectory() {
-  return toolWorkingDirectory || process.cwd();
+  return toolWorkingDirectory || PROJECT_ROOT;
 }
 
 function resolveToolPath(pathValue = '.', { allowEmpty = false } = {}) {
@@ -3794,7 +4535,7 @@ function resolveToolPath(pathValue = '.', { allowEmpty = false } = {}) {
   }
   const resolved = isAbsolute(rawPath) ? rawPath : pathResolve(getToolWorkingDirectory(), rawPath);
   // Prevent path traversal outside the project directory
-  const projectRoot = process.cwd();
+  const projectRoot = PROJECT_ROOT;
   if (!resolved.startsWith(projectRoot + '/') && resolved !== projectRoot) {
     return projectRoot; // Fall back to project root for paths that escape sandbox
   }
@@ -3899,123 +4640,888 @@ function findPathsByName(patternValue, startPathValue = '.') {
   return `${header}\n${body}${truncated}`;
 }
 
-function truncateToolText(textValue = '', maxChars = 24000) {
-  const text = String(textValue ?? '').trim();
-  if (!text) return '';
-  if (text.length <= maxChars) return text;
-  return `${text.slice(0, maxChars)}\n... (output truncated at ${maxChars.toLocaleString()} chars)`;
+// ─────────────────────────────────────────────────────────────────
+// REGEX SEARCH — advanced source-code search using JS RegExp
+// Accepts /pattern/flags or raw pattern (default flags = 'i').
+// Optional include filter: comma-separated extensions (js,ts) or
+// path substrings (src/,routes). Returns file:line:col matches
+// with capture groups, capped to keep context small.
+// ─────────────────────────────────────────────────────────────────
+function parseRegexPattern(rawPattern) {
+  const raw = String(rawPattern ?? '').trim();
+  if (!raw) return { error: 'Missing regex pattern' };
+
+  let body = raw;
+  let flags = 'i';
+  const delimMatch = raw.match(/^\/(.+)\/([gimsuy]*)$/);
+  if (delimMatch) {
+    body = delimMatch[1];
+    flags = delimMatch[2] || 'i';
+  }
+  // Always evaluate per-line so we can report line numbers; strip a user-supplied 'g'.
+  flags = flags.replace(/g/g, '');
+
+  try {
+    return { regex: new RegExp(body, flags), body, flags };
+  } catch (error) {
+    return { error: `Invalid regex: ${error.message}` };
+  }
+}
+
+function matchesIncludeFilter(relativePath, includeList) {
+  if (!includeList || includeList.length === 0) return true;
+  const lower = relativePath.toLowerCase();
+  for (const token of includeList) {
+    const norm = token.toLowerCase();
+    if (!norm) continue;
+    // Extension-only token (e.g. "js" or ".js")
+    if (/^\.?[a-z0-9]+$/i.test(norm)) {
+      const ext = norm.startsWith('.') ? norm : `.${norm}`;
+      if (lower.endsWith(ext)) return true;
+    } else if (lower.includes(norm)) {
+      return true;
+    }
+  }
+  return false;
 }
 
-function shellQuote(value = '') {
-  return `'${String(value ?? '').replace(/'/g, `'\\''`)}'`;
+const REGEX_TEXT_EXTENSIONS = new Set([
+  'js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs',
+  'py', 'rb', 'go', 'rs', 'java', 'kt', 'kts', 'scala',
+  'c', 'h', 'cc', 'cpp', 'hpp', 'cs', 'swift', 'm', 'mm',
+  'php', 'pl', 'lua', 'sh', 'bash', 'zsh', 'fish', 'ps1',
+  'html', 'htm', 'css', 'scss', 'sass', 'less', 'vue', 'svelte',
+  'json', 'jsonc', 'yaml', 'yml', 'toml', 'ini', 'env',
+  'md', 'mdx', 'txt', 'rst', 'tex',
+  'sql', 'graphql', 'gql', 'proto', 'xml',
+]);
+
+function isLikelyTextFile(name) {
+  const ext = name.includes('.') ? name.split('.').pop().toLowerCase() : '';
+  if (!ext) return false;
+  return REGEX_TEXT_EXTENSIONS.has(ext);
 }
 
-function runCapturedCommand(command, { cwd = getToolWorkingDirectory(), timeoutMs = 12000, maxOutput = 24000 } = {}) {
-  return new Promise((resolve) => {
-    const proc = spawn('sh', ['-c', command], { cwd });
-    let stdout = '';
-    let stderr = '';
-    let stdoutTruncated = false;
-    let stderrTruncated = false;
-    let finished = false;
+// Read a specific line range from a file (1-based, inclusive).
+// If start/end are omitted, returns the whole file capped at maxLines.
+// Always emits gutter-style line numbers so the agent knows exact positions.
+function readChunk(pathValue, startValue, endValue, contextValue) {
+  const trimmedPath = typeof pathValue === 'string' ? pathValue.trim() : '';
+  if (!trimmedPath) return 'Error reading chunk: missing file path';
 
-    const appendLimited = (existing, chunkText, maxChars, setTruncated) => {
-      if (existing.length >= maxChars) {
-        setTruncated(true);
-        return existing;
-      }
-      const remaining = maxChars - existing.length;
-      if (chunkText.length > remaining) {
-        setTruncated(true);
-        return existing + chunkText.slice(0, remaining);
-      }
-      return existing + chunkText;
-    };
+  let content;
+  try {
+    content = fs.readFileSync(resolveToolPath(trimmedPath), 'utf8');
+  } catch (error) {
+    return `Error reading chunk: ${error.message}`;
+  }
 
-    const finish = (result) => {
-      if (finished) return;
-      finished = true;
-      if (timer) clearTimeout(timer);
-      const finalStdout = stdoutTruncated
-        ? `${stdout}\n... (stdout truncated at ${maxOutput.toLocaleString()} chars)`
-        : stdout;
-      const finalStderr = stderrTruncated
-        ? `${stderr}\n... (stderr truncated at ${maxOutput.toLocaleString()} chars)`
-        : stderr;
-      resolve({ ...result, stdout: finalStdout, stderr: finalStderr });
-    };
+  const lines = content === '' ? [] : content.split('\n');
+  if (lines.length === 0) {
+    return `Chunk of ${trimmedPath}: (empty file)`;
+  }
 
-    const timer = timeoutMs > 0
-      ? setTimeout(() => {
-          try { proc.kill('SIGTERM'); } catch (e) {}
-          finish({ exitCode: 124, stdout, stderr: `${stderr}\nCommand timed out after ${timeoutMs}ms`.trim(), timedOut: true });
-        }, timeoutMs)
-      : null;
+  const ctx = Number.isFinite(Number(contextValue)) ? Math.max(0, Math.round(Number(contextValue))) : 0;
+  let start = Number(startValue);
+  let end = Number(endValue);
 
-    proc.stdout.on('data', (data) => {
-      stdout = appendLimited(stdout, data.toString(), maxOutput, (value) => { stdoutTruncated = value; });
-    });
-    proc.stderr.on('data', (data) => {
-      stderr = appendLimited(stderr, data.toString(), maxOutput, (value) => { stderrTruncated = value; });
-    });
+  if (!Number.isFinite(start) || start < 1) start = 1;
+  if (!Number.isFinite(end) || end < start) end = Math.min(lines.length, start + 60);
 
-    proc.on('error', (error) => {
-      finish({ exitCode: 1, stdout, stderr: `${stderr}\n${error.message}`.trim(), timedOut: false });
-    });
-    proc.on('close', (code) => {
-      finish({ exitCode: code ?? 0, stdout, stderr, timedOut: false });
-    });
+  // Expand by context window when caller asked for it
+  start = Math.max(1, start - ctx);
+  end = Math.min(lines.length, end + ctx);
+
+  const MAX_CHUNK_LINES = 400;
+  if (end - start + 1 > MAX_CHUNK_LINES) {
+    end = start + MAX_CHUNK_LINES - 1;
+  }
+
+  const gutterWidth = String(end).length;
+  const slice = lines.slice(start - 1, end).map((line, idx) => {
+    const lineNo = String(start + idx).padStart(gutterWidth, ' ');
+    return `${lineNo} | ${line}`;
   });
+
+  const header = `Chunk of ${trimmedPath} (lines ${start}-${end} of ${lines.length}):`;
+  const footer = end < lines.length || start > 1
+    ? `\n... (${start > 1 ? `${start - 1} line(s) before` : ''}${start > 1 && end < lines.length ? ', ' : ''}${end < lines.length ? `${lines.length - end} line(s) after` : ''})`
+    : '';
+  return `${header}\n${slice.join('\n')}${footer}`;
 }
 
-function normalizeFetchedWebContent(rawContent = '') {
-  const trimmed = String(rawContent ?? '').trim();
-  if (!trimmed) return '';
+function regexSearch(patternValue, includeValue = '', startPathValue = '.') {
+  const parsed = parseRegexPattern(patternValue);
+  if (parsed.error) return `Error: ${parsed.error}`;
+  const { regex, body, flags } = parsed;
 
-  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-    try {
-      return JSON.stringify(JSON.parse(trimmed), null, 2);
-    } catch (error) {
-      return trimmed;
-    }
+  const startPath = typeof startPathValue === 'string' && startPathValue.trim() ? startPathValue.trim() : '.';
+  const resolvedStart = resolveToolPath(startPath);
+  if (!fs.existsSync(resolvedStart)) {
+    return `Error: ${startPath} does not exist`;
   }
 
-  if (trimmed.startsWith('<') || trimmed.toLowerCase().includes('<html')) {
-    return htmlToText(trimmed);
-  }
+  const includeList = String(includeValue ?? '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
 
-  return trimmed;
-}
+  const useChunks = chunkingEnabled();
+  const ctxLines = chunkingContextLines();
+  const maxChunksFile = chunkingMaxPerFile();
 
-function keywordRecallMemory(query, embeddings, topK = 3) {
-  const queryText = String(query ?? '').trim().toLowerCase();
-  if (!queryText || !embeddings?.chunks?.length) return [];
+  const MAX_MATCHES = 80;
+  const MAX_FILES_SCANNED = 2000;
+  const MAX_FILE_BYTES = 512 * 1024; // 512KB — skip huge files
+  const MAX_LINE_PREVIEW = 240;
 
-  const queryWords = Array.from(new Set(
-    queryText.split(/[^a-z0-9_]+/i).map(word => word.trim()).filter(word => word.length >= 2)
-  ));
-  const maxScore = Math.max(1, 4 + queryWords.length);
+  const matches = [];
+  const chunkBlocks = []; // { file, start, end, body }
+  let filesScanned = 0;
+  let filesMatched = 0;
+  let truncated = false;
 
-  return embeddings.chunks
-    .map((chunk) => {
-      const text = String(chunk?.text ?? '');
-      const lowered = text.toLowerCase();
-      let score = 0;
-      if (lowered.includes(queryText)) score += 4;
-      for (const word of queryWords) {
-        if (lowered.includes(word)) score += 1;
-      }
-      return { ...chunk, score: Math.min(1, score / maxScore) };
-    })
-    .filter(chunk => chunk.score > 0)
-    .sort((a, b) => b.score - a.score || (b.timestamp || 0) - (a.timestamp || 0))
-    .slice(0, topK);
-}
+  const visit = (dirPath, displayPrefix = '') => {
+    if (truncated) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch { return; }
 
-const tools = {
-  read: (path) => {
-    const trimmedPath = typeof path === 'string' ? path.trim() : '';
-    if (!trimmedPath) return 'Error reading file: missing file path';
+    for (const entry of entries) {
+      if (truncated) return;
+      if (entry.name.startsWith('.')) continue;
+      if (shouldIgnore(entry.name)) continue;
+
+      const fullPath = join(dirPath, entry.name);
+      const relativePath = displayPrefix ? `${displayPrefix}/${entry.name}` : entry.name;
+      if (shouldIgnore(relativePath)) continue;
+
+      if (entry.isDirectory()) {
+        visit(fullPath, relativePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!isLikelyTextFile(entry.name)) continue;
+      if (!matchesIncludeFilter(relativePath, includeList)) continue;
+
+      filesScanned++;
+      if (filesScanned > MAX_FILES_SCANNED) { truncated = true; return; }
+
+      let stat;
+      try { stat = fs.statSync(fullPath); } catch { continue; }
+      if (stat.size > MAX_FILE_BYTES) continue;
+
+      let content;
+      try { content = fs.readFileSync(fullPath, 'utf8'); } catch { continue; }
+
+      const lines = content.split('\n');
+      let fileMatchCount = 0;
+      const fileMatchLines = []; // 1-based line numbers of hits in this file
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        regex.lastIndex = 0;
+        const m = line.match(regex);
+        if (!m) continue;
+
+        const col = (m.index ?? 0) + 1;
+        let preview = line.trim();
+        if (preview.length > MAX_LINE_PREVIEW) {
+          preview = `${preview.slice(0, MAX_LINE_PREVIEW)}…`;
+        }
+        let entryLine = `${relativePath}:${i + 1}:${col}: ${preview}`;
+        if (m.length > 1) {
+          const groups = m.slice(1).map((g, idx) => `$${idx + 1}=${g === undefined ? '∅' : JSON.stringify(g)}`).join(' ');
+          entryLine += `\n    └─ ${groups}`;
+        }
+        matches.push(entryLine);
+        fileMatchLines.push(i + 1);
+        fileMatchCount++;
+
+        if (matches.length >= MAX_MATCHES) { truncated = true; break; }
+        if (fileMatchCount >= 10) break; // Cap per-file noise
+      }
+      if (fileMatchCount > 0) filesMatched++;
+
+      // Group nearby matches into chunk windows (lines ± ctxLines)
+      if (useChunks && fileMatchLines.length > 0) {
+        const groups = [];
+        let curStart = Math.max(1, fileMatchLines[0] - ctxLines);
+        let curEnd = Math.min(lines.length, fileMatchLines[0] + ctxLines);
+        for (let k = 1; k < fileMatchLines.length; k++) {
+          const ln = fileMatchLines[k];
+          const winStart = Math.max(1, ln - ctxLines);
+          const winEnd = Math.min(lines.length, ln + ctxLines);
+          if (winStart <= curEnd + 1) {
+            curEnd = Math.max(curEnd, winEnd);
+          } else {
+            groups.push([curStart, curEnd]);
+            curStart = winStart;
+            curEnd = winEnd;
+            if (groups.length >= maxChunksFile) break;
+          }
+        }
+        if (groups.length < maxChunksFile) groups.push([curStart, curEnd]);
+
+        const gutterWidthMax = String(lines.length).length;
+        for (const [s, e] of groups.slice(0, maxChunksFile)) {
+          const sliceText = lines.slice(s - 1, e).map((ln, idx) => {
+            const num = String(s + idx).padStart(gutterWidthMax, ' ');
+            return `${num} | ${ln}`;
+          }).join('\n');
+          chunkBlocks.push({ file: relativePath, start: s, end: e, body: sliceText });
+        }
+      }
+    }
+  };
+
+  let startStat;
+  try { startStat = fs.statSync(resolvedStart); } catch (e) { return `Error: ${e.message}`; }
+  if (startStat.isFile()) {
+    visit(dirname(resolvedStart), '');
+  } else {
+    visit(resolvedStart);
+  }
+
+  if (matches.length === 0) {
+    return `No regex matches for /${body}/${flags}${includeList.length ? ` (filter: ${includeList.join(',')})` : ''}\nFiles scanned: ${filesScanned}`;
+  }
+
+  const header = `Found ${matches.length}${truncated ? '+' : ''} match${matches.length === 1 ? '' : 'es'} for /${body}/${flags}` +
+    ` in ${filesMatched} file${filesMatched === 1 ? '' : 's'} (scanned ${filesScanned})` +
+    `${includeList.length ? ` · filter: ${includeList.join(',')}` : ''}` +
+    `${useChunks ? ` · chunked ±${ctxLines} lines` : ''}`;
+  const footer = truncated ? `\n... (results truncated at ${MAX_MATCHES} matches)` : '';
+
+  let output = `${header}\n${matches.join('\n')}${footer}`;
+
+  if (useChunks && chunkBlocks.length > 0) {
+    const MAX_TOTAL_CHUNKS = 25;
+    const shown = chunkBlocks.slice(0, MAX_TOTAL_CHUNKS);
+    const chunkText = shown.map(c =>
+      `── ${c.file}:${c.start}-${c.end} ──\n${c.body}`
+    ).join('\n\n');
+    const chunkFooter = chunkBlocks.length > shown.length
+      ? `\n\n... (${chunkBlocks.length - shown.length} more chunk(s) omitted — narrow the pattern or use read_chunk for specific ranges)`
+      : '';
+    output += `\n\n=== Code chunks (±${ctxLines} lines of context) ===\n${chunkText}${chunkFooter}`;
+  }
+
+  return output;
+}
+
+function truncateToolText(textValue = '', maxChars = 24000) {
+  const text = String(textValue ?? '').trim();
+  if (!text) return '';
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n... (output truncated at ${maxChars.toLocaleString()} chars)`;
+}
+
+function shellQuote(value = '') {
+  return `'${String(value ?? '').replace(/'/g, `'\\''`)}'`;
+}
+
+// ─────────────────────────────────────────────────────────────────
+// VOICE INPUT (Whisper)
+// Uses whisper.cpp `whisper-cli` for transcription and ffmpeg (or
+// sox) to capture from the microphone. Triggered by /voice.
+// ─────────────────────────────────────────────────────────────────
+function recordAudioToFile(outPath, { seconds, recorder, device, sampleRate }) {
+  return new Promise((resolve) => {
+    let cmd, args;
+    if (recorder === 'sox') {
+      // `rec` reads from default mic
+      cmd = 'rec';
+      args = ['-q', '-c', '1', '-r', String(sampleRate), outPath, 'trim', '0', String(seconds)];
+    } else {
+      // ffmpeg + avfoundation on macOS, alsa on linux. We default to macOS-style ':0'.
+      const platform = process.platform;
+      const inputFmt = platform === 'darwin' ? 'avfoundation'
+                      : platform === 'linux' ? 'alsa'
+                      : 'dshow';
+      cmd = 'ffmpeg';
+      args = [
+        '-loglevel', 'error',
+        '-y',
+        '-f', inputFmt,
+        '-i', device,
+        '-t', String(seconds),
+        '-ar', String(sampleRate),
+        '-ac', '1',
+        outPath,
+      ];
+    }
+    const proc = spawn(cmd, args);
+    let stderr = '';
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+    proc.on('error', (err) => resolve({ ok: false, error: `Failed to start ${cmd}: ${err.message}` }));
+    proc.on('close', (code) => {
+      if (code === 0 && fs.existsSync(outPath)) resolve({ ok: true });
+      else resolve({ ok: false, error: stderr.trim() || `${cmd} exited with code ${code}` });
+    });
+  });
+}
+
+// Push-to-stop recording: records until the user presses any key (or Ctrl-C).
+// Returns { ok, error?, durationMs }.
+function recordAudioUntilKey(outPath, { recorder, device, sampleRate, maxSeconds = 600 }) {
+  return new Promise((resolve) => {
+    let cmd, args;
+    const platform = process.platform;
+    if (recorder === 'sox') {
+      cmd = 'rec';
+      args = ['-q', '-c', '1', '-r', String(sampleRate), outPath, 'trim', '0', String(maxSeconds)];
+    } else {
+      const inputFmt = platform === 'darwin' ? 'avfoundation'
+                      : platform === 'linux' ? 'alsa'
+                      : 'dshow';
+      cmd = 'ffmpeg';
+      args = [
+        '-loglevel', 'error',
+        '-y',
+        '-f', inputFmt,
+        '-i', device,
+        '-t', String(maxSeconds),
+        '-ar', String(sampleRate),
+        '-ac', '1',
+        outPath,
+      ];
+    }
+
+    const proc = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    // Pause readline so its keypress listeners don't eat our input.
+    const rlWasPaused = rl ? rl.paused : true;
+    try { if (rl && !rl.paused) rl.pause(); } catch {}
+
+    const wasRaw = !!process.stdin.isRaw;
+    let listenerAttached = false;
+    let stopped = false;
+    const startTs = Date.now();
+
+    const cleanupStdin = () => {
+      try { process.stdin.removeListener('data', onKey); } catch {}
+      try { if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw); } catch {}
+      listenerAttached = false;
+    };
+
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      cleanupStdin();
+      if (recorder === 'sox') {
+        try { proc.kill('SIGINT'); } catch {}
+      } else {
+        // ffmpeg: send 'q' on stdin for a clean shutdown (writes a valid WAV).
+        try { proc.stdin.write('q'); } catch {}
+        // Hard-stop fallback if it doesn't exit on its own.
+        const t = setTimeout(() => { try { proc.kill('SIGINT'); } catch {} }, 1500);
+        if (t.unref) t.unref();
+      }
+    };
+
+    const onKey = (chunk) => {
+      // Ctrl-C → also stop (and let SIGINT bubble below via parent handlers)
+      stop();
+    };
+
+    // Ticker
+    let tickInterval = null;
+    const drawTick = () => {
+      const elapsed = ((Date.now() - startTs) / 1000).toFixed(1);
+      process.stdout.write('\r' + chalk.red('🔴 ') + chalk.cyan(`Recording ${elapsed}s  `) + chalk.gray('— press any key to stop'));
+    };
+    const clearTick = () => {
+      if (tickInterval) { clearInterval(tickInterval); tickInterval = null; }
+      // Clear the status line
+      process.stdout.write('\r' + ' '.repeat(70) + '\r');
+    };
+
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', onKey);
+        listenerAttached = true;
+        drawTick();
+        tickInterval = setInterval(drawTick, 100);
+      } else {
+        console.log(chalk.yellow(`No TTY — recording up to ${maxSeconds}s then auto-stopping.`));
+      }
+    } catch {}
+
+    proc.on('error', (err) => {
+      clearTick();
+      cleanupStdin();
+      try { if (rl && !rlWasPaused) rl.resume(); } catch {}
+      resolve({ ok: false, error: `Failed to start ${cmd}: ${err.message}` });
+    });
+
+    proc.on('close', (code) => {
+      clearTick();
+      cleanupStdin();
+      try { if (rl && !rlWasPaused) rl.resume(); } catch {}
+      const durationMs = Date.now() - startTs;
+      // ffmpeg sometimes exits non-zero when killed; accept if the file exists and isn't tiny.
+      const fileOk = fs.existsSync(outPath) && (() => {
+        try { return fs.statSync(outPath).size > 1000; } catch { return false; }
+      })();
+      if (fileOk || (code === 0 && fs.existsSync(outPath))) {
+        return resolve({ ok: true, durationMs });
+      }
+      resolve({ ok: false, error: stderr.trim() || `${cmd} exited with code ${code}` });
+    });
+  });
+}
+
+function runWhisperCli(audioPath, { whisperBin, model, language, translate }) {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(model)) {
+      return resolve({ ok: false, error: `Whisper model not found: ${model}` });
+    }
+    if (!fs.existsSync(audioPath)) {
+      return resolve({ ok: false, error: `Audio file not found: ${audioPath}` });
+    }
+
+    // whisper-cli writes <audio>.txt next to the input when --output-txt is set.
+    const outTxt = `${audioPath}.txt`;
+    try { if (fs.existsSync(outTxt)) fs.unlinkSync(outTxt); } catch {}
+
+    const args = [
+      '-m', model,
+      '-f', audioPath,
+      '-l', language || 'auto',
+      '-nt',                  // no timestamps
+      '-np',                  // no progress / debug prints
+      '-sns',                 // suppress non-speech tokens (kills "you"/"Thank you" hallucinations)
+      '--no-fallback',        // don't escalate temperature into garbage
+      '--temperature', '0',   // deterministic decoding
+      '-bs', '5',             // beam search
+      '-bo', '5',             // best-of
+      '--output-txt',         // write <audio>.txt
+    ];
+    if (translate) args.push('-tr');
+
+    const proc = spawn(whisperBin, args);
+    let stderr = '';
+    let stdout = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+    proc.on('error', (err) => resolve({ ok: false, error: `Failed to start ${whisperBin}: ${err.message}` }));
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        return resolve({ ok: false, error: stderr.trim() || `${whisperBin} exited with code ${code}` });
+      }
+      let text = '';
+      try {
+        if (fs.existsSync(outTxt)) text = fs.readFileSync(outTxt, 'utf8');
+      } catch {}
+      if (!text.trim()) text = stdout; // fallback
+      try { if (fs.existsSync(outTxt)) fs.unlinkSync(outTxt); } catch {}
+      // Strip whisper's silence/non-speech markers, timestamps, and common
+      // hallucinations that surface on silence (multilingual).
+      let cleaned = text
+        .replace(/\r/g, '')
+        .replace(/\[\d{2}:\d{2}:\d{2}\.\d{3}\s*-->\s*\d{2}:\d{2}:\d{2}\.\d{3}\]/g, '')
+        .replace(/\[BLANK_AUDIO\]/gi, '')
+        .replace(/\(.*?silence.*?\)/gi, '')
+        // Common subtitle/end-card hallucinations Whisper learned from training data:
+        .replace(/Продолжение следует\.{0,3}/gi, '')
+        .replace(/Thanks? for watching!?/gi, '')
+        .replace(/Subtitles by[^\n.]*/gi, '')
+        .replace(/Subtitles? (made|provided) by[^\n.]*/gi, '')
+        .replace(/ترجمة[^\n.]*/g, '')
+        .replace(/字幕[^\n。]*/g, '')
+        .replace(/시청해주셔서 감사합니다/g, '')
+        .replace(/ご視聴ありがとうございました/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+      // If the entire result is just a bare hallucination word, drop it.
+      const HALLUCINATION_WHOLE = /^(you|thanks?|thank you\.?|okay\.?|um\.?|uh\.?|\.+|bye\.?|hi\.?)$/i;
+      if (HALLUCINATION_WHOLE.test(cleaned)) cleaned = '';
+      resolve({ ok: true, text: cleaned });
+    });
+  });
+}
+
+// Live transcription using whisper-stream. Streams partial text to the terminal
+// as the user is speaking. Press any key to stop. Returns the cleaned full
+// transcript on stop.
+function runWhisperLive({ whisperStreamBin, model, language, translate, stepMs, lengthMs, keepMs }) {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(model)) {
+      return resolve({ ok: false, error: `Whisper model not found: ${model}` });
+    }
+
+    // We ALWAYS save audio in live mode. The streamed text is for live preview
+    // only — the final transcript comes from a single clean whisper-cli pass on
+    // the saved audio (no overlap-induced duplicates).
+    const saStartTs = Date.now();
+    const saTmpDir = fs.mkdtempSync(join(os.tmpdir(), 'sapper-live-sa-'));
+
+    const args = [
+      '-m', model,
+      '-c', '-1',                // default capture device
+      '--step', String(stepMs),
+      '--length', String(lengthMs),
+      '--keep', String(keepMs),
+      '-l', language || 'auto',  // whisper-stream supports 'auto' (real-time language detection)
+      '--keep-context',
+      '-sa',                     // save the captured audio (we'll re-transcribe it)
+    ];
+    if (translate) args.push('-tr');
+
+    let proc;
+    try {
+      proc = spawn(whisperStreamBin, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: saTmpDir,
+      });
+    } catch (err) {
+      try { fs.rmSync(saTmpDir, { recursive: true, force: true }); } catch {}
+      return resolve({ ok: false, error: `Failed to start ${whisperStreamBin}: ${err.message}` });
+    }
+
+    // Pause readline so its keypress listeners don't eat our key.
+    const rlWasPaused = rl ? rl.paused : true;
+    try { if (rl && !rl.paused) rl.pause(); } catch {}
+
+    const wasRaw = !!process.stdin.isRaw;
+    let stopped = false;
+    let stderr = '';
+    let initSeen = false;
+
+    // Print a header banner
+    console.log();
+    console.log(chalk.red('🔴 ') + chalk.cyan('Live preview ') + chalk.gray('— press any key to stop. Final transcript will be cleaner.'));
+    if (!language || language === 'auto') {
+      console.log(chalk.yellow('  💡 Tip: lock language for much better quality, e.g. ') + chalk.white('/v lang ar') + chalk.yellow(' (Arabic) or ') + chalk.white('/v lang en'));
+    } else {
+      console.log(chalk.gray(`  language: ${language}`));
+    }
+    console.log(chalk.gray('─'.repeat(Math.min(70, process.stdout.columns || 70))));
+
+    const cleanupStdin = () => {
+      try { process.stdin.removeListener('data', onKey); } catch {}
+      try { if (process.stdin.isTTY) process.stdin.setRawMode(wasRaw); } catch {}
+    };
+
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      cleanupStdin();
+      try { proc.kill('SIGINT'); } catch {}
+      // Hard-kill if it lingers
+      const t = setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, 1500);
+      if (t.unref) t.unref();
+    };
+
+    const onKey = () => { stop(); };
+
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', onKey);
+      }
+    } catch {}
+
+    // Filter whisper-stream output for live preview only (we discard it later).
+    const isNoise = (line) => {
+      const s = line.trim();
+      if (!s) return true;
+      if (/^ggml_|^load_backend:|^whisper_|^main:|^init:|^system_info:/i.test(s)) return true;
+      if (/^\[Start speaking\]/i.test(s)) return true;
+      if (/^processing|^n_new_line|^n_threads|^step_ms|^length_ms|^keep_ms|^vad_thold|^freq_thold/i.test(s)) return true;
+      if (/^use gpu|^flash attn|^audio_ctx|^model: |^translate|^language/i.test(s)) return true;
+      return false;
+    };
+
+    // Show only the LAST line of each chunk (collapse the overlap visually).
+    let lastShown = '';
+    proc.stdout.on('data', (chunk) => {
+      const text = chunk.toString();
+      const lines = text.split(/\r?\n/).map(l => l.trim()).filter(l => l && !isNoise(l));
+      if (lines.length === 0) return;
+      initSeen = true;
+      const latest = lines[lines.length - 1];
+      // Skip the dummy [BLANK_AUDIO] markers
+      if (/^\[?BLANK_AUDIO\]?$/i.test(latest)) return;
+      if (latest === lastShown) return;
+      lastShown = latest;
+      process.stdout.write(chalk.white('  ' + latest) + '\n');
+    });
+
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      cleanupStdin();
+      try { if (rl && !rlWasPaused) rl.resume(); } catch {}
+      try { fs.rmSync(saTmpDir, { recursive: true, force: true }); } catch {}
+      resolve({ ok: false, error: `Failed to start ${whisperStreamBin}: ${err.message}` });
+    });
+
+    proc.on('close', () => {
+      cleanupStdin();
+      try { if (rl && !rlWasPaused) rl.resume(); } catch {}
+
+      console.log(chalk.gray('─'.repeat(Math.min(70, process.stdout.columns || 70))));
+
+      // Locate the audio file produced by -sa (named like 20260605104159.wav).
+      let savedAudio = null;
+      try {
+        const files = fs.readdirSync(saTmpDir)
+          .filter(f => f.toLowerCase().endsWith('.wav'))
+          .map(f => ({ f, full: join(saTmpDir, f), mtime: fs.statSync(join(saTmpDir, f)).mtimeMs, size: fs.statSync(join(saTmpDir, f)).size }))
+          .filter(x => x.mtime >= saStartTs - 1000 && x.size > 1000)
+          .sort((a, b) => b.mtime - a.mtime);
+        if (files.length) savedAudio = files[0].full;
+      } catch {}
+
+      if (!savedAudio) {
+        try { fs.rmSync(saTmpDir, { recursive: true, force: true }); } catch {}
+        const errMsg = stderr.trim().split('\n').slice(-3).join('\n') || 'no audio was captured';
+        return resolve({ ok: false, error: errMsg });
+      }
+
+      resolve({ ok: true, audioPath: savedAudio, audioTmpDir: saTmpDir });
+    });
+  });
+}
+
+// Save a recording (audio + transcript) under voice.archiveDir/YYYY-MM-DD/.
+// Returns { ok, audio?, transcript?, error? } with the final saved paths.
+function archiveVoiceRecording({ sourceAudio, transcript, mode = 'record', extHint = null } = {}) {
+  try {
+    const cfg = getVoiceConfig();
+    if (!cfg.archive) return { ok: false, error: 'archiving disabled' };
+
+    const baseDir = isAbsolute(cfg.archiveDir)
+      ? cfg.archiveDir
+      : pathResolve(getToolWorkingDirectory(), cfg.archiveDir);
+
+    const now = new Date();
+    const yyyy = now.getFullYear();
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    const hh = String(now.getHours()).padStart(2, '0');
+    const mi = String(now.getMinutes()).padStart(2, '0');
+    const ss = String(now.getSeconds()).padStart(2, '0');
+    const dayDir = join(baseDir, `${yyyy}-${mm}-${dd}`);
+    fs.mkdirSync(dayDir, { recursive: true });
+
+    const stamp = `${hh}${mi}${ss}`;
+    const safeMode = String(mode).replace(/[^a-z0-9_-]/gi, '');
+    const baseName = `${stamp}-${safeMode}`;
+
+    let audioOut = null;
+    if (sourceAudio && fs.existsSync(sourceAudio)) {
+      const ext = extHint || extname(sourceAudio) || '.wav';
+      audioOut = join(dayDir, `${baseName}${ext}`);
+      try {
+        fs.copyFileSync(sourceAudio, audioOut);
+      } catch (err) {
+        // Fall back to rename if same FS
+        try { fs.renameSync(sourceAudio, audioOut); } catch { audioOut = null; }
+      }
+    }
+
+    let txtOut = null;
+    const cleanTranscript = (transcript || '').trim();
+    if (cleanTranscript) {
+      txtOut = join(dayDir, `${baseName}.txt`);
+      try {
+        fs.writeFileSync(txtOut, cleanTranscript + '\n', 'utf8');
+      } catch { txtOut = null; }
+    }
+
+    return { ok: true, audio: audioOut, transcript: txtOut, dir: dayDir };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function transcribeAudio({ audioFile = null, seconds = null, pushToStop = false, mode = null } = {}) {
+  const cfg = getVoiceConfig();
+  if (!cfg.enabled) return { ok: false, error: 'Voice input is disabled in config (voice.enabled = false). Re-enable with /voice on.' };
+  if (!cfg.model) return { ok: false, error: 'No Whisper model configured. Set one with /voice model <path-to-ggml.bin>.' };
+
+  let audioPath = audioFile;
+  let cleanupAudio = false;
+
+  if (!audioPath) {
+    audioPath = join(os.tmpdir(), `sapper-voice-${Date.now()}.wav`);
+    cleanupAudio = true;
+
+    let rec;
+    if (pushToStop) {
+      // Push-to-stop: ticker + key-press handling are rendered inside the helper.
+      rec = await recordAudioUntilKey(audioPath, {
+        recorder: cfg.recorder,
+        device: cfg.device,
+        sampleRate: cfg.sampleRate,
+        maxSeconds: 600,
+      });
+    } else {
+      const dur = Math.max(1, Math.min(300, Number(seconds) || cfg.recordSeconds));
+      const recIntro = uiCleanMode()
+        ? chalk.cyan(`Recording ${dur}s from ${cfg.recorder} (${cfg.device}) ...`)
+        : chalk.cyan(`🎙️  Recording ${dur}s from ${cfg.recorder} (${cfg.device}) ...`);
+      console.log(recIntro);
+      rec = await recordAudioToFile(audioPath, {
+        seconds: dur,
+        recorder: cfg.recorder,
+        device: cfg.device,
+        sampleRate: cfg.sampleRate,
+      });
+    }
+
+    if (!rec.ok) {
+      try { if (fs.existsSync(audioPath)) fs.unlinkSync(audioPath); } catch {}
+      return { ok: false, error: `Recording failed: ${rec.error}` };
+    }
+  }
+
+  const transSpinner = ora(chalk.cyan(`Transcribing with ${cfg.whisperBin} (${cfg.model.split('/').pop()})...`)).start();
+  const result = await runWhisperCli(audioPath, {
+    whisperBin: cfg.whisperBin,
+    model: cfg.model,
+    language: cfg.language,
+    translate: cfg.translate,
+  });
+  transSpinner.stop();
+
+  // Archive the recording (audio + transcript) before cleaning up the temp file.
+  let archived = null;
+  if (result.ok && cfg.archive) {
+    const archiveMode = mode || (audioFile ? 'file' : (pushToStop ? 'talk' : 'record'));
+    archived = archiveVoiceRecording({
+      sourceAudio: audioPath,
+      transcript: result.text,
+      mode: archiveMode,
+    });
+    if (archived && archived.ok) {
+      const where = archived.audio || archived.transcript;
+      if (where) console.log(UI.slate(`  Archived → ${where.replace(getToolWorkingDirectory() + '/', '')}`));
+    }
+  }
+
+  if (cleanupAudio) {
+    try { if (fs.existsSync(audioPath)) fs.unlinkSync(audioPath); } catch {}
+  }
+  return { ...result, archived };
+}
+
+function runCapturedCommand(command, { cwd = getToolWorkingDirectory(), timeoutMs = 12000, maxOutput = 24000 } = {}) {
+  return new Promise((resolve) => {
+    const proc = spawn('sh', ['-c', command], { cwd });
+    let stdout = '';
+    let stderr = '';
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let finished = false;
+
+    const appendLimited = (existing, chunkText, maxChars, setTruncated) => {
+      if (existing.length >= maxChars) {
+        setTruncated(true);
+        return existing;
+      }
+      const remaining = maxChars - existing.length;
+      if (chunkText.length > remaining) {
+        setTruncated(true);
+        return existing + chunkText.slice(0, remaining);
+      }
+      return existing + chunkText;
+    };
+
+    const finish = (result) => {
+      if (finished) return;
+      finished = true;
+      if (timer) clearTimeout(timer);
+      const finalStdout = stdoutTruncated
+        ? `${stdout}\n... (stdout truncated at ${maxOutput.toLocaleString()} chars)`
+        : stdout;
+      const finalStderr = stderrTruncated
+        ? `${stderr}\n... (stderr truncated at ${maxOutput.toLocaleString()} chars)`
+        : stderr;
+      resolve({ ...result, stdout: finalStdout, stderr: finalStderr });
+    };
+
+    const timer = timeoutMs > 0
+      ? setTimeout(() => {
+          try { proc.kill('SIGTERM'); } catch (e) {}
+          finish({ exitCode: 124, stdout, stderr: `${stderr}\nCommand timed out after ${timeoutMs}ms`.trim(), timedOut: true });
+        }, timeoutMs)
+      : null;
+
+    proc.stdout.on('data', (data) => {
+      stdout = appendLimited(stdout, data.toString(), maxOutput, (value) => { stdoutTruncated = value; });
+    });
+    proc.stderr.on('data', (data) => {
+      stderr = appendLimited(stderr, data.toString(), maxOutput, (value) => { stderrTruncated = value; });
+    });
+
+    proc.on('error', (error) => {
+      finish({ exitCode: 1, stdout, stderr: `${stderr}\n${error.message}`.trim(), timedOut: false });
+    });
+    proc.on('close', (code) => {
+      finish({ exitCode: code ?? 0, stdout, stderr, timedOut: false });
+    });
+  });
+}
+
+function normalizeFetchedWebContent(rawContent = '') {
+  const trimmed = String(rawContent ?? '').trim();
+  if (!trimmed) return '';
+
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      return JSON.stringify(JSON.parse(trimmed), null, 2);
+    } catch (error) {
+      return trimmed;
+    }
+  }
+
+  if (trimmed.startsWith('<') || trimmed.toLowerCase().includes('<html')) {
+    return htmlToText(trimmed);
+  }
+
+  return trimmed;
+}
+
+function keywordRecallMemory(query, embeddings, topK = 3) {
+  const queryText = String(query ?? '').trim().toLowerCase();
+  if (!queryText || !embeddings?.chunks?.length) return [];
+
+  const queryWords = Array.from(new Set(
+    queryText.split(/[^a-z0-9_]+/i).map(word => word.trim()).filter(word => word.length >= 2)
+  ));
+  const maxScore = Math.max(1, 4 + queryWords.length);
+
+  return embeddings.chunks
+    .map((chunk) => {
+      const text = String(chunk?.text ?? '');
+      const lowered = text.toLowerCase();
+      let score = 0;
+      if (lowered.includes(queryText)) score += 4;
+      for (const word of queryWords) {
+        if (lowered.includes(word)) score += 1;
+      }
+      return { ...chunk, score: Math.min(1, score / maxScore) };
+    })
+    .filter(chunk => chunk.score > 0)
+    .sort((a, b) => b.score - a.score || (b.timestamp || 0) - (a.timestamp || 0))
+    .slice(0, topK);
+}
+
+const tools = {
+  read: (path) => {
+    const trimmedPath = typeof path === 'string' ? path.trim() : '';
+    if (!trimmedPath) return 'Error reading file: missing file path';
     try { return fs.readFileSync(resolveToolPath(trimmedPath), 'utf8'); } 
     catch (error) { return `Error reading file: ${error.message}`; }
   },
@@ -4191,7 +5697,7 @@ const tools = {
         `${UI.slate('This will permanently delete the directory and its contents.')}`,
         'Directory Removal', 'red'
       ));
-      const confirm = await safeQuestion(confirmPrompt('Remove directory', 'error'));
+      const confirm = await safeQuestion(confirmPrompt(promptLabel('questions.removeDirectory', 'Remove directory'), 'error'));
       if (!['y', 'yes'].includes(String(confirm ?? '').trim().toLowerCase())) {
         return 'Directory removal blocked by user.';
       }
@@ -4208,6 +5714,8 @@ const tools = {
   tail: (path, lines) => readFileLineWindow(path, 'tail', lines),
   grep: (pattern) => tools.search(pattern),
   find: (pattern, startPath) => findPathsByName(pattern, startPath),
+  regex: (pattern, include, startPath) => regexSearch(pattern, include, startPath),
+  read_chunk: (path, start, end, context) => readChunk(path, start, end, context),
   changes: async (path) => {
     const trimmedPath = typeof path === 'string' ? path.trim() : '';
     const cwd = getToolWorkingDirectory();
@@ -4299,6 +5807,39 @@ const tools = {
 
     return `Found ${relevant.length} memory match${relevant.length === 1 ? '' : 'es'} for: ${trimmedQuery}\n\n${formatted}`;
   },
+  save_memory_note: async (title, content, tags) => {
+    const result = appendLongMemoryNote({
+      title,
+      content,
+      tags,
+      source: 'assistant-tool',
+    });
+    if (!result.ok) {
+      return `Error saving memory note: ${result.error}`;
+    }
+    const tagText = result.tags.length ? ` [${result.tags.join(', ')}]` : '';
+    return `Saved memory note: ${result.title}${tagText} (${result.timestamp}) in ${result.path}`;
+  },
+  search_memory_notes: async (query) => {
+    const cleanQuery = String(query ?? '').trim();
+    if (!cleanQuery) return 'Error searching memory notes: missing query';
+
+    const matches = searchLongMemoryNotes(cleanQuery, 5);
+    if (!matches.length) {
+      return `No markdown long-memory notes found for: ${cleanQuery}`;
+    }
+
+    const formatted = matches.map((note, index) => {
+      const preview = truncateToolText(note, 900);
+      return `[${index + 1}]\n${preview}`;
+    }).join('\n\n');
+
+    return `Found ${matches.length} markdown note match${matches.length === 1 ? '' : 'es'} for: ${cleanQuery}\n\n${formatted}`;
+  },
+  read_memory_notes: async () => {
+    const text = loadLongMemoryText();
+    return truncateToolText(text, 28000);
+  },
   open_url: async (url) => {
     const trimmedUrl = String(url ?? '').trim();
     if (!trimmedUrl) return 'Error opening URL: missing URL';
@@ -4312,7 +5853,7 @@ const tools = {
       `${UI.slate('This will open the URL in your default browser.')}`,
       'Open URL', 'red'
     ));
-    const confirm = await safeQuestion(confirmPrompt('Open URL in browser', 'error'));
+    const confirm = await safeQuestion(confirmPrompt(promptLabel('questions.openUrlInBrowser', 'Open URL in browser'), 'error'));
     if (!['y', 'yes'].includes(String(confirm ?? '').trim().toLowerCase())) {
       return 'Open URL blocked by user.';
     }
@@ -4357,7 +5898,7 @@ const tools = {
       'Shell Approval', 'red'
     ));
     while (true) {
-      const confirmInput = await safeQuestion(confirmPrompt('Run shell command', 'error', '[y/N/f/e or text] '));
+      const confirmInput = await safeQuestion(confirmPrompt(promptLabel('questions.runShellCommand', 'Run shell command'), 'error', '[y/N/f/e or text] '));
       const confirmRaw = String(confirmInput ?? '').trim();
       const confirm = confirmRaw.toLowerCase();
 
@@ -4449,8 +5990,8 @@ const tools = {
       }
 
       const approvalInstruction = await resolveApprovalInstruction(confirmRaw, {
-        feedbackPrompt: 'Feedback for this command: ',
-        editPrompt: 'Edit instruction for this command: ',
+        feedbackPrompt: promptLabel('questions.feedbackForSapper', 'Feedback for Sapper: '),
+        editPrompt: promptLabel('questions.editInstructionForSapper', 'Edit instruction for Sapper: '),
       });
 
       if (approvalInstruction) {
@@ -4547,10 +6088,25 @@ async function checkForUpdates() {
 
 async function runSapper() {
   console.clear();
-  console.log(BANNER);
-  console.log(`${UI.slate(process.cwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`);
-  console.log(divider());
-  console.log(sectionTitle('Quick start', '@file attach · /help commands · /agents modes', 'gray'));
+  const clean = uiCleanMode();
+  const ultra = uiUltraCleanMode();
+  if (ultra) {
+    console.log(`${chalk.white(promptLabel('ui.bannerTitle', 'Sapper'))} ${UI.slate(`v${CURRENT_VERSION}`)} ${UI.slate(safeCwd())}`);
+    console.log(UI.slate(promptLabel('ui.ultraFrontendHint', 'ultra frontend active  /ui style sapper to switch back')));
+  } else if (clean) {
+    console.log(`${chalk.white(promptLabel('ui.bannerTitle', 'Sapper'))} ${UI.slate(`v${CURRENT_VERSION}`)} ${UI.slate('·')} ${UI.slate(safeCwd())}`);
+    console.log(UI.slate(promptLabel('ui.cleanFrontendHint', 'clean frontend active  ·  /ui style sapper to switch back')));
+    console.log(divider('─', 'gray', terminalWidth(70)));
+  } else {
+    console.log(bannerText());
+    console.log(`${UI.slate(safeCwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`);
+    console.log(divider());
+    console.log(sectionTitle(
+      promptLabel('ui.quickStartTitle', 'Quick Start'),
+      promptLabel('ui.quickStartSubtitle', '@file attach · /commands palette · /agents modes'),
+      'gray'
+    ));
+  }
   console.log();
   
   // Check for updates
@@ -4602,27 +6158,46 @@ async function runSapper() {
     ? Math.max(0, Math.round((Date.now() - new Date(workspace.indexed).getTime()) / 1000 / 60))
     : 0;
   const startupLines = [
-    `${statusBadge('workspace', 'info')} ${chalk.white(`${workspaceFileCount} files`)} ${UI.slate('·')} ${chalk.white(`${workspaceSymbolCount} symbols`)} ${UI.slate('·')} ${UI.slate(`indexed ${workspaceAgeMinutes}m ago`)}`,
-    `${statusBadge('memory', 'neutral')} ${chalk.white('.sapper/')} ${UI.slate('·')} ${UI.slate(`auto-attach ${sapperConfig.autoAttach ? 'on' : 'off'}`)}`,
-    `${statusBadge('prompt', hasCustomPromptConfig() ? 'warning' : 'neutral')} ${UI.slate(hasCustomPromptConfig() ? 'custom prompt on' : 'default prompt')}`,
-    `${statusBadge('thinking', 'neutral')} ${UI.slate(`mode ${thinkingMode()}`)}`,
-    `${statusBadge('tools', 'action')} ${UI.slate(`limit ${toolRoundLimit()} rounds`)}`,
-    `${statusBadge('shell', 'info')} ${UI.slate(`stream ${shellStreamToModelEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`bg ${shellBackgroundMode()}`)} ${UI.slate('·')} ${UI.slate(`${activeShellSessionCount()} active`)}`,
-    `${statusBadge('stream', 'neutral')} ${UI.slate(`heartbeat ${streamHeartbeatEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`phases ${streamPhaseStatusEnabled() ? 'on' : 'off'}`)}`,
-    `${statusBadge('summary', 'info')} ${UI.slate(`phases ${summaryPhasesEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`trigger ${summaryTriggerPercent()}%`)}`,
-    `${statusBadge('agents', 'action')} ${chalk.white(`${agentCount}`)} ${UI.slate('·')} ${statusBadge('skills', 'success')} ${chalk.white(`${skillCount}`)}`,
+    piRow('workspace', `${chalk.white(`${workspaceFileCount} files`)} ${UI.slate('·')} ${chalk.white(`${workspaceSymbolCount} symbols`)} ${UI.slate('·')} ${UI.slate(`indexed ${workspaceAgeMinutes}m ago`)}`),
+    piRow('memory', `${chalk.white('.sapper/')} ${UI.slate('·')} ${UI.slate(`auto-attach ${sapperConfig.autoAttach ? 'on' : 'off'}`)}`),
+    piRow('prompt', UI.slate(hasCustomPromptConfig() ? 'custom prompt on' : 'default prompt')),
+    piRow('thinking', UI.slate(`mode ${thinkingMode()}`)),
+    piRow('tools', UI.slate(`limit ${toolRoundLimit()} rounds`)),
+    piRow('shell', `${UI.slate(`stream ${shellStreamToModelEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`bg ${shellBackgroundMode()}`)} ${UI.slate('·')} ${UI.slate(`${activeShellSessionCount()} active`)}`),
+    piRow('stream', `${UI.slate(`heartbeat ${streamHeartbeatEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`phases ${streamPhaseStatusEnabled() ? 'on' : 'off'}`)}`),
+    piRow('summary', `${UI.slate(`phases ${summaryPhasesEnabled() ? 'on' : 'off'}`)} ${UI.slate('·')} ${UI.slate(`trigger ${summaryTriggerPercent()}%`)}`),
+    piRow('modes', `${chalk.white(`agents ${agentCount}`)} ${UI.slate('·')} ${chalk.white(`skills ${skillCount}`)}`),
   ];
   if (newlyCreated > 0) {
     startupLines.push(UI.slate(`${newlyCreated} default agents or skills created in .sapper/`));
   }
-  console.log(box(startupLines.join('\n'), 'Workspace', 'gray'));
+  if (ultra) {
+    const condensed = [
+      `${chalk.white(`${workspaceFileCount} files`)} ${UI.slate(`${workspaceSymbolCount} symbols`)}`,
+      `${UI.slate('agents')} ${chalk.white(agentCount)} ${UI.slate('skills')} ${chalk.white(skillCount)} ${UI.slate('summary')} ${chalk.white(`${summaryTriggerPercent()}%`)}`,
+    ];
+    if (newlyCreated > 0) condensed.push(UI.slate(`${newlyCreated} defaults created in .sapper/`));
+    console.log(condensed.join('\n'));
+  } else if (clean) {
+    const condensed = [
+      `${chalk.white(`${workspaceFileCount} files`)} ${UI.slate('·')} ${chalk.white(`${workspaceSymbolCount} symbols`)} ${UI.slate('·')} ${UI.slate(`indexed ${workspaceAgeMinutes}m ago`)}`,
+      `${UI.slate('tools')} ${chalk.white(`limit ${toolRoundLimit()}`)} ${UI.slate('·')} ${UI.slate('summary')} ${chalk.white(`${summaryTriggerPercent()}%`)}`,
+      `${UI.slate('modes')} ${chalk.white(`agents ${agentCount}`)} ${UI.slate('·')} ${chalk.white(`skills ${skillCount}`)} ${UI.slate('·')} ${UI.slate('shell')} ${chalk.white(shellBackgroundMode())}`,
+    ];
+    if (newlyCreated > 0) {
+      condensed.push(UI.slate(`${newlyCreated} default agents or skills created in .sapper/`));
+    }
+    console.log(box(condensed.join('\n'), 'Session', 'gray'));
+  } else {
+    console.log(box(startupLines.join('\n'), 'Session Dashboard', 'gray'));
+  }
   console.log();
   
   let messages = [];
   if (fs.existsSync(CONTEXT_FILE)) {
     console.log(divider());
     console.log(UI.ink('Previous session found in .sapper/context.json'));
-    const resume = await safeQuestion(confirmPrompt('Resume session', 'success'));
+    const resume = await safeQuestion(confirmPrompt(promptLabel('questions.resumeSession', 'Resume session'), 'success'));
     if (resume.toLowerCase() === 'y') {
       messages = JSON.parse(fs.readFileSync(CONTEXT_FILE, 'utf8'));
       console.log(chalk.green('  ✓ Session restored\n'));
@@ -4717,9 +6292,9 @@ async function runSapper() {
     contextLabel = `${effectiveCtx.toLocaleString()} tokens (custom limit, model: ${modelContextLength.toLocaleString()})`;
   }
   console.log(box(
-    `${statusBadge('model', 'action')} ${chalk.white.bold(selectedModel)}\n` +
-    `${statusBadge('tools', useNativeTools ? 'success' : 'neutral')} ${UI.ink(toolModeLabel)}\n` +
-    `${statusBadge('context', 'info')} ${UI.ink(contextLabel)}`,
+    `${piRow('model', chalk.white.bold(selectedModel))}\n` +
+    `${piRow('tools', UI.ink(toolModeLabel))}\n` +
+    `${piRow('context', UI.ink(contextLabel))}`,
     'Session', 'cyan'
   ));
   console.log();
@@ -4899,6 +6474,39 @@ async function runSapper() {
         }
       }
     },
+    {
+      type: 'function',
+      function: {
+        name: 'regex_search',
+        description: 'Advanced regex search across source code. Accepts JS-style /pattern/flags or a raw pattern (default flag: case-insensitive). Returns file:line:col with capture groups. Optional filter limits to extensions (js,ts) or path substrings (src/).',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Regex pattern, e.g. "TODO[:\\s]" or "/function\\s+(\\w+)/i"' },
+            include: { type: 'string', description: 'Optional comma-separated extensions (js,ts,py) or path substrings (src/,routes/)' },
+            path: { type: 'string', description: 'Directory to search from (default current tool working directory)' }
+          },
+          required: ['pattern']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'read_chunk',
+        description: 'Read a specific line range from a file (e.g. lines 40-80) instead of the whole file. Use this after regex_search/grep to inspect the surrounding context without loading huge files into context. Always preferred for files larger than ~400 lines.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string', description: 'File path to read' },
+            start: { type: 'number', description: 'Starting line (1-based, inclusive)' },
+            end: { type: 'number', description: 'Ending line (1-based, inclusive). Defaults to start + 60.' },
+            context: { type: 'number', description: 'Extra lines to include above & below the range (default 0)' }
+          },
+          required: ['path', 'start']
+        }
+      }
+    },
     {
       type: 'function',
       function: {
@@ -4979,6 +6587,47 @@ async function runSapper() {
         }
       }
     },
+    {
+      type: 'function',
+      function: {
+        name: 'save_memory_note',
+        description: 'Save a durable markdown note in .sapper/long-memory.md for reusable project patterns, decisions, or fixes.',
+        parameters: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Short title for the note' },
+            content: { type: 'string', description: 'Main note content to store' },
+            tags: { type: 'string', description: 'Optional comma-separated tags like bugfix,cli,pattern' }
+          },
+          required: ['content']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'search_memory_notes',
+        description: 'Search markdown long-memory notes in .sapper/long-memory.md.',
+        parameters: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'Search query for notes' }
+          },
+          required: ['query']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'read_memory_notes',
+        description: 'Read the markdown long-memory file at .sapper/long-memory.md.',
+        parameters: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    },
     {
       type: 'function',
       function: {
@@ -5062,33 +6711,61 @@ async function runSapper() {
       
       // Build prompt label with active agent/skills
       const contextPercent = ctxLen ? Math.round((estimatedTokens / ctxLen) * 100) : null;
-      const promptParts = [
-        statusBadge(selectedModel.split(':')[0] || selectedModel, 'action'),
-        activeAgentPromptBadge(),
-      ];
-      const skillsBadge = activeSkillsPromptBadge();
-      if (skillsBadge) {
-        promptParts.push(skillsBadge);
-      }
-      if (contextPercent !== null) {
-        const tone = contextPercent >= 85 ? 'error' : contextPercent >= 65 ? 'warning' : 'neutral';
-        promptParts.push(statusBadge(`${contextPercent}% ctx`, tone));
-      }
+      const cleanPrompt = uiCleanMode();
+      const ultraPrompt = uiUltraCleanMode();
+      let promptText;
+
+      if (ultraPrompt) {
+        const modelShort = selectedModel.split(':')[0] || selectedModel;
+        const modeBits = [chalk.white(modelShort)];
+        if (currentAgent) modeBits.push(UI.slate(currentAgent));
+        if (contextPercent !== null) modeBits.push(UI.slate(`${contextPercent}%`));
+        promptText = `\n${modeBits.join(' ')} ${UI.accent('> ' )}`;
+      } else if (cleanPrompt) {
+        const modelShort = selectedModel.split(':')[0] || selectedModel;
+        const modeLineParts = [chalk.white(modelShort)];
+        if (currentAgent) {
+          modeLineParts.push(UI.slate(`agent:${currentAgent}`));
+        } else {
+          modeLineParts.push(UI.slate('default'));
+        }
+        if (contextPercent !== null) {
+          modeLineParts.push(UI.slate(`${contextPercent}% ctx`));
+        }
 
-      const promptDetailLines = [ctxLen
-        ? `${meter(estimatedTokens, ctxLen, 24)} ${UI.slate(`${estimatedTokens.toLocaleString()}/${ctxLen.toLocaleString()} tokens`)}`
-        : UI.slate(`${estimatedTokens.toLocaleString()} estimated tokens`)
-      ];
-      const modeSummary = activeModeSummary({ includeAgent: true, maxSkills: 3 });
-      if (modeSummary) {
-        promptDetailLines.push(UI.slate(modeSummary));
+        const detail = ctxLen
+          ? `${meter(estimatedTokens, ctxLen, 16)} ${UI.slate(`${estimatedTokens.toLocaleString()}/${ctxLen.toLocaleString()} tokens`)}`
+          : UI.slate(`${estimatedTokens.toLocaleString()} estimated tokens`);
+        promptText = `\n${UI.slate(modeLineParts.join(' · '))}\n${detail}\n${UI.accent('› ')} `;
+      } else {
+        const promptParts = [
+          statusBadge(selectedModel.split(':')[0] || selectedModel, 'action'),
+          activeAgentPromptBadge(),
+        ];
+        const skillsBadge = activeSkillsPromptBadge();
+        if (skillsBadge) {
+          promptParts.push(skillsBadge);
+        }
+        if (contextPercent !== null) {
+          const tone = contextPercent >= 85 ? 'error' : contextPercent >= 65 ? 'warning' : 'neutral';
+          promptParts.push(statusBadge(`${contextPercent}% ctx`, tone));
+        }
+
+        const promptDetailLines = [ctxLen
+          ? `${meter(estimatedTokens, ctxLen, 24)} ${UI.slate(`${estimatedTokens.toLocaleString()}/${ctxLen.toLocaleString()} tokens`)}`
+          : UI.slate(`${estimatedTokens.toLocaleString()} estimated tokens`)
+        ];
+        const modeSummary = activeModeSummary({ includeAgent: true, maxSkills: 3 });
+        if (modeSummary) {
+          promptDetailLines.push(UI.slate(modeSummary));
+        }
+        const promptDetail = promptDetailLines.join('\n');
+        promptText = `\n${promptShell(promptParts.join(' '), promptDetail)}`;
       }
-      const promptDetail = promptDetailLines.join('\n');
 
-      const promptText = `\n${promptShell(promptParts.join(' '), promptDetail)}`;
-      const input = await safeQuestion(promptText);
+      let input = await safeQuestion(promptText);
       clearPromptEcho(promptText, input);
-      
+
       // Block empty prompts
       if (!input.trim()) {
         continue;
@@ -5140,53 +6817,41 @@ async function runSapper() {
         continue;
       }
       
+      // Handle model switch command
+      if (input.toLowerCase().startsWith('/model')) {
+        const arg = input.slice(6).trim();
+        const modelList = await ollama.list();
+        if (!modelList.models || modelList.models.length === 0) {
+          console.log(chalk.red('No local models found. Pull one with: ollama pull <model>'));
+        } else if (arg) {
+          // Direct name — try exact match then prefix
+          const match = modelList.models.find(m => m.name === arg) ||
+                        modelList.models.find(m => m.name.startsWith(arg));
+          if (match) {
+            selectedModel = match.name;
+            sapperConfig.defaultModel = selectedModel;
+            saveConfig(sapperConfig);
+            console.log(chalk.green(`✅ Switched to ${chalk.bold(selectedModel)}`));
+          } else {
+            console.log(chalk.red(`Model "${arg}" not found locally.`));
+            console.log(chalk.gray('Available: ' + modelList.models.map(m => m.name).join(', ')));
+          }
+        } else {
+          const picked = await pickModel(modelList.models);
+          if (picked) {
+            selectedModel = picked;
+            sapperConfig.defaultModel = selectedModel;
+            saveConfig(sapperConfig);
+            console.log(chalk.green(`\n✅ Switched to ${chalk.bold(selectedModel)}\n`));
+          }
+        }
+        continue;
+      }
+
       // Handle help command
-      if (input.toLowerCase() === '/help') {
+      if (input.toLowerCase() === '/help' || input.toLowerCase() === '/commands' || input.toLowerCase() === '/cmd') {
         console.log();
-        console.log(sectionTitle('Core', 'daily workflow', 'cyan'));
-        console.log(commandRow('@ or /attach', 'Pick files to attach interactively'));
-        console.log(commandRow('@file', 'Attach a file inline, for example @src/app.js'));
-        console.log(commandRow('/scan', 'Scan the codebase into context'));
-        console.log(commandRow('/index', 'Rebuild the workspace graph'));
-        console.log(commandRow('/graph file', 'Show related files from the graph'));
-        console.log(commandRow('/symbol name', 'Search indexed functions and classes'));
-        console.log(commandRow('/auto', 'Toggle automatic related-file attach'));
-        console.log();
-        console.log(sectionTitle('Context', 'memory and visibility', 'cyan'));
-        console.log(commandRow('/recall', 'Search memory for relevant context'));
-        console.log(commandRow('/fetch <url>', 'Fetch a web page into context'));
-        console.log(commandRow('/reset /clear', 'Clear all current context'));
-        console.log(commandRow('/prune', 'Summarize long context and store memory'));
-        console.log(commandRow('/summary', 'Show or change auto-summary settings'));
-        console.log(commandRow('/shell', 'Inspect shell config and background sessions'));
-        console.log(commandRow('/shell read <id>', 'Read output from a tracked shell session'));
-        console.log(commandRow('/shell stop <id>', 'Stop a tracked shell session'));
-        console.log(commandRow('/context', 'Inspect token usage, summary trigger, and model window'));
-        console.log(commandRow('/ctx <limit>', 'Set context window limit (e.g. /ctx 64k)'));
-        console.log(commandRow('/debug', 'Toggle regex and tool debug output'));
-        console.log(commandRow('/log', 'Show the session activity timeline'));
-        console.log(commandRow('/log stats', 'Show session statistics'));
-        console.log(commandRow('/log file', 'Show log file path and history'));
-        console.log(commandRow('/help', 'Open this command view again'));
-        console.log(commandRow('exit', 'Quit Sapper'));
-        console.log(UI.slate('  Summary settings: /summary  |  /summary phases off  |  /summary trigger 60'));
-        console.log(UI.slate('  Tool config: .sapper/config.json -> toolRoundLimit (default 40)'));
-        console.log(UI.slate('  Shell config: .sapper/config.json -> shell.streamToModel, shell.backgroundMode [off|auto|on], shell.backgroundAfterSeconds, shell.outputChunkChars'));
-        console.log(UI.slate('  Want to see all live shell output? Set shell.backgroundMode to off. thinking.mode only controls model reasoning.'));
-        console.log(UI.slate('  Streaming config: .sapper/config.json -> streaming.showPhaseStatus, streaming.showHeartbeat, streaming.idleNoticeSeconds'));
-        console.log(UI.slate('  Thinking config: .sapper/config.json -> thinking.mode [auto|on|off]'));
-        console.log(UI.slate('  Prompt config: .sapper/config.json -> prompt.prepend, prompt.append, prompt.coreOverride'));
-        console.log();
-        console.log(sectionTitle('Agents', 'specialist modes and skills', 'cyan'));
-        console.log(commandRow('/agents', 'List available agents'));
-        console.log(commandRow('/skills', 'List available skills'));
-        console.log(commandRow('/agentname', 'Switch to an agent such as /reviewer'));
-        console.log(commandRow('/default', 'Return to the default Sapper role'));
-        console.log(commandRow('/use skill', 'Load a skill into the session'));
-        console.log(commandRow('/unload skill', 'Unload a previously loaded skill'));
-        console.log(commandRow('/newagent', 'Create a new agent'));
-        console.log(commandRow('/newskill', 'Create a new skill'));
-        console.log(divider());
+        console.log(renderCommandPalette());
         console.log();
         continue;
       }
@@ -5226,12 +6891,14 @@ async function runSapper() {
             `${chalk.cyan('Methods:')} ${methods.length}\n` +
             chalk.gray('─'.repeat(30)) + '\n' +
             chalk.gray('Usage: /symbol <name> to search'),
-            '📦 Symbol Index', 'cyan'
+            uiCleanMode() ? 'Symbol Index' : '📦 Symbol Index', 'cyan'
           ));
           continue;
         }
         
-        console.log(chalk.cyan(`\n🔍 Searching for: "${query}"...\n`));
+        console.log(uiCleanMode()
+          ? chalk.cyan(`\nSearching for: "${query}"...\n`)
+          : chalk.cyan(`\n🔍 Searching for: "${query}"...\n`));
         const results = searchSymbol(query, workspace);
         
         if (results.length === 0) {
@@ -5243,9 +6910,14 @@ async function runSapper() {
         console.log(chalk.green(`Found ${results.length} symbol${results.length !== 1 ? 's' : ''}:\n`));
         
         for (const sym of results.slice(0, 15)) {
-          const typeIcon = sym.type === 'function' ? chalk.yellow('𝑓') : 
-                          sym.type === 'class' ? chalk.blue('◆') :
-                          sym.type === 'method' ? chalk.cyan('○') : chalk.gray('◇');
+          const clean = uiCleanMode();
+          const typeIcon = sym.type === 'function'
+            ? (clean ? chalk.yellow('f') : chalk.yellow('𝑓'))
+            : sym.type === 'class'
+              ? (clean ? chalk.blue('C') : chalk.blue('◆'))
+              : sym.type === 'method'
+                ? (clean ? chalk.cyan('m') : chalk.cyan('○'))
+                : (clean ? chalk.gray('-') : chalk.gray('◇'));
           const asyncTag = sym.async ? chalk.magenta('async ') : '';
           const params = sym.params !== undefined ? chalk.gray(`(${sym.params})`) : '';
           
@@ -5260,7 +6932,7 @@ async function runSapper() {
         // Offer to add file to context
         if (results.length > 0) {
           console.log();
-          const addToCtx = await safeQuestion(chalk.yellow('Add first match file to context? ') + chalk.gray('(y/n): '));
+          const addToCtx = await safeQuestion(chalk.yellow(promptLabel('questions.addFirstMatchFileToContext', 'Add first match file to context? (y/n): ')));
           if (addToCtx.toLowerCase() === 'y') {
             const targetFile = results[0].file;
             try {
@@ -5310,15 +6982,15 @@ async function runSapper() {
           chalk.gray('─'.repeat(40)) + '\n' +
           `${chalk.white('Related files:')}\n` +
           (related.length > 0 
-            ? related.map(r => `  📄 ${r}`).join('\n')
+            ? related.map(r => uiCleanMode() ? `  - ${r}` : `  📄 ${r}`).join('\n')
             : chalk.gray('  (no related files found)')),
-          '🔗 File Graph', 'cyan'
+          uiCleanMode() ? 'File Graph' : '🔗 File Graph', 'cyan'
         ));
         console.log();
         
         // Offer to add to context
         if (related.length > 0) {
-          const addRelated = await safeQuestion(chalk.yellow('Add this file + related to context? ') + chalk.gray('(y/n): '));
+          const addRelated = await safeQuestion(chalk.yellow(promptLabel('questions.addFileAndRelatedToContext', 'Add this file + related to context? (y/n): ')));
           if (addRelated.toLowerCase() === 'y') {
             let contextContent = `\n📄 ${matchingFile}:\n`;
             contextContent += fs.readFileSync(matchingFile, 'utf8');
@@ -5344,7 +7016,9 @@ async function runSapper() {
       if (input.toLowerCase() === '/auto') {
         sapperConfig.autoAttach = !sapperConfig.autoAttach;
         saveConfig(sapperConfig);
-        console.log(chalk.cyan(`\n🔗 Auto-attach related files: ${sapperConfig.autoAttach ? chalk.green('ON') : chalk.red('OFF')}`));
+        console.log(uiCleanMode()
+          ? chalk.cyan(`\nAuto-attach related files: ${sapperConfig.autoAttach ? chalk.green('ON') : chalk.red('OFF')}`)
+          : chalk.cyan(`\n🔗 Auto-attach related files: ${sapperConfig.autoAttach ? chalk.green('ON') : chalk.red('OFF')}`));
         if (sapperConfig.autoAttach) {
           console.log(chalk.gray('   When you @file, related imports will be auto-included.'));
         } else {
@@ -5384,36 +7058,243 @@ async function runSapper() {
               console.log(chalk.yellow(`   ⚠ Limit exceeds model's ${modelContextLength.toLocaleString()} context — may cause errors`));
             }
           }
-        } else {
-          // Show current setting
-          const effective = effectiveContextLength();
-          const custom = sapperConfig.contextLimit;
-          const lines = [
-            `model default  ${chalk.white(modelContextLength ? modelContextLength.toLocaleString() : 'unknown')} tokens`,
-            `custom limit   ${custom ? chalk.cyan.bold(custom.toLocaleString() + ' tokens') : UI.slate('not set (using model default)')}`,
-            `effective      ${chalk.white.bold(effective ? effective.toLocaleString() + ' tokens' : 'unknown')}`,
-          ];
-          console.log();
-          console.log(box(lines.join('\n'), 'Context Limit', 'cyan'));
-          console.log(UI.slate('  Set: /ctx 64k  |  /ctx 32768  |  /ctx reset'));
+        } else {
+          // Show current setting
+          const effective = effectiveContextLength();
+          const custom = sapperConfig.contextLimit;
+          const lines = [
+            `model default  ${chalk.white(modelContextLength ? modelContextLength.toLocaleString() : 'unknown')} tokens`,
+            `custom limit   ${custom ? chalk.cyan.bold(custom.toLocaleString() + ' tokens') : UI.slate('not set (using model default)')}`,
+            `effective      ${chalk.white.bold(effective ? effective.toLocaleString() + ' tokens' : 'unknown')}`,
+          ];
+          console.log();
+          console.log(box(lines.join('\n'), 'Context Limit', 'cyan'));
+          console.log(UI.slate('  Set: /ctx 64k  |  /ctx 32768  |  /ctx reset'));
+        }
+        continue;
+      }
+
+      if (input.toLowerCase().startsWith('/summary')) {
+        const arg = input.substring(8).trim();
+
+        if (!arg) {
+          const effective = effectiveContextLength();
+          const threshold = summaryTokenThreshold(effective);
+          const lines = [
+            `phases        ${summaryPhasesEnabled() ? chalk.green('ON') : chalk.red('OFF')}`,
+            `trigger       ${chalk.white.bold(summaryTriggerPercent() + '%')} ${UI.slate(`(~${threshold.toLocaleString()} tokens)`)}`,
+            `config file   ${chalk.white(CONFIG_FILE)}`,
+          ];
+          console.log();
+          console.log(box(lines.join('\n'), 'Summary Settings', 'cyan'));
+          console.log(UI.slate('  Usage: /summary phases [on|off]  |  /summary trigger <percent>  |  /summary reset'));
+          continue;
+        }
+
+        const [subcommandRaw, ...rest] = arg.split(/\s+/);
+        const subcommand = subcommandRaw.toLowerCase();
+        const value = rest.join(' ').trim();
+
+        if (subcommand === 'reset' || subcommand === 'default') {
+          sapperConfig.summaryPhases = DEFAULT_CONFIG.summaryPhases;
+          sapperConfig.summarizeTriggerPercent = DEFAULT_CONFIG.summarizeTriggerPercent;
+          saveConfig(sapperConfig);
+          console.log(chalk.green(`✅ Summary settings reset: phases ${summaryPhasesEnabled() ? 'ON' : 'OFF'}, trigger ${summaryTriggerPercent()}%`));
+          continue;
+        }
+
+        if (subcommand === 'phases' || subcommand === 'phase') {
+          let nextValue = null;
+
+          if (!value) {
+            nextValue = !summaryPhasesEnabled();
+          } else {
+            const normalized = value.toLowerCase();
+            if (['on', 'true', 'yes', '1', 'enable', 'enabled'].includes(normalized)) {
+              nextValue = true;
+            } else if (['off', 'false', 'no', '0', 'disable', 'disabled'].includes(normalized)) {
+              nextValue = false;
+            } else if (['toggle', 'flip'].includes(normalized)) {
+              nextValue = !summaryPhasesEnabled();
+            }
+          }
+
+          if (nextValue === null) {
+            console.log(chalk.yellow('Usage: /summary phases [on|off]'));
+            continue;
+          }
+
+          sapperConfig.summaryPhases = nextValue;
+          saveConfig(sapperConfig);
+          console.log(chalk.green(`✅ Summary phases: ${summaryPhasesEnabled() ? chalk.green('ON') : chalk.red('OFF')}`));
+          continue;
+        }
+
+        if (subcommand === 'trigger' || subcommand === 'percent' || subcommand === 'threshold') {
+          if (!value) {
+            console.log(chalk.yellow('Usage: /summary trigger <percent>'));
+            console.log(chalk.gray('  Examples: /summary trigger 65, /summary trigger 70%, /summary trigger 0.6'));
+            continue;
+          }
+
+          const parsedTrigger = parseSummaryTriggerInput(value);
+          if (parsedTrigger === null) {
+            console.log(chalk.yellow(`Invalid summary trigger: ${value}`));
+            console.log(chalk.gray('  Examples: /summary trigger 65, /summary trigger 70%, /summary trigger 0.6'));
+            continue;
+          }
+
+          sapperConfig.summarizeTriggerPercent = parsedTrigger;
+          saveConfig(sapperConfig);
+          const effective = effectiveContextLength();
+          const threshold = summaryTokenThreshold(effective);
+          console.log(chalk.green(`✅ Summary trigger set to ${chalk.white.bold(summaryTriggerPercent() + '%')}`));
+          console.log(chalk.gray(`   Auto-summary will start near ${threshold.toLocaleString()} tokens.`));
+          continue;
+        }
+
+        console.log(chalk.yellow(`Unknown summary option: ${subcommand}`));
+        console.log(chalk.gray('  Usage: /summary  |  /summary phases [on|off]  |  /summary trigger <percent>  |  /summary reset'));
+        continue;
+      }
+
+      if (input.toLowerCase().startsWith('/chunking') || input.toLowerCase().startsWith('/chunk ') || input.toLowerCase() === '/chunk') {
+        const arg = input.replace(/^\/chunk(ing)?/i, '').trim();
+
+        if (!arg || ['status', 'show'].includes(arg.toLowerCase())) {
+          const cfg = getChunkingConfig();
+          const lines = [
+            `enabled         ${cfg.enabled ? chalk.green('ON') : chalk.red('OFF')}`,
+            `context lines   ${chalk.white.bold(cfg.contextLines)} ${UI.slate('(lines above & below each match)')}`,
+            `max per file    ${chalk.white.bold(cfg.maxChunksPerFile)} ${UI.slate('(chunk groups returned per file)')}`,
+            `auto-suggest    ${chalk.white.bold(cfg.autoChunkAboveLines)} ${UI.slate('(prefer chunking when files exceed this many lines)')}`,
+            `config file     ${chalk.white(CONFIG_FILE)}`,
+          ];
+          console.log();
+          console.log(box(lines.join('\n'), 'Chunked Reading', 'cyan'));
+          console.log(UI.slate('  Usage: /chunking on|off  |  /chunking context <N>  |  /chunking max <N>  |  /chunking auto <N>  |  /chunking reset'));
+          continue;
+        }
+
+        const [subcommandRaw, ...rest] = arg.split(/\s+/);
+        const subcommand = subcommandRaw.toLowerCase();
+        const value = rest.join(' ').trim();
+        const updateChunking = (patch) => {
+          sapperConfig.chunking = { ...getChunkingConfig(), ...patch };
+          saveConfig(sapperConfig);
+        };
+
+        if (subcommand === 'reset' || subcommand === 'default') {
+          sapperConfig.chunking = { ...DEFAULT_CONFIG.chunking };
+          saveConfig(sapperConfig);
+          console.log(chalk.green(`✅ Chunking reset to defaults: enabled=${chunkingEnabled() ? 'ON' : 'OFF'}, context=${chunkingContextLines()}, maxPerFile=${chunkingMaxPerFile()}`));
+          continue;
+        }
+
+        if (['on', 'true', 'yes', '1', 'enable', 'enabled'].includes(subcommand)) {
+          updateChunking({ enabled: true });
+          console.log(chalk.green('✅ Chunked reading: ' + chalk.green('ON')));
+          continue;
+        }
+        if (['off', 'false', 'no', '0', 'disable', 'disabled'].includes(subcommand)) {
+          updateChunking({ enabled: false });
+          console.log(chalk.yellow('✅ Chunked reading: ' + chalk.red('OFF') + chalk.gray(' (agent will read full files)')));
+          continue;
+        }
+        if (subcommand === 'toggle' || subcommand === 'flip') {
+          updateChunking({ enabled: !chunkingEnabled() });
+          console.log(chalk.green(`✅ Chunked reading: ${chunkingEnabled() ? chalk.green('ON') : chalk.red('OFF')}`));
+          continue;
+        }
+
+        if (subcommand === 'context' || subcommand === 'lines') {
+          const n = parseInt(value, 10);
+          if (!Number.isFinite(n) || n < 0 || n > 200) {
+            console.log(chalk.yellow('Usage: /chunking context <0-200>'));
+            continue;
+          }
+          updateChunking({ contextLines: n });
+          console.log(chalk.green(`✅ Chunk context lines set to ${chalk.white.bold(chunkingContextLines())}`));
+          continue;
+        }
+
+        if (subcommand === 'max' || subcommand === 'maxperfile') {
+          const n = parseInt(value, 10);
+          if (!Number.isFinite(n) || n < 1 || n > 50) {
+            console.log(chalk.yellow('Usage: /chunking max <1-50>'));
+            continue;
+          }
+          updateChunking({ maxChunksPerFile: n });
+          console.log(chalk.green(`✅ Max chunks per file set to ${chalk.white.bold(chunkingMaxPerFile())}`));
+          continue;
+        }
+
+        if (subcommand === 'auto' || subcommand === 'autoabove') {
+          const n = parseInt(value, 10);
+          if (!Number.isFinite(n) || n < 50 || n > 10000) {
+            console.log(chalk.yellow('Usage: /chunking auto <50-10000>'));
+            continue;
+          }
+          updateChunking({ autoChunkAboveLines: n });
+          console.log(chalk.green(`✅ Auto-chunk threshold set to ${chalk.white.bold(chunkingAutoAboveLines())} lines`));
+          continue;
         }
+
+        console.log(chalk.yellow(`Unknown chunking option: ${subcommand}`));
+        console.log(chalk.gray('  Usage: /chunking  |  /chunking on|off  |  /chunking context <N>  |  /chunking max <N>  |  /chunking auto <N>  |  /chunking reset'));
         continue;
       }
 
-      if (input.toLowerCase().startsWith('/summary')) {
-        const arg = input.substring(8).trim();
+      {
+        const _voiceLower = input.toLowerCase();
+        const _isVoiceCmd =
+          _voiceLower === '/voice' || _voiceLower === '/v' ||
+          _voiceLower.startsWith('/voice ') || _voiceLower.startsWith('/v ');
+        if (_isVoiceCmd) {
+        const arg = (_voiceLower.startsWith('/voice') ? input.substring(6) : input.substring(2)).trim();
+        const cfg = getVoiceConfig();
+        const updateVoice = (patch) => {
+          sapperConfig.voice = { ...getVoiceConfig(), ...patch };
+          saveConfig(sapperConfig);
+        };
 
-        if (!arg) {
-          const effective = effectiveContextLength();
-          const threshold = summaryTokenThreshold(effective);
+        if (!arg || ['status', 'show'].includes(arg.toLowerCase())) {
+          const archiveDirDisplay = isAbsolute(cfg.archiveDir)
+            ? cfg.archiveDir
+            : pathResolve(getToolWorkingDirectory(), cfg.archiveDir);
           const lines = [
-            `phases        ${summaryPhasesEnabled() ? chalk.green('ON') : chalk.red('OFF')}`,
-            `trigger       ${chalk.white.bold(summaryTriggerPercent() + '%')} ${UI.slate(`(~${threshold.toLocaleString()} tokens)`)}`,
-            `config file   ${chalk.white(CONFIG_FILE)}`,
+            `enabled         ${cfg.enabled ? chalk.green('ON') : chalk.red('OFF')}`,
+            `whisper bin     ${chalk.white(cfg.whisperBin)}`,
+            `model           ${fs.existsSync(cfg.model) ? chalk.white(cfg.model) : chalk.red(cfg.model + ' (not found)')}`,
+            `language        ${chalk.white(cfg.language)}`,
+            `recorder        ${chalk.white(cfg.recorder)} ${UI.slate(`(device: ${cfg.device})`)}`,
+            `record seconds  ${chalk.white.bold(cfg.recordSeconds)}`,
+            `sample rate     ${chalk.white(cfg.sampleRate + ' Hz')}`,
+            `translate       ${cfg.translate ? chalk.green('ON') : chalk.red('OFF')} ${UI.slate('(force English output)')}`,
+            `auto-send       ${cfg.autoSend ? chalk.green('ON') : chalk.red('OFF')} ${UI.slate('(skip confirm before sending to AI)')}`,
+            `archive         ${cfg.archive ? chalk.green('ON') : chalk.red('OFF')} ${UI.slate(`→ ${archiveDirDisplay}/YYYY-MM-DD/`)}`,
           ];
           console.log();
-          console.log(box(lines.join('\n'), 'Summary Settings', 'cyan'));
-          console.log(UI.slate('  Usage: /summary phases [on|off]  |  /summary trigger <percent>  |  /summary reset'));
+          console.log(box(lines.join('\n'), '🎙️  Voice / Whisper', 'cyan'));
+          console.log(UI.slate('  Usage:'));
+          console.log(UI.slate('    /v live                   live preview while you speak, clean final transcript on stop'));
+          console.log(UI.slate('    /v record                 record from mic — press any key to stop'));
+          console.log(UI.slate('    /v record <seconds>       record for a fixed duration'));
+          console.log(UI.slate('    /v talk                   alias for push-to-stop recording'));
+          console.log(UI.slate('    /v file <path>            transcribe an existing audio file'));
+          console.log(UI.slate('    /voice on|off             toggle the feature'));
+          console.log(UI.slate('    /voice model              list available models and pick one'));
+          console.log(UI.slate('    /voice model <N|path>     pick model by number or set path'));
+          console.log(UI.slate('    /voice lang <code|auto>   set language'));
+          console.log(UI.slate('    /voice seconds <n>        default record duration'));
+          console.log(UI.slate('    /voice device <id>        mic device (e.g. :0)'));
+          console.log(UI.slate('    /voice recorder ffmpeg|sox'));
+          console.log(UI.slate('    /voice translate on|off   translate to English'));
+          console.log(UI.slate('    /voice autosend on|off    skip confirm and send to AI'));
+          console.log(UI.slate('    /voice archive on|off     save recordings + transcripts to disk'));
+          console.log(UI.slate('    /voice archive path <dir> set archive folder (default .sapper/voice)'));
+          console.log(UI.slate('    /voice archive open       reveal archive folder in Finder/Explorer'));
+          console.log(UI.slate('    /voice reset              restore defaults'));
           continue;
         }
 
@@ -5421,66 +7302,458 @@ async function runSapper() {
         const subcommand = subcommandRaw.toLowerCase();
         const value = rest.join(' ').trim();
 
+        // Settings subcommands
         if (subcommand === 'reset' || subcommand === 'default') {
-          sapperConfig.summaryPhases = DEFAULT_CONFIG.summaryPhases;
-          sapperConfig.summarizeTriggerPercent = DEFAULT_CONFIG.summarizeTriggerPercent;
+          sapperConfig.voice = { ...DEFAULT_CONFIG.voice };
           saveConfig(sapperConfig);
-          console.log(chalk.green(`✅ Summary settings reset: phases ${summaryPhasesEnabled() ? 'ON' : 'OFF'}, trigger ${summaryTriggerPercent()}%`));
+          console.log(chalk.green('✅ Voice settings reset to defaults'));
           continue;
         }
+        if (['on', 'true', 'yes', '1', 'enable', 'enabled'].includes(subcommand)) {
+          updateVoice({ enabled: true });
+          console.log(chalk.green('✅ Voice input: ' + chalk.green('ON')));
+          continue;
+        }
+        if (['off', 'false', 'no', '0', 'disable', 'disabled'].includes(subcommand)) {
+          updateVoice({ enabled: false });
+          console.log(chalk.yellow('✅ Voice input: ' + chalk.red('OFF')));
+          continue;
+        }
+        if (subcommand === 'model' || subcommand === 'models') {
+          // Build the list of candidate models from common locations
+          const searchDirs = [
+            join(os.homedir(), 'models'),
+            join(os.homedir(), '.whisper'),
+            join(os.homedir(), '.cache', 'whisper'),
+            '/opt/homebrew/share/whisper.cpp/models',
+            '/usr/local/share/whisper.cpp/models',
+            './models',
+          ];
+          const seen = new Set();
+          const found = [];
+          for (const dir of searchDirs) {
+            const abs = isAbsolute(dir) ? dir : pathResolve(getToolWorkingDirectory(), dir);
+            try {
+              if (!fs.existsSync(abs)) continue;
+              for (const f of fs.readdirSync(abs)) {
+                if (!/^ggml-.*\.bin$/i.test(f)) continue;          // ggml-*.bin only
+                if (/\.(tmp|partial|download)$/i.test(f)) continue; // skip stale tmp files
+                const full = join(abs, f);
+                if (seen.has(full)) continue;
+                seen.add(full);
+                try {
+                  const st = fs.statSync(full);
+                  if (st.size < 50 * 1024 * 1024) continue;        // skip < 50MB (probably broken)
+                  found.push({ path: full, name: f, size: st.size, mtime: st.mtimeMs });
+                } catch {}
+              }
+            } catch {}
+          }
+          found.sort((a, b) => a.name.localeCompare(b.name));
 
-        if (subcommand === 'phases' || subcommand === 'phase') {
-          let nextValue = null;
+          const humanSize = (n) => n >= 1024 * 1024 * 1024
+            ? `${(n / 1024 / 1024 / 1024).toFixed(1)} GB`
+            : `${(n / 1024 / 1024).toFixed(0)} MB`;
 
-          if (!value) {
-            nextValue = !summaryPhasesEnabled();
-          } else {
-            const normalized = value.toLowerCase();
-            if (['on', 'true', 'yes', '1', 'enable', 'enabled'].includes(normalized)) {
-              nextValue = true;
-            } else if (['off', 'false', 'no', '0', 'disable', 'disabled'].includes(normalized)) {
-              nextValue = false;
-            } else if (['toggle', 'flip'].includes(normalized)) {
-              nextValue = !summaryPhasesEnabled();
+          // Direct pick by number: /v model 2
+          if (value && /^\d+$/.test(value)) {
+            const idx = parseInt(value, 10) - 1;
+            if (idx < 0 || idx >= found.length) {
+              console.log(chalk.yellow(`No model #${value}. Run /v model (no args) to list.`));
+              continue;
             }
+            updateVoice({ model: found[idx].path });
+            console.log(chalk.green(`✅ Whisper model set to ${chalk.white(found[idx].path)}`));
+            continue;
           }
 
-          if (nextValue === null) {
-            console.log(chalk.yellow('Usage: /summary phases [on|off]'));
+          // Direct pick by path: /v model /some/path.bin
+          if (value) {
+            const abs = isAbsolute(value) ? value : pathResolve(getToolWorkingDirectory(), value);
+            if (!fs.existsSync(abs)) {
+              console.log(chalk.yellow(`⚠️  File not found: ${abs} (saved anyway — fix the path before recording)`));
+            }
+            updateVoice({ model: abs });
+            console.log(chalk.green(`✅ Whisper model set to ${chalk.white(abs)}`));
             continue;
           }
 
-          sapperConfig.summaryPhases = nextValue;
-          saveConfig(sapperConfig);
-          console.log(chalk.green(`✅ Summary phases: ${summaryPhasesEnabled() ? chalk.green('ON') : chalk.red('OFF')}`));
+          // Interactive list + pick
+          if (found.length === 0) {
+            console.log();
+            console.log(chalk.yellow('No ggml-*.bin Whisper models found.'));
+            console.log(UI.slate('  Searched: ' + searchDirs.join(', ')));
+            console.log(UI.slate('  Download one with:'));
+            console.log(UI.slate('    curl -L -o ~/models/ggml-large-v3-turbo.bin \\'));
+            console.log(UI.slate('      https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin'));
+            continue;
+          }
+
+          console.log();
+          console.log(chalk.cyan(`Available Whisper models (${found.length}):`));
+          const currentModel = cfg.model;
+          const nameW = Math.min(40, Math.max(...found.map(m => m.name.length)));
+          for (let i = 0; i < found.length; i++) {
+            const m = found[i];
+            const marker = m.path === currentModel ? chalk.green(' ← current') : '';
+            const num = chalk.cyan(String(i + 1).padStart(2, ' ') + '.');
+            const name = chalk.white(m.name.padEnd(nameW));
+            const size = chalk.gray(humanSize(m.size).padStart(7));
+            const dir = UI.slate('  ' + dirname(m.path));
+            console.log(`  ${num} ${name} ${size}${marker}`);
+            console.log(`     ${dir}`);
+          }
+          console.log();
+          const pick = await safeQuestion(chalk.yellow(`Pick a model [1-${found.length}, Enter to cancel]: `));
+          const pickN = parseInt(pick.trim(), 10);
+          if (!Number.isFinite(pickN) || pickN < 1 || pickN > found.length) {
+            console.log(UI.slate('Cancelled.'));
+            continue;
+          }
+          updateVoice({ model: found[pickN - 1].path });
+          console.log(chalk.green(`✅ Whisper model set to ${chalk.white(found[pickN - 1].path)}`));
+          continue;
+        }
+        if (subcommand === 'lang' || subcommand === 'language') {
+          if (!value) { console.log(chalk.yellow('Usage: /voice lang <code|auto>')); continue; }
+          updateVoice({ language: value.toLowerCase() });
+          console.log(chalk.green(`✅ Whisper language set to ${chalk.white(value.toLowerCase())}`));
+          continue;
+        }
+        if (subcommand === 'seconds' || subcommand === 'duration') {
+          const n = parseInt(value, 10);
+          if (!Number.isFinite(n) || n < 1 || n > 300) { console.log(chalk.yellow('Usage: /voice seconds <1-300>')); continue; }
+          updateVoice({ recordSeconds: n });
+          console.log(chalk.green(`✅ Default record duration: ${chalk.white.bold(n)}s`));
+          continue;
+        }
+        if (subcommand === 'device' || subcommand === 'mic') {
+          if (!value) { console.log(chalk.yellow('Usage: /voice device <id>  (e.g. :0 for ffmpeg avfoundation default mic)')); continue; }
+          updateVoice({ device: value });
+          console.log(chalk.green(`✅ Mic device set to ${chalk.white(value)}`));
+          continue;
+        }
+        if (subcommand === 'recorder') {
+          const r = value.toLowerCase();
+          if (!['ffmpeg', 'sox'].includes(r)) { console.log(chalk.yellow('Usage: /voice recorder ffmpeg|sox')); continue; }
+          updateVoice({ recorder: r });
+          console.log(chalk.green(`✅ Recorder set to ${chalk.white(r)}`));
+          continue;
+        }
+        if (subcommand === 'translate') {
+          const on = ['on', 'true', 'yes', '1'].includes(value.toLowerCase());
+          const off = ['off', 'false', 'no', '0'].includes(value.toLowerCase());
+          if (!on && !off) { console.log(chalk.yellow('Usage: /voice translate on|off')); continue; }
+          updateVoice({ translate: on });
+          console.log(chalk.green(`✅ Translate to English: ${on ? chalk.green('ON') : chalk.red('OFF')}`));
+          continue;
+        }
+        if (subcommand === 'autosend' || subcommand === 'auto-send' || subcommand === 'auto') {
+          const on = ['on', 'true', 'yes', '1'].includes(value.toLowerCase());
+          const off = ['off', 'false', 'no', '0'].includes(value.toLowerCase());
+          if (!on && !off) { console.log(chalk.yellow('Usage: /voice autosend on|off')); continue; }
+          updateVoice({ autoSend: on });
+          console.log(chalk.green(`✅ Auto-send transcript: ${on ? chalk.green('ON') : chalk.red('OFF')}`));
+          continue;
+        }
+        if (subcommand === 'archive') {
+          const [archSubRaw, ...archRest] = (value || '').split(/\s+/);
+          const archSub = (archSubRaw || '').toLowerCase();
+          const archValue = archRest.join(' ').trim();
+          const archiveDirAbs = isAbsolute(cfg.archiveDir)
+            ? cfg.archiveDir
+            : pathResolve(getToolWorkingDirectory(), cfg.archiveDir);
+
+          if (!archSub || archSub === 'show' || archSub === 'status') {
+            const exists = fs.existsSync(archiveDirAbs);
+            console.log(chalk.cyan('Archive') + ': ' + (cfg.archive ? chalk.green('ON') : chalk.red('OFF')));
+            console.log(chalk.cyan('Folder') + ': ' + chalk.white(archiveDirAbs) + (exists ? UI.slate(' (exists)') : UI.slate(' (will be created on next recording)')));
+            if (exists) {
+              try {
+                const days = fs.readdirSync(archiveDirAbs).filter(d => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse().slice(0, 5);
+                if (days.length) {
+                  console.log(chalk.cyan('Recent days') + ':');
+                  for (const d of days) {
+                    const files = fs.readdirSync(join(archiveDirAbs, d));
+                    const wavs = files.filter(f => f.endsWith('.wav')).length;
+                    const txts = files.filter(f => f.endsWith('.txt')).length;
+                    console.log(UI.slate(`  ${d}  →  ${wavs} audio, ${txts} transcripts`));
+                  }
+                }
+              } catch {}
+            }
+            console.log(UI.slate('  /voice archive on|off       toggle archiving'));
+            console.log(UI.slate('  /voice archive path <dir>   change archive folder'));
+            console.log(UI.slate('  /voice archive open         reveal folder in Finder/Explorer'));
+            continue;
+          }
+          if (['on', 'true', 'yes', '1'].includes(archSub)) {
+            updateVoice({ archive: true });
+            console.log(chalk.green('✅ Voice archiving: ' + chalk.green('ON')));
+            continue;
+          }
+          if (['off', 'false', 'no', '0'].includes(archSub)) {
+            updateVoice({ archive: false });
+            console.log(chalk.green('✅ Voice archiving: ' + chalk.red('OFF')));
+            continue;
+          }
+          if (archSub === 'path' || archSub === 'dir' || archSub === 'folder') {
+            if (!archValue) { console.log(chalk.yellow('Usage: /voice archive path <dir>')); continue; }
+            updateVoice({ archiveDir: archValue });
+            console.log(chalk.green(`✅ Archive folder set to ${chalk.white(archValue)}`));
+            continue;
+          }
+          if (archSub === 'open' || archSub === 'reveal') {
+            try { fs.mkdirSync(archiveDirAbs, { recursive: true }); } catch {}
+            const opener = process.platform === 'darwin' ? 'open'
+                          : process.platform === 'win32' ? 'explorer'
+                          : 'xdg-open';
+            try {
+              spawn(opener, [archiveDirAbs], { detached: true, stdio: 'ignore' }).unref();
+              console.log(chalk.green(`✅ Opening ${archiveDirAbs}`));
+            } catch (err) {
+              console.log(chalk.red(`Failed to open: ${err.message}`));
+            }
+            continue;
+          }
+          console.log(chalk.yellow(`Unknown archive option: ${archSub}`));
+          console.log(chalk.gray('  Run "/voice archive" with no args to see usage.'));
           continue;
         }
 
-        if (subcommand === 'trigger' || subcommand === 'percent' || subcommand === 'threshold') {
+        // Action subcommands: record / rec / talk / live / file
+        if (subcommand === 'live' || subcommand === 'stream') {
+          if (!cfg.enabled) {
+            console.log(chalk.yellow('Voice input is OFF. Enable with /voice on first.'));
+            continue;
+          }
+          // Phase 1: live preview + save audio (no final text yet)
+          const res = await runWhisperLive({
+            whisperStreamBin: cfg.whisperStreamBin,
+            model: cfg.model,
+            language: cfg.language,
+            translate: cfg.translate,
+            stepMs: cfg.liveStepMs,
+            lengthMs: cfg.liveLengthMs,
+            keepMs: cfg.liveKeepMs,
+          });
+          if (!res.ok) { console.log(chalk.red(`❌ ${res.error}`)); continue; }
+          if (!res.audioPath) {
+            if (res.audioTmpDir) { try { fs.rmSync(res.audioTmpDir, { recursive: true, force: true }); } catch {} }
+            console.log(chalk.yellow('No audio captured.'));
+            continue;
+          }
+
+          // Phase 2: single clean transcription pass on the saved WAV (this is
+          // the trick — whisper-stream's sliding window produces overlapping
+          // chunks, so we ignore that text and re-decode the whole file once).
+          const finalSpinner = ora(chalk.cyan(`Transcribing with ${cfg.whisperBin} (${cfg.model.split('/').pop()})...`)).start();
+          const finalRes = await runWhisperCli(res.audioPath, {
+            whisperBin: cfg.whisperBin,
+            model: cfg.model,
+            language: cfg.language,
+            translate: cfg.translate,
+          });
+          finalSpinner.stop();
+
+          if (!finalRes.ok) {
+            if (res.audioTmpDir) { try { fs.rmSync(res.audioTmpDir, { recursive: true, force: true }); } catch {} }
+            console.log(chalk.red(`❌ Final transcription failed: ${finalRes.error}`));
+            continue;
+          }
+
+          // Drop the [BLANK_AUDIO] marker whisper sometimes emits at the start
+          let transcript = (finalRes.text || '')
+            .replace(/\[BLANK_AUDIO\]/gi, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+
+          if (!transcript) {
+            if (res.audioTmpDir) { try { fs.rmSync(res.audioTmpDir, { recursive: true, force: true }); } catch {} }
+            console.log(chalk.yellow('No speech detected.'));
+            continue;
+          }
+
+          // Archive (audio + clean transcript)
+          if (cfg.archive) {
+            const archived = archiveVoiceRecording({
+              sourceAudio: res.audioPath,
+              transcript,
+              mode: 'live',
+            });
+            if (archived && archived.ok) {
+              const where = archived.audio || archived.transcript;
+              if (where) console.log(UI.slate(`  Archived → ${where.replace(getToolWorkingDirectory() + '/', '')}`));
+            }
+          }
+          // Cleanup the temp sa dir whether or not archive succeeded
+          if (res.audioTmpDir) { try { fs.rmSync(res.audioTmpDir, { recursive: true, force: true }); } catch {} }
+
+          console.log();
+          if (!transcript || !transcript.trim()) {
+            console.log(box(
+              chalk.gray('(empty — no speech detected or only hallucinations were filtered)\n') +
+              (cfg.language === 'auto' || !cfg.language
+                ? chalk.yellow('  💡 Try locking the language: ') + chalk.white('/v lang ar') + chalk.yellow(' or ') + chalk.white('/v lang en')
+                : chalk.gray(`  language was: ${cfg.language}`)),
+              '🎙️  Final transcript', 'yellow'));
+            continue;
+          }
+          console.log(box(chalk.white(transcript), '🎙️  Final transcript', 'cyan'));
+          if (cfg.autoSend) {
+            input = transcript;
+          } else {
+            const confirm = await safeQuestion(chalk.yellow('Send to AI? [Y/n/e=edit]: '));
+            const ans = confirm.trim().toLowerCase();
+            if (ans === 'n' || ans === 'no') { continue; }
+            if (ans === 'e' || ans === 'edit') {
+              const edited = await safeQuestion(chalk.cyan('Edit transcript: '));
+              if (!edited.trim()) continue;
+              input = edited.trim();
+            } else {
+              input = transcript;
+            }
+          }
+          // Fall through to AI processing
+        } else if (subcommand === 'record' || subcommand === 'rec' || subcommand === 'talk') {
+          if (!cfg.enabled) {
+            console.log(chalk.yellow('Voice input is OFF. Enable with /voice on first.'));
+            continue;
+          }
+          // /v record           → push-to-stop (press any key to stop)
+          // /v record <N>       → fixed N seconds
+          // /v talk             → also push-to-stop (alias)
+          const secs = value ? parseInt(value, 10) : null;
+          const usePushToStop = (subcommand === 'talk') || !Number.isFinite(secs);
+          const t = await transcribeAudio({
+            seconds: usePushToStop ? null : secs,
+            pushToStop: usePushToStop,
+            mode: subcommand === 'talk' ? 'talk' : 'record',
+          });
+          if (!t.ok) { console.log(chalk.red(`❌ ${t.error}`)); continue; }
+          const transcript = (t.text || '').trim();
+          if (!transcript) { console.log(chalk.yellow('No speech detected.')); continue; }
+          console.log();
+          console.log(box(chalk.white(transcript), '🎙️  Transcript', 'cyan'));
+          if (cfg.autoSend) {
+            input = transcript; // fall through to AI processing
+          } else {
+            const confirm = await safeQuestion(chalk.yellow('Send to AI? [Y/n/e=edit]: '));
+            const ans = confirm.trim().toLowerCase();
+            if (ans === 'n' || ans === 'no') { continue; }
+            if (ans === 'e' || ans === 'edit') {
+              const edited = await safeQuestion(chalk.cyan('Edit transcript: '));
+              if (!edited.trim()) continue;
+              input = edited.trim();
+            } else {
+              input = transcript;
+            }
+          }
+          // Fall through — the loop body below will process `input` as a normal user prompt
+        } else if (subcommand === 'file') {
+          if (!cfg.enabled) {
+            console.log(chalk.yellow('Voice input is OFF. Enable with /voice on first.'));
+            continue;
+          }
+          if (!value) { console.log(chalk.yellow('Usage: /voice file <path-to-audio>')); continue; }
+          const resolved = isAbsolute(value) ? value : pathResolve(getToolWorkingDirectory(), value);
+          if (!fs.existsSync(resolved)) { console.log(chalk.red(`❌ File not found: ${resolved}`)); continue; }
+          const t = await transcribeAudio({ audioFile: resolved, mode: 'file' });
+          if (!t.ok) { console.log(chalk.red(`❌ ${t.error}`)); continue; }
+          const transcript = (t.text || '').trim();
+          if (!transcript) { console.log(chalk.yellow('No speech detected in file.')); continue; }
+          console.log();
+          console.log(box(chalk.white(transcript), `🎙️  Transcript (${value})`, 'cyan'));
+          if (cfg.autoSend) {
+            input = transcript;
+          } else {
+            const confirm = await safeQuestion(chalk.yellow('Send to AI? [Y/n/e=edit]: '));
+            const ans = confirm.trim().toLowerCase();
+            if (ans === 'n' || ans === 'no') { continue; }
+            if (ans === 'e' || ans === 'edit') {
+              const edited = await safeQuestion(chalk.cyan('Edit transcript: '));
+              if (!edited.trim()) continue;
+              input = edited.trim();
+            } else {
+              input = transcript;
+            }
+          }
+        } else {
+          console.log(chalk.yellow(`Unknown /voice option: ${subcommand}`));
+          console.log(chalk.gray('  Run /voice with no args to see usage.'));
+          continue;
+        }
+        // No `continue` here — `input` was set to the transcript, let the rest of the loop process it.
+        }
+      }
+
+      if (input.toLowerCase().startsWith('/ui')) {
+        const arg = input.substring(3).trim();
+        const currentUI = getUIConfig();
+
+        if (!arg || ['status', 'show'].includes(arg.toLowerCase())) {
+          const lines = [
+            `style         ${chalk.white(currentUI.style)}`,
+            `compact       ${chalk.white(currentUI.compactMode)}`,
+            `render mode   ${chalk.white(uiStyle())}`,
+          ];
+          console.log();
+          console.log(box(lines.join('\n'), 'UI Settings', 'cyan'));
+          console.log(UI.slate('  Usage: /ui style [sapper|clean|ultra]  |  /ui compact [auto|on|off]  |  /ui reset'));
+          continue;
+        }
+
+        const [subcommandRaw, ...rest] = arg.split(/\s+/);
+        const subcommand = subcommandRaw.toLowerCase();
+        const value = rest.join(' ').trim();
+
+        if (subcommand === 'reset') {
+          saveConfig({
+            ...sapperConfig,
+            ui: { ...DEFAULT_CONFIG.ui },
+          });
+          console.log(chalk.green('✅ UI settings reset to defaults (style=sapper, compact=auto).'));
+          continue;
+        }
+
+        if (subcommand === 'style') {
           if (!value) {
-            console.log(chalk.yellow('Usage: /summary trigger <percent>'));
-            console.log(chalk.gray('  Examples: /summary trigger 65, /summary trigger 70%, /summary trigger 0.6'));
+            console.log(chalk.yellow('Usage: /ui style [sapper|clean|ultra]'));
             continue;
           }
 
-          const parsedTrigger = parseSummaryTriggerInput(value);
-          if (parsedTrigger === null) {
-            console.log(chalk.yellow(`Invalid summary trigger: ${value}`));
-            console.log(chalk.gray('  Examples: /summary trigger 65, /summary trigger 70%, /summary trigger 0.6'));
+          const nextStyle = normalizeUIStyle(value);
+          saveConfig({
+            ...sapperConfig,
+            ui: {
+              ...currentUI,
+              style: nextStyle,
+            },
+          });
+          console.log(chalk.green(`✅ UI style set to ${chalk.white(nextStyle)}.`));
+          console.log(chalk.gray('   Restart Sapper to refresh startup screens. Prompt style updates immediately.'));
+          continue;
+        }
+
+        if (subcommand === 'compact') {
+          if (!value) {
+            console.log(chalk.yellow('Usage: /ui compact [auto|on|off]'));
             continue;
           }
 
-          sapperConfig.summarizeTriggerPercent = parsedTrigger;
-          saveConfig(sapperConfig);
-          const effective = effectiveContextLength();
-          const threshold = summaryTokenThreshold(effective);
-          console.log(chalk.green(`✅ Summary trigger set to ${chalk.white.bold(summaryTriggerPercent() + '%')}`));
-          console.log(chalk.gray(`   Auto-summary will start near ${threshold.toLocaleString()} tokens.`));
+          const nextCompact = normalizeUICompactMode(value);
+          saveConfig({
+            ...sapperConfig,
+            ui: {
+              ...currentUI,
+              compactMode: nextCompact,
+            },
+          });
+          console.log(chalk.green(`✅ UI compact mode set to ${chalk.white(nextCompact)}.`));
           continue;
         }
 
-        console.log(chalk.yellow(`Unknown summary option: ${subcommand}`));
-        console.log(chalk.gray('  Usage: /summary  |  /summary phases [on|off]  |  /summary trigger <percent>  |  /summary reset'));
+        console.log(chalk.yellow('Usage: /ui style [sapper|clean|ultra]  |  /ui compact [auto|on|off]  |  /ui reset'));
         continue;
       }
 
@@ -5790,7 +8063,7 @@ async function runSapper() {
           '🤖 New Agent', 'cyan'
         ));
         
-        const agentName = await safeQuestion(chalk.cyan('\nAgent name (lowercase, no spaces): '));
+        const agentName = await safeQuestion(promptQuestion('questions.agentName', '\nAgent name (lowercase, no spaces): '));
         if (!agentName.trim() || !/^[a-z0-9_-]+$/.test(agentName.trim())) {
           console.log(chalk.yellow('Invalid name. Use lowercase letters, numbers, hyphens, underscores only.'));
           continue;
@@ -5802,10 +8075,10 @@ async function runSapper() {
           continue;
         }
         
-        const agentTitle = await safeQuestion(chalk.cyan('Agent title/role: '));
-        const agentExpertise = await safeQuestion(chalk.cyan('Areas of expertise (comma-separated): '));
-        const agentStyle = await safeQuestion(chalk.cyan('Communication style (e.g., professional, casual, technical): '));
-        const agentToolsInput = await safeQuestion(chalk.cyan('Allowed tools (comma-sep, or Enter for all): ') + chalk.gray('read,edit,write,list,ls,search,grep,find,shell,mkdir,rmdir,pwd,cd,cat,head,tail,changes,fetch,memory,open: '));
+        const agentTitle = await safeQuestion(promptQuestion('questions.agentTitle', 'Agent title/role: '));
+        const agentExpertise = await safeQuestion(promptQuestion('questions.agentExpertise', 'Areas of expertise (comma-separated): '));
+        const agentStyle = await safeQuestion(promptQuestion('questions.agentStyle', 'Communication style (e.g., professional, casual, technical): '));
+        const agentToolsInput = await safeQuestion(promptQuestion('questions.agentTools', 'Allowed tools (comma-sep, or Enter for all): read,edit,write,list,ls,search,grep,find,shell,mkdir,rmdir,pwd,cd,cat,head,tail,changes,fetch,memory,open: '));
         
         const expertiseList = agentExpertise.split(',').map(e => `- ${e.trim()}`).join('\n');
         const toolsLine = agentToolsInput.trim() ? `tools: [${agentToolsInput.trim()}]` : 'tools: [read, edit, write, list, search, shell]';
@@ -5828,7 +8101,7 @@ async function runSapper() {
           '📘 New Skill', 'cyan'
         ));
         
-        const skillName = await safeQuestion(chalk.cyan('\nSkill name (lowercase, no spaces): '));
+        const skillName = await safeQuestion(promptQuestion('questions.skillName', '\nSkill name (lowercase, no spaces): '));
         if (!skillName.trim() || !/^[a-z0-9_-]+$/.test(skillName.trim())) {
           console.log(chalk.yellow('Invalid name. Use lowercase letters, numbers, hyphens, underscores only.'));
           continue;
@@ -5840,10 +8113,10 @@ async function runSapper() {
           continue;
         }
         
-        const skillTitle = await safeQuestion(chalk.cyan('Skill title: '));
-        const skillDesc = await safeQuestion(chalk.cyan('Brief description (for /skills listing): '));
-        const skillArgHint = await safeQuestion(chalk.cyan('Argument hint (optional, e.g. "Describe what to do"): '));
-        const skillBody = await safeQuestion(chalk.cyan('Skill knowledge (or Enter for template): '));
+        const skillTitle = await safeQuestion(promptQuestion('questions.skillTitle', 'Skill title: '));
+        const skillDesc = await safeQuestion(promptQuestion('questions.skillDescription', 'Brief description (for /skills listing): '));
+        const skillArgHint = await safeQuestion(promptQuestion('questions.skillArgumentHint', 'Argument hint (optional, e.g. "Describe what to do"): '));
+        const skillBody = await safeQuestion(promptQuestion('questions.skillKnowledge', 'Skill knowledge (or Enter for template): '));
         
         const descLine = skillDesc.trim() || skillTitle.trim() || skillName;
         const argHintLine = skillArgHint.trim() ? `\nargument-hint: "${skillArgHint.trim()}"` : '';
@@ -5916,7 +8189,7 @@ async function runSapper() {
           continue;
         }
         try {
-          const fetchSpinner = ora({ text: chalk.cyan(`🌐 Fetching ${url}...`), spinner: 'dots' }).start();
+          const fetchSpinner = ora({ text: chalk.cyan(`${uiCleanMode() ? 'Fetching' : '🌐 Fetching'} ${url}...`), spinner: 'dots' }).start();
           const rawContent = await fetchUrl(url);
           fetchSpinner.stop();
           
@@ -5932,12 +8205,17 @@ async function runSapper() {
           }
           
           if (text.trim().length > 0) {
-            const webContent = `\n\n══════════════════════════════════════\n🌐 WEB PAGE CONTENT\n══════════════════════════════════════\n\nURL: ${url}\n\n${text}\n`;
+            const webTitle = uiCleanMode() ? 'WEB PAGE CONTENT' : '🌐 WEB PAGE CONTENT';
+            const webContent = `\n\n══════════════════════════════════════\n${webTitle}\n══════════════════════════════════════\n\nURL: ${url}\n\n${text}\n`;
             messages.push({ role: 'user', content: `I fetched this web page for reference:\n${webContent}\n\nUse this information to help me.` });
             ensureSapperDir();
             fs.writeFileSync(CONTEXT_FILE, JSON.stringify(messages, null, 2));
-            console.log(chalk.green(`🌐 Fetched: ${url} (${Math.round(text.length/1024)}KB)`));
-            console.log(chalk.gray('📝 Added to context. AI can now reference this page.\n'));
+            console.log(uiCleanMode()
+              ? chalk.green(`Fetched: ${url} (${Math.round(text.length/1024)}KB)`)
+              : chalk.green(`🌐 Fetched: ${url} (${Math.round(text.length/1024)}KB)`));
+            console.log(uiCleanMode()
+              ? chalk.gray('Added to context. AI can now reference this page.\n')
+              : chalk.gray('📝 Added to context. AI can now reference this page.\n'));
           } else {
             console.log(chalk.yellow('⚠️  No readable content found on that page.'));
           }
@@ -5961,7 +8239,9 @@ async function runSapper() {
           continue;
         }
         
-        console.log(chalk.cyan(`\n🔍 Searching memory for: "${query}"...`));
+        console.log(uiCleanMode()
+          ? chalk.cyan(`\nSearching memory for: "${query}"...`)
+          : chalk.cyan(`\n🔍 Searching memory for: "${query}"...`));
         const relevant = await findRelevantContext(query, embeddings, 3);
         
         if (relevant.length === 0) {
@@ -5979,7 +8259,7 @@ async function runSapper() {
           });
           
           // Optionally add to context
-          const addToContext = await safeQuestion(chalk.yellow('Add to current context? ') + chalk.gray('(y/n): '));
+          const addToContext = await safeQuestion(chalk.yellow(promptLabel('questions.addMemoryToCurrentContext', 'Add to current context? (y/n): ')));
           if (addToContext.toLowerCase() === 'y') {
             const contextAddition = relevant.map(c => c.text).join('\n---\n');
             messages.push({ 
@@ -5991,10 +8271,99 @@ async function runSapper() {
         }
         continue;
       }
+
+      if (input.toLowerCase().startsWith('/memory')) {
+        const rawArgs = input.slice('/memory'.length).trim();
+
+        if (!rawArgs) {
+          const latestNotes = listLongMemoryNotes(6);
+          console.log(chalk.cyan('\nMarkdown Long Memory'));
+          console.log(chalk.gray(`File: ${LONG_MEMORY_FILE}`));
+          if (latestNotes.length) {
+            console.log(chalk.green(`Recent notes (${latestNotes.length}):`));
+            for (const note of latestNotes) {
+              console.log(`  - ${note}`);
+            }
+          } else {
+            console.log(chalk.gray('No notes yet. Save one with /memory add title ::: note'));
+          }
+          console.log(chalk.gray('Commands: /memory add title ::: note ::: tags | /memory save note | /memory search query | /memory show'));
+          continue;
+        }
+
+        const lowerArgs = rawArgs.toLowerCase();
+        if (lowerArgs === 'show' || lowerArgs === 'read') {
+          const text = loadLongMemoryText();
+          console.log();
+          console.log(box(truncateToolText(text, 16000), 'Long Memory (.md)', 'magenta'));
+          console.log();
+          continue;
+        }
+
+        if (lowerArgs.startsWith('search ')) {
+          const query = rawArgs.slice(7).trim();
+          if (!query) {
+            console.log(chalk.yellow('Usage: /memory search <query>'));
+            continue;
+          }
+          const matches = searchLongMemoryNotes(query, 5);
+          if (!matches.length) {
+            console.log(chalk.yellow(`No markdown notes found for: ${query}`));
+            continue;
+          }
+
+          console.log(chalk.green(`Found ${matches.length} note match${matches.length === 1 ? '' : 'es'}:\n`));
+          matches.forEach((match, index) => {
+            console.log(box(truncateToolText(match, 1200), `Note ${index + 1}`, 'magenta'));
+            console.log();
+          });
+          continue;
+        }
+
+        if (lowerArgs.startsWith('save ')) {
+          const note = rawArgs.slice(5).trim();
+          if (!note) {
+            console.log(chalk.yellow('Usage: /memory save <note>'));
+            continue;
+          }
+          const saved = appendLongMemoryNote({ content: note, source: 'manual-save' });
+          if (!saved.ok) {
+            console.log(chalk.red(`Failed to save note: ${saved.error}`));
+            continue;
+          }
+          console.log(chalk.green(`Saved note: ${saved.title}`));
+          continue;
+        }
+
+        if (lowerArgs.startsWith('add ')) {
+          const payload = rawArgs.slice(4).trim();
+          const parts = payload.split(':::').map(part => part.trim());
+          if (parts.length < 2 || !parts[0] || !parts[1]) {
+            console.log(chalk.yellow('Usage: /memory add <title> ::: <note> ::: <optional tags>'));
+            continue;
+          }
+          const saved = appendLongMemoryNote({
+            title: parts[0],
+            content: parts[1],
+            tags: parts[2] || '',
+            source: 'manual-add',
+          });
+          if (!saved.ok) {
+            console.log(chalk.red(`Failed to save note: ${saved.error}`));
+            continue;
+          }
+          const tagPart = saved.tags.length ? ` [${saved.tags.join(', ')}]` : '';
+          console.log(chalk.green(`Saved note: ${saved.title}${tagPart}`));
+          continue;
+        }
+
+        console.log(chalk.yellow('Usage: /memory | /memory show | /memory search <query> | /memory save <note> | /memory add <title> ::: <note> ::: <optional tags>'));
+        continue;
+      }
       
       // Handle codebase scan command
       if (input.toLowerCase() === '/scan') {
-        console.log(chalk.cyan('\n🔍 Scanning codebase...'));
+        console.log(uiCleanMode() ? chalk.cyan('\nScanning codebase...') : chalk.cyan('\n🔍 Scanning codebase...'));
         const scanResult = scanCodebase('.');
         
         if (scanResult.files.length === 0) {
@@ -6006,9 +8375,13 @@ async function runSapper() {
         const includedCount = scanResult.files.filter(f => !f.skipped).length;
         const skippedCount = scanResult.files.filter(f => f.skipped).length;
         
-        console.log(chalk.green(`✅ Scanned ${includedCount} files (~${Math.round(scanResult.totalSize/1024)}KB)`));
+        console.log(uiCleanMode()
+          ? chalk.green(`Scanned ${includedCount} files (~${Math.round(scanResult.totalSize/1024)}KB)`)
+          : chalk.green(`✅ Scanned ${includedCount} files (~${Math.round(scanResult.totalSize/1024)}KB)`));
         if (skippedCount > 0) {
-          console.log(chalk.yellow(`⏭️  Skipped ${skippedCount} files (too large or limit reached)`));
+          console.log(uiCleanMode()
+            ? chalk.yellow(`Skipped ${skippedCount} files (too large or limit reached)`)
+            : chalk.yellow(`⏭️  Skipped ${skippedCount} files (too large or limit reached)`));
         }
         
         // Add scan to context
@@ -6019,7 +8392,32 @@ async function runSapper() {
         
         ensureSapperDir();
         fs.writeFileSync(CONTEXT_FILE, JSON.stringify(messages, null, 2));
-        console.log(chalk.gray('📝 Codebase added to context. AI now has full picture.\n'));
+        console.log(uiCleanMode()
+          ? chalk.gray('Codebase added to context. AI now has full picture.\n')
+          : chalk.gray('📝 Codebase added to context. AI now has full picture.\n'));
+        continue;
+      }
+
+      if (input.startsWith('/') && !input.startsWith('//') && !agentHandled) {
+        const commandToken = input.slice(1).trim().split(/\s+/)[0] || '';
+        const suggestions = suggestSlashCommands(commandToken, 5);
+        if (uiCleanMode()) {
+          const lines = [
+            `${chalk.white(input)}`,
+            suggestions.length > 0 ? UI.slate(`did you mean: ${suggestions.join(', ')}`) : UI.slate('no close command suggestions'),
+            UI.slate('use /commands to view the full command palette'),
+            UI.slate('for literal text starting with /, prefix with //'),
+          ];
+          console.log();
+          console.log(box(lines.join('\n'), 'Unknown Command', 'yellow'));
+        } else {
+          console.log(chalk.yellow(`Unknown command: ${input}`));
+          if (suggestions.length > 0) {
+            console.log(UI.slate(`Did you mean: ${suggestions.join(', ')}`));
+          }
+          console.log(UI.slate('Use /commands to view the full command palette.'));
+          console.log(UI.slate('If you meant literal text that starts with /, prefix it with //'));
+        }
         continue;
       }
       
@@ -6062,7 +8460,7 @@ async function runSapper() {
         
         // Ask for the prompt to go with these files
         console.log();
-        const prompt = await safeQuestion(chalk.cyan('Your prompt for these files: '));
+        const prompt = await safeQuestion(promptQuestion('questions.promptForFiles', 'Your prompt for these files: '));
         
         if (!prompt.trim()) {
           console.log(chalk.gray('Cancelled.'));
@@ -6076,7 +8474,7 @@ async function runSapper() {
         // Continue to AI response (don't use 'continue' here)
       } else {
         // Process @file attachments in prompt (e.g., "analyze @package.json" or "fix @src/index.js")
-      let processedInput = input;
+      let processedInput = input.startsWith('//') ? input.slice(1) : input;
       const fileAttachments = [];
       const attachRegex = /@([\w.\/\-_]+)/g;
       let attachMatch;
@@ -6227,7 +8625,7 @@ async function runSapper() {
       
       let active = true;
       while (active) {
-        if (stepMode) await safeQuestion(chalk.gray('[STEP] Press Enter to let AI think...'));
+        if (stepMode) await safeQuestion(chalk.gray(promptLabel('questions.stepContinue', '[STEP] Press Enter to let AI think...')));
         
         spinner.start('Thinking...');
         const aiStartTime = Date.now();
@@ -6576,6 +8974,14 @@ async function runSapper() {
                   result = tools.find(args.pattern, args.path ?? '.');
                   logEntry('tool', { toolType: 'FIND', path: args.pattern, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
                   break;
+                case 'regex_search':
+                  result = tools.regex(args.pattern, args.include ?? '', args.path ?? '.');
+                  logEntry('tool', { toolType: 'REGEX', path: args.pattern, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+                  break;
+                case 'read_chunk':
+                  result = tools.read_chunk(args.path, args.start, args.end, args.context);
+                  logEntry('file', { action: 'read', path: `${args.path}#L${args.start}-${args.end ?? ''}`, size: result?.length || 0 });
+                  break;
                 case 'pwd':
                   result = tools.pwd();
                   break;
@@ -6598,6 +9004,18 @@ async function runSapper() {
                   result = await tools.recall_memory(args.query);
                   logEntry('tool', { toolType: 'MEMORY', path: args.query, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
                   break;
+                case 'save_memory_note':
+                  result = await tools.save_memory_note(args.title, args.content, args.tags);
+                  logEntry('tool', { toolType: 'MEMORY', path: args.title || 'memory-note', duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+                  break;
+                case 'search_memory_notes':
+                  result = await tools.search_memory_notes(args.query);
+                  logEntry('tool', { toolType: 'MEMORY', path: args.query, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+                  break;
+                case 'read_memory_notes':
+                  result = await tools.read_memory_notes();
+                  logEntry('tool', { toolType: 'MEMORY', path: LONG_MEMORY_FILE, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+                  break;
                 case 'open_url':
                   result = await tools.open_url(args.url);
                   logEntry('tool', { toolType: 'OPEN', path: args.url, duration: Date.now() - toolStart, success: String(result).startsWith('Opened URL'), resultSize: result?.length });
@@ -6803,6 +9221,41 @@ async function runSapper() {
               result = tools.find(path, content);
               logEntry('tool', { toolType: 'FIND', path, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
             }
+            else if (type.toLowerCase() === 'regex') {
+              // Content can be "include" filter (e.g. "js,ts") or "include:::startPath"
+              let include = '';
+              let startPath = '.';
+              if (content) {
+                const idx = content.indexOf(':::');
+                if (idx > -1) {
+                  include = content.substring(0, idx).trim();
+                  startPath = content.substring(idx + 3).trim() || '.';
+                } else {
+                  include = content.trim();
+                }
+              }
+              result = tools.regex(path, include, startPath);
+              logEntry('tool', { toolType: 'REGEX', path, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+            }
+            else if (type.toLowerCase() === 'chunk' || type.toLowerCase() === 'read_chunk') {
+              // Content format: "start-end" or "start:end" or "start,end" (end optional). Extra ":::context" appends context lines.
+              let start = 1, end = null, ctx = 0;
+              if (content) {
+                let main = content.trim();
+                const ctxIdx = main.indexOf(':::');
+                if (ctxIdx > -1) {
+                  ctx = Number(main.substring(ctxIdx + 3).trim()) || 0;
+                  main = main.substring(0, ctxIdx).trim();
+                }
+                const rangeMatch = main.match(/^(\d+)\s*[-:,]\s*(\d+)?$/) || main.match(/^(\d+)$/);
+                if (rangeMatch) {
+                  start = parseInt(rangeMatch[1], 10);
+                  end = rangeMatch[2] ? parseInt(rangeMatch[2], 10) : null;
+                }
+              }
+              result = tools.read_chunk(path, start, end, ctx);
+              logEntry('file', { action: 'read', path: `${path}#L${start}-${end ?? ''}`, size: result?.length || 0 });
+            }
             else if (type.toLowerCase() === 'changes') {
               result = await tools.changes(path);
               logEntry('tool', { toolType: 'CHANGES', path: path || '.', duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
@@ -6815,6 +9268,19 @@ async function runSapper() {
               result = await tools.recall_memory(path);
               logEntry('tool', { toolType: 'MEMORY', path, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
             }
+            else if (type.toLowerCase() === 'memory_note_save') {
+              const [noteContent = '', tagText = ''] = String(content ?? '').split(':::');
+              result = await tools.save_memory_note(path, noteContent, tagText);
+              logEntry('tool', { toolType: 'MEMORY', path, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+            }
+            else if (type.toLowerCase() === 'memory_note_search') {
+              result = await tools.search_memory_notes(path);
+              logEntry('tool', { toolType: 'MEMORY', path, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+            }
+            else if (type.toLowerCase() === 'memory_note_read') {
+              result = await tools.read_memory_notes();
+              logEntry('tool', { toolType: 'MEMORY', path: LONG_MEMORY_FILE, duration: Date.now() - toolStart, success: !String(result).startsWith('Error:'), resultSize: result?.length });
+            }
             else if (type.toLowerCase() === 'open') {
               result = await tools.open_url(path);
               logEntry('tool', { toolType: 'OPEN', path, duration: Date.now() - toolStart, success: String(result).startsWith('Opened URL'), resultSize: result?.length });
@@ -6826,7 +9292,7 @@ async function runSapper() {
             }
 
             // Log tool execution (for non-shell, non-file specific ones)
-            if (!['list', 'ls', 'read', 'cat', 'head', 'tail', 'mkdir', 'rmdir', 'pwd', 'cd', 'write', 'patch', 'search', 'grep', 'find', 'changes', 'fetch', 'memory', 'open', 'shell'].includes(type.toLowerCase())) {
+            if (!['list', 'ls', 'read', 'cat', 'head', 'tail', 'mkdir', 'rmdir', 'pwd', 'cd', 'write', 'patch', 'search', 'grep', 'find', 'regex', 'chunk', 'read_chunk', 'changes', 'fetch', 'memory', 'memory_note_save', 'memory_note_search', 'memory_note_read', 'open', 'shell'].includes(type.toLowerCase())) {
               logEntry('tool', { toolType: type.toUpperCase(), path, duration: Date.now() - toolStart, success: toolSuccess, resultSize: result?.length, error: toolSuccess ? undefined : result });
             }