sapper-iq 1.1.36 → 1.1.38

package/sapper.mjs

@@ -8,7 +8,7 @@ import readline from 'readline';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { marked } from 'marked';
-import TerminalRenderer from 'marked-terminal';
+import { markedTerminal } from 'marked-terminal';
 import * as acorn from 'acorn';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -26,7 +26,7 @@ process.on('unhandledRejection', (reason) => {
 let ctrlCCount = 0;
 process.on('SIGINT', () => {
   ctrlCCount++;
-  if (ctrlCCount >= 2) {
+  if (ctrlCCount >= 3) {
     console.log(chalk.red('\nForce quitting...'));
     process.exit(1);
   }
@@ -36,7 +36,11 @@ process.on('SIGINT', () => {
   // Clear current line and move to new one - stops ghost output
   process.stdout.clearLine(0);
   process.stdout.cursorTo(0);
-  console.log(chalk.yellow('\n⏹️  Stopping response... (Ctrl+C again to force quit)'));
+  if (ctrlCCount >= 2) {
+    console.log(chalk.yellow('\n⏹️  Press Ctrl+C once more to force quit'));
+  } else {
+    console.log(UI.slate('\n⏹️  Stopped'));
+  }
   
   // Reset terminal immediately
   resetTerminal();
@@ -76,6 +80,7 @@ const CONFIG_FILE = `${SAPPER_DIR}/config.json`;
 const AGENTS_DIR = `${SAPPER_DIR}/agents`;
 const SKILLS_DIR = `${SAPPER_DIR}/skills`;
 const LOGS_DIR = `${SAPPER_DIR}/logs`;
+const SAPPERIGNORE_FILE = '.sapperignore';
 
 // ═══════════════════════════════════════════════════════════════
 // COMPREHENSIVE ACTIVITY LOGGER
@@ -300,6 +305,156 @@ function ensureSapperDir() {
   }
 }
 
+// Default .sapperignore template — created on first run
+const DEFAULT_SAPPERIGNORE = `# ═══════════════════════════════════════════════════════════════
+# .sapperignore — Files and folders Sapper should ignore
+# Works like .gitignore: one pattern per line, # for comments
+# Edit this file to customize what Sapper skips
+# ═══════════════════════════════════════════════════════════════
+
+# ── Sapper internal ──
+.sapper/
+
+# ── Dependencies ──
+node_modules/
+vendor/
+bower_components/
+
+# ── Build outputs ──
+dist/
+build/
+out/
+.next/
+.nuxt/
+.output/
+.vercel/
+.netlify/
+
+# ── Environment & secrets ──
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.cert
+
+# ── Version control ──
+.git/
+.svn/
+.hg/
+
+# ── IDE / Editor ──
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# ── OS files ──
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# ── Caches ──
+.cache/
+__pycache__/
+*.pyc
+.pytest_cache/
+.mypy_cache/
+
+# ── Coverage & tests ──
+coverage/
+.nyc_output/
+htmlcov/
+
+# ── Logs ──
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# ── Lock files (large) ──
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+composer.lock
+Gemfile.lock
+Cargo.lock
+
+# ── Compiled / binary / large ──
+*.min.js
+*.min.css
+*.map
+*.bundle.js
+*.chunk.js
+*.wasm
+*.so
+*.dylib
+*.dll
+*.exe
+*.o
+*.a
+*.class
+*.jar
+*.war
+*.zip
+*.tar.gz
+*.tgz
+*.rar
+*.7z
+*.iso
+*.dmg
+
+# ── Media (large files) ──
+*.mp4
+*.mp3
+*.avi
+*.mov
+*.mkv
+*.wav
+*.flac
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.bmp
+*.ico
+*.svg
+*.webp
+*.ttf
+*.woff
+*.woff2
+*.eot
+*.otf
+*.pdf
+
+# ── Database ──
+*.sqlite
+*.sqlite3
+*.db
+
+# ── Terraform / IaC ──
+.terraform/
+*.tfstate
+*.tfstate.*
+
+# ── Docker ──
+*.tar
+
+# ── Gradle / Maven ──
+.gradle/
+target/
+`;
+
+// Create .sapperignore if it doesn't exist (runs on startup)
+function ensureSapperIgnore() {
+  if (!fs.existsSync(SAPPERIGNORE_FILE)) {
+    fs.writeFileSync(SAPPERIGNORE_FILE, DEFAULT_SAPPERIGNORE);
+    return true; // newly created
+  }
+  return false;
+}
+
 // Ensure agents and skills directories exist
 function ensureAgentsDirs() {
   ensureSapperDir();
@@ -663,7 +818,10 @@ function buildSystemPrompt(agentContent = null, skillContents = []) {
   const now = new Date();
   const dateStr = now.toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
   const timeStr = now.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
-  let prompt = `You are Sapper, an intelligent AI assistant with access to the local filesystem and shell.
+  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.
 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.
 
@@ -675,6 +833,9 @@ RULES:
 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 += `
@@ -686,7 +847,12 @@ Available tools: list_directory, read_file, search_files, write_file, patch_file
 PATCH TIPS:
 - For patch_file, set old_text to "LINE:<number>" to replace a specific line by number (most reliable).
 - Always read_file first to see exact content before using patch_file.
-- If a patch fails, do NOT retry with slight variations. Switch to LINE:number mode or use write_file instead.`;
+- If a patch fails, do NOT retry with slight variations. Switch to LINE:number mode or use write_file instead.
+
+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 += `
 
@@ -704,6 +870,11 @@ PATCH TIPS:
 - Always READ the file first to see exact content before using PATCH.
 - If a PATCH fails, do NOT retry with slight variations. Switch to LINE:number mode or use WRITE instead.
 
+SHELL TIPS:
+- Long-running commands may be moved to a background shell session depending on config.
+- If shell output mentions a session id, inspect more output with [TOOL:SHELL]__shell_read__ <session_id>[/TOOL].
+- 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.`;
   }
@@ -739,6 +910,10 @@ FORBIDDEN TOOLS (DO NOT USE): ${forbidden.join(', ')}. You MUST NOT attempt to u
     prompt += `\n═══ END SKILLS ═══\n\nUse the knowledge from the loaded skills above when relevant to the user's request.`;
   }
 
+  if (promptAppend) {
+    prompt += wrapPromptCustomizationBlock('CUSTOM PROMPT APPEND', promptAppend);
+  }
+
   return prompt;
 }
 
@@ -747,25 +922,413 @@ 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
 
-// Load config (settings like autoAttach)
+const DEFAULT_CONFIG = Object.freeze({
+  autoAttach: true,
+  contextLimit: null,
+  toolRoundLimit: 40,
+  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') {
+    const normalized = value.trim().toLowerCase();
+    if (['true', '1', 'yes', 'on'].includes(normalized)) return true;
+    if (['false', '0', 'no', 'off'].includes(normalized)) return false;
+  }
+  return fallback;
+}
+
+function normalizeContextLimit(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed) : null;
+}
+
+function normalizeSummarizeTriggerPercent(value) {
+  let parsed = Number(value);
+  if (!Number.isFinite(parsed)) return DEFAULT_CONFIG.summarizeTriggerPercent;
+  if (parsed > 0 && parsed <= 1) parsed *= 100;
+  return Math.max(40, Math.min(90, Math.round(parsed)));
+}
+
+function normalizeToolRoundLimit(value) {
+  return normalizeIntegerInRange(value, DEFAULT_CONFIG.toolRoundLimit, 1, 200);
+}
+
+function normalizeThinkingMode(value) {
+  if (typeof value === 'boolean') return value ? 'on' : 'off';
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (['on', 'true', '1', 'yes', 'enable', 'enabled', 'always'].includes(normalized)) return 'on';
+  if (['off', 'false', '0', 'no', 'disable', 'disabled', 'never'].includes(normalized)) return 'off';
+  return 'auto';
+}
+
+function normalizeShellBackgroundMode(value) {
+  if (typeof value === 'boolean') return value ? 'on' : 'off';
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (['on', 'true', '1', 'yes', 'enable', 'enabled', 'always'].includes(normalized)) return 'on';
+  if (['off', 'false', '0', 'no', 'disable', 'disabled', 'never'].includes(normalized)) return 'off';
+  return 'auto';
+}
+
+function normalizeThinkingConfig(thinkingConfig = {}) {
+  if (typeof thinkingConfig === 'boolean' || typeof thinkingConfig === 'string') {
+    return { mode: normalizeThinkingMode(thinkingConfig) };
+  }
+
+  if (!thinkingConfig || typeof thinkingConfig !== 'object' || Array.isArray(thinkingConfig)) {
+    return { ...DEFAULT_CONFIG.thinking };
+  }
+
+  return {
+    mode: normalizeThinkingMode(thinkingConfig.mode),
+  };
+}
+
+function normalizeShellConfig(shellConfig = {}) {
+  if (typeof shellConfig === 'boolean' || typeof shellConfig === 'string') {
+    return {
+      ...DEFAULT_CONFIG.shell,
+      backgroundMode: normalizeShellBackgroundMode(shellConfig),
+    };
+  }
+
+  if (!shellConfig || typeof shellConfig !== 'object' || Array.isArray(shellConfig)) {
+    return { ...DEFAULT_CONFIG.shell };
+  }
+
+  return {
+    streamToModel: normalizeBoolean(shellConfig.streamToModel, DEFAULT_CONFIG.shell.streamToModel),
+    backgroundMode: normalizeShellBackgroundMode(shellConfig.backgroundMode),
+    backgroundAfterSeconds: normalizeIntegerInRange(shellConfig.backgroundAfterSeconds, DEFAULT_CONFIG.shell.backgroundAfterSeconds, 2, 120),
+    outputChunkChars: normalizeIntegerInRange(shellConfig.outputChunkChars, DEFAULT_CONFIG.shell.outputChunkChars, 400, 12000),
+  };
+}
+
+function normalizeIntegerInRange(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(parsed)));
+}
+
+function normalizeStreamingConfig(streamingConfig = {}) {
+  if (typeof streamingConfig === 'boolean') {
+    return {
+      ...DEFAULT_CONFIG.streaming,
+      showPhaseStatus: streamingConfig,
+      showHeartbeat: streamingConfig,
+    };
+  }
+
+  if (!streamingConfig || typeof streamingConfig !== 'object' || Array.isArray(streamingConfig)) {
+    return { ...DEFAULT_CONFIG.streaming };
+  }
+
+  return {
+    showPhaseStatus: normalizeBoolean(streamingConfig.showPhaseStatus, DEFAULT_CONFIG.streaming.showPhaseStatus),
+    showHeartbeat: normalizeBoolean(streamingConfig.showHeartbeat, DEFAULT_CONFIG.streaming.showHeartbeat),
+    idleNoticeSeconds: normalizeIntegerInRange(streamingConfig.idleNoticeSeconds, DEFAULT_CONFIG.streaming.idleNoticeSeconds, 2, 60),
+  };
+}
+
+function normalizePromptText(value) {
+  if (typeof value === 'string') return value;
+  if (value === null || value === undefined) return '';
+  return String(value);
+}
+
+function normalizePromptConfig(promptConfig = {}) {
+  if (!promptConfig || typeof promptConfig !== 'object' || Array.isArray(promptConfig)) {
+    return {
+      ...DEFAULT_CONFIG.prompt,
+      append: normalizePromptText(promptConfig),
+    };
+  }
+
+  const coreOverride = promptConfig.coreOverride !== undefined
+    ? promptConfig.coreOverride
+    : promptConfig.override;
+
+  return {
+    prepend: normalizePromptText(promptConfig.prepend),
+    append: normalizePromptText(promptConfig.append),
+    coreOverride: normalizePromptText(coreOverride),
+  };
+}
+
+function normalizeConfig(config = {}) {
+  return {
+    ...config,
+    autoAttach: normalizeBoolean(config.autoAttach, DEFAULT_CONFIG.autoAttach),
+    contextLimit: normalizeContextLimit(config.contextLimit),
+    toolRoundLimit: normalizeToolRoundLimit(config.toolRoundLimit),
+    summaryPhases: normalizeBoolean(config.summaryPhases, DEFAULT_CONFIG.summaryPhases),
+    summarizeTriggerPercent: normalizeSummarizeTriggerPercent(config.summarizeTriggerPercent),
+    shell: normalizeShellConfig(config.shell),
+    streaming: normalizeStreamingConfig(config.streaming),
+    thinking: normalizeThinkingConfig(config.thinking),
+    prompt: normalizePromptConfig(config.prompt),
+  };
+}
+
+// Load config (settings like autoAttach and context summarization)
 function loadConfig() {
   try {
     ensureSapperDir();
     if (fs.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      const rawConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      const normalizedConfig = normalizeConfig(rawConfig);
+      if (JSON.stringify(rawConfig) !== JSON.stringify(normalizedConfig)) {
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(normalizedConfig, null, 2));
+      }
+      return normalizedConfig;
     }
   } catch (e) {}
-  return { autoAttach: true }; // Default: auto-attach related files is ON
+
+  const defaultConfig = normalizeConfig();
+  try {
+    ensureSapperDir();
+    if (!fs.existsSync(CONFIG_FILE)) {
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(defaultConfig, null, 2));
+    }
+  } catch (e) {}
+  return defaultConfig;
 }
 
 function saveConfig(config) {
   ensureSapperDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  const normalizedConfig = normalizeConfig(config);
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(normalizedConfig, null, 2));
+  sapperConfig = normalizedConfig;
 }
 
 // Global config
 let sapperConfig = loadConfig();
 
+// Effective context length — user limit overrides model's reported size
+function effectiveContextLength() {
+  if (sapperConfig.contextLimit && sapperConfig.contextLimit > 0) {
+    return sapperConfig.contextLimit;
+  }
+  return modelContextLength;
+}
+
+const SUMMARY_PHASES = [
+  'Prepare summary request',
+  'Summarize older messages',
+  'Save compressed context',
+  'Resume your prompt',
+];
+
+function summaryPhasesEnabled() {
+  return sapperConfig.summaryPhases !== false;
+}
+
+function toolRoundLimit() {
+  return normalizeToolRoundLimit(sapperConfig.toolRoundLimit);
+}
+
+function getShellConfig() {
+  return normalizeShellConfig(sapperConfig.shell);
+}
+
+function shellStreamToModelEnabled() {
+  return getShellConfig().streamToModel;
+}
+
+function shellBackgroundMode() {
+  return getShellConfig().backgroundMode;
+}
+
+function shellBackgroundAfterSeconds() {
+  return getShellConfig().backgroundAfterSeconds;
+}
+
+function shellOutputChunkChars() {
+  return getShellConfig().outputChunkChars;
+}
+
+function summaryTriggerPercent() {
+  return normalizeSummarizeTriggerPercent(sapperConfig.summarizeTriggerPercent);
+}
+
+function summaryTokenThreshold(ctxLen) {
+  return ctxLen ? Math.floor(ctxLen * (summaryTriggerPercent() / 100)) : 8000;
+}
+
+function parseSummaryTriggerInput(value) {
+  if (value === undefined || value === null) return null;
+  const normalized = String(value).trim().replace(/%$/, '');
+  if (!normalized) return null;
+
+  let parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) return null;
+  if (parsed > 0 && parsed <= 1) parsed *= 100;
+
+  return Math.max(40, Math.min(90, Math.round(parsed)));
+}
+
+function summaryPhaseText(stepNumber, detail = '') {
+  const fallback = SUMMARY_PHASES[stepNumber - 1] || 'Context summarization';
+  if (!summaryPhasesEnabled()) {
+    return detail || fallback;
+  }
+  return detail
+    ? `Step ${stepNumber}/${SUMMARY_PHASES.length} ${detail}`
+    : `Step ${stepNumber}/${SUMMARY_PHASES.length} ${fallback}`;
+}
+
+function renderSummaryPhaseList(activeStep = null) {
+  return SUMMARY_PHASES
+    .map((label, index) => {
+      const stepNumber = index + 1;
+      const line = `Step ${stepNumber}/${SUMMARY_PHASES.length} ${label}`;
+      return activeStep === stepNumber ? chalk.cyan(line) : UI.slate(line);
+    })
+    .join('\n');
+}
+
+function getPromptConfig() {
+  return normalizePromptConfig(sapperConfig.prompt);
+}
+
+function getThinkingConfig() {
+  return normalizeThinkingConfig(sapperConfig.thinking);
+}
+
+function getStreamingConfig() {
+  return normalizeStreamingConfig(sapperConfig.streaming);
+}
+
+function streamPhaseStatusEnabled() {
+  return getStreamingConfig().showPhaseStatus;
+}
+
+function streamHeartbeatEnabled() {
+  return getStreamingConfig().showHeartbeat;
+}
+
+function streamIdleNoticeSeconds() {
+  return getStreamingConfig().idleNoticeSeconds;
+}
+
+function thinkingMode() {
+  return getThinkingConfig().mode;
+}
+
+function normalizeThinkingInput(input = '') {
+  let normalized = String(input ?? '').trim();
+  if (normalized.startsWith('/') && normalized.includes(' ')) {
+    normalized = normalized.substring(normalized.indexOf(' ') + 1).trim();
+  }
+  return normalized;
+}
+
+function isSimplePrompt(input = '') {
+  const normalized = normalizeThinkingInput(input).toLowerCase();
+  if (!normalized) return true;
+  if (normalized.includes('\n')) return false;
+  if (/@|https?:\/\//.test(normalized)) return false;
+  if (/[`{}[\]();<>]/.test(normalized)) return false;
+  if (/^(hi|hello|hey|thanks|thank you|ok|okay|continue|go on|proceed|yes|no|y|n|cool|nice|bye|good morning|good evening)$/.test(normalized)) {
+    return true;
+  }
+  if (/\b(analyze|debug|fix|implement|refactor|design|plan|optimi[sz]e|architect|investigate|review|build|create|generate|search|find|error|bug|test|compare|explain deeply)\b/.test(normalized)) {
+    return false;
+  }
+  if (normalized.length <= 32) return true;
+  return normalized.length <= 60 && normalized.split(/\s+/).length <= 8;
+}
+
+function shouldUseThinkingForInput(input = '') {
+  const mode = thinkingMode();
+  if (mode === 'on') return true;
+  if (mode === 'off') return false;
+  return !isSimplePrompt(input);
+}
+
+function isLikelyLongRunningCommand(command = '') {
+  const normalized = String(command ?? '').trim().toLowerCase();
+  if (!normalized) return false;
+
+  const patterns = [
+    /\buvicorn\b/,
+    /\bnpm\s+run\s+(dev|start|watch)\b/,
+    /\bpnpm\s+(dev|start|watch)\b/,
+    /\byarn\s+(dev|start|watch)\b/,
+    /\bnext\s+dev\b/,
+    /\bvite\b/,
+    /\bnodemon\b/,
+    /\bdocker\s+compose\s+up\b/,
+    /\bwebpack(?:\s+serve|\s+--watch)?\b/,
+    /\bpython\s+-m\s+http\.server\b/,
+    /\btail\s+-f\b/,
+    /\bserve\b/,
+    /--reload\b/,
+    /--watch\b/
+  ];
+
+  return patterns.some(pattern => pattern.test(normalized));
+}
+
+function shouldBackgroundShellCommand(command = '') {
+  const mode = shellBackgroundMode();
+  if (mode === 'off') return false;
+  if (mode === 'on') return true;
+  return isLikelyLongRunningCommand(command);
+}
+
+function hasCustomPromptConfig() {
+  const promptConfig = getPromptConfig();
+  return Boolean(promptConfig.prepend.trim() || promptConfig.append.trim() || promptConfig.coreOverride.trim());
+}
+
+function wrapPromptCustomizationBlock(title, content, leadingNewline = true) {
+  const normalized = String(content ?? '').trim();
+  if (!normalized) return '';
+  const prefix = leadingNewline ? '\n\n' : '';
+  return `${prefix}═══ ${title} ═══\n${normalized}\n═══ END ${title} ═══`;
+}
+
+function resolveLoadedSkillContents() {
+  const allSkills = loadSkills();
+  return loadedSkills.map(skillName => allSkills[skillName]?.content || '').filter(Boolean);
+}
+
+function resolveActiveAgentContent() {
+  if (!currentAgent) return null;
+  const allAgents = loadAgents();
+  return allAgents[currentAgent]?.content || null;
+}
+
+function refreshSystemPrompt(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return;
+  messages[0] = {
+    role: 'system',
+    content: buildSystemPrompt(resolveActiveAgentContent(), resolveLoadedSkillContents())
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════
 // WORKSPACE GRAPH - Track file relationships and summaries
 // ═══════════════════════════════════════════════════════════════
@@ -876,9 +1439,10 @@ async function buildWorkspaceGraph(showProgress = true) {
         const fullPath = dir === '.' ? entry.name : `${dir}/${entry.name}`;
         
         if (entry.isDirectory()) {
-          if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+          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;
           
@@ -1298,18 +1862,41 @@ async function addToEmbeddings(text, embeddings) {
 // SMART CONTEXT SUMMARIZATION
 // ═══════════════════════════════════════════════════════════════
 
-async function autoSummarizeContext(messages, model) {
+async function autoSummarizeContext(messages, model, force = false) {
+  // Use real token-based threshold if we know the model's context length
+  const estimatedTokens = estimateMessagesTokens(messages);
   const contextSize = JSON.stringify(messages).length;
-  if (contextSize <= 32000 || messages.length <= 5) return messages;
+  
+  // Summarize when we hit the configured share of the effective context window
+  const ctxLen = effectiveContextLength();
+  const tokenThreshold = summaryTokenThreshold(ctxLen);
+  // Also keep the old byte-based check as a fallback
+  const shouldSummarize = (ctxLen && estimatedTokens > tokenThreshold) || 
+                          (!ctxLen && contextSize > 32000);
+  
+  if ((!force && !shouldSummarize) || messages.length <= 5) return messages;
+
+  const usagePercent = ctxLen 
+    ? Math.round((estimatedTokens / ctxLen) * 100)
+    : Math.round((contextSize / 32000) * 100);
 
   console.log();
-  console.log(box(
-    `Context is ${chalk.red.bold(Math.round(contextSize / 1024) + 'KB')} (${messages.length} messages)\n` +
-    `${chalk.cyan('Auto-summarizing via AI to keep things fast...')}`,
-    '🧠 Smart Summary', 'cyan'
-  ));
+  const summaryIntroLines = [
+    `Context: ~${chalk.red.bold(estimatedTokens.toLocaleString())} tokens / ${chalk.white(ctxLen ? ctxLen.toLocaleString() : '?')} max (${chalk.red.bold(usagePercent + '%')})`,
+    chalk.gray(`${messages.length} messages, ${Math.round(contextSize / 1024)}KB raw`),
+    chalk.cyan('Auto-summarizing to stay within context window before answering your prompt...'),
+    chalk.gray(`Trigger: ${summaryTriggerPercent()}% of the active context window (${tokenThreshold.toLocaleString()} tokens)`),
+    chalk.gray('This is an extra model call, so large contexts can pause here for a while.'),
+  ];
+  if (summaryPhasesEnabled()) {
+    summaryIntroLines.push('');
+    summaryIntroLines.push(renderSummaryPhaseList(1));
+  }
+  console.log(box(summaryIntroLines.join('\n'), '🧠 Context Window Management', 'cyan'));
 
-  const summarySpinner = ora('Summarizing conversation...').start();
+  const summaryStart = Date.now();
+  const elapsedSummaryTime = () => `${Math.max(0, Math.round((Date.now() - summaryStart) / 1000))}s`;
+  const summarySpinner = ora(summaryPhaseText(1, 'Preparing summary request...')).start();
 
   // Separate: system prompt, messages to summarize, recent messages to keep
   const systemPrompt = messages[0];
@@ -1363,13 +1950,13 @@ async function autoSummarizeContext(messages, model) {
     })
     .join('\n\n');
 
+  const conversationTokens = estimateTokens(conversationText);
+  const conversationBytes = Buffer.byteLength(conversationText, 'utf8');
+  summarySpinner.text = summaryPhaseText(1, `Preparing summary request from ${oldMessages.length} older messages (~${conversationTokens.toLocaleString()} tokens, ${formatBytes(conversationBytes)})`);
+  let spinnerInterval = null;
+
   try {
-    const summaryResponse = await ollama.chat({
-      model,
-      messages: [
-        {
-          role: 'system',
-          content: `You are a conversation summarizer for an AI coding agent called Sapper. Produce a concise but thorough summary of the conversation below. Include:
+    const summaryInstruction = `You are a conversation summarizer for an AI coding agent called Sapper. Produce a concise but thorough summary of the conversation below. Include:
 - Key topics discussed and decisions made
 - Files that were read, created, or modified (with paths)
 - Important code changes or bugs found
@@ -1381,7 +1968,20 @@ async function autoSummarizeContext(messages, model) {
 
 CRITICAL: The AI assistant uses tools with syntax like [TOOL:READ]path[/TOOL]. Make sure to note which tools were used so the assistant remembers to keep using them after this summary.
 
-Output ONLY the summary, no preamble. Keep it under 800 words. Use bullet points.`
+Output ONLY the summary, no preamble. Keep it under 800 words. Use bullet points.`;
+    const summaryInputTokens = estimateTokens(summaryInstruction) + estimateTokens(`Summarize this conversation:\n\n${conversationText}`);
+    summarySpinner.text = summaryPhaseText(2, `Waiting for ${model} to summarize (~${summaryInputTokens.toLocaleString()} tokens, ${elapsedSummaryTime()} elapsed)`);
+    spinnerInterval = setInterval(() => {
+      summarySpinner.text = summaryPhaseText(2, `Waiting for ${model} to summarize (~${summaryInputTokens.toLocaleString()} tokens, ${elapsedSummaryTime()} elapsed)`);
+    }, 1000);
+
+    const summaryResponse = await ollama.chat({
+      model,
+      ...(effectiveContextLength() ? { options: { num_ctx: effectiveContextLength() } } : {}),
+      messages: [
+        {
+          role: 'system',
+          content: summaryInstruction
         },
         {
           role: 'user',
@@ -1390,10 +1990,13 @@ Output ONLY the summary, no preamble. Keep it under 800 words. Use bullet points
       ],
       stream: false
     });
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
 
     const summary = summaryResponse.message.content;
 
     // Save old messages to embeddings before discarding
+    summarySpinner.text = summaryPhaseText(3, `Saving compressed context and memory (${elapsedSummaryTime()} elapsed)`);
     const embeddings = loadEmbeddings();
     const textToEmbed = oldMessages
       .filter(m => m.role !== 'system')
@@ -1444,19 +2047,31 @@ Output ONLY the summary, no preamble. Keep it under 800 words. Use bullet points
     fs.writeFileSync(CONTEXT_FILE, JSON.stringify(newMessages, null, 2));
 
     const newSize = JSON.stringify(newMessages).length;
+    const newTokens = estimateMessagesTokens(newMessages);
     summarySpinner.stop();
-    console.log(chalk.green(`✅ Summarized! ${chalk.gray(`${Math.round(contextSize / 1024)}KB → ${Math.round(newSize / 1024)}KB`)} (${messages.length} → ${newMessages.length} messages)`));
+    if (summaryPhasesEnabled()) {
+      console.log(chalk.gray(`   ${summaryPhaseText(4, 'Context ready. Returning to chat...')}`));
+    }
+    console.log(chalk.green(`✅ Summarized! ~${chalk.white(estimatedTokens.toLocaleString())} → ~${chalk.white(newTokens.toLocaleString())} tokens (${messages.length} → ${newMessages.length} messages)`));
+    if (ctxLen) {
+      const newPercent = Math.round((newTokens / ctxLen) * 100);
+      console.log(chalk.gray(`   📊 Context window usage: ${newPercent}% of ${ctxLen.toLocaleString()} tokens`));
+      if (newPercent >= 80) {
+        console.log(chalk.yellow('   ⚠️  Context is still dense, so the next reply may still be slower than usual.'));
+      }
+    }
     if (embeddings.chunks.length > 0) {
       console.log(chalk.gray(`   🧠 Old context saved to memory (${embeddings.chunks.length} memories)`));
     }
     logEntry('summary', {
-      before: `${Math.round(contextSize / 1024)}KB / ${messages.length} msgs`,
-      after: `${Math.round(newSize / 1024)}KB / ${newMessages.length} msgs`
+      before: `~${estimatedTokens.toLocaleString()} tokens / ${messages.length} msgs`,
+      after: `~${newTokens.toLocaleString()} tokens / ${newMessages.length} msgs`
     });
     console.log();
 
     return newMessages;
   } catch (e) {
+    if (spinnerInterval) clearInterval(spinnerInterval);
     summarySpinner.stop();
     console.log(chalk.yellow(`⚠️  Auto-summary failed: ${e.message}`));
     console.log(chalk.gray('   Tip: Use /prune to manually reduce context.\n'));
@@ -1468,64 +2083,468 @@ Output ONLY the summary, no preamble. Keep it under 800 words. Use bullet points
 // FANCY UI HELPERS
 // ═══════════════════════════════════════════════════════════════
 
-const BANNER = `
-${chalk.cyan('  ███████╗ █████╗ ██████╗ ██████╗ ███████╗██████╗ ')}
-${chalk.cyan('  ██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗')}
-${chalk.cyan('  ███████╗███████║██████╔╝██████╔╝█████╗  ██████╔╝')}
-${chalk.cyan('  ╚════██║██╔══██║██╔═══╝ ██╔═══╝ ██╔══╝  ██╔══██╗')}
-${chalk.cyan('  ███████║██║  ██║██║     ██║     ███████╗██║  ██║')}
-${chalk.cyan('  ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝     ╚══════╝╚═╝  ╚═╝')}
-`;
+const UI = {
+  accent: chalk.hex('#7cc4ff'),
+  accentSoft: chalk.hex('#b8d9ff'),
+  mint: chalk.hex('#9ad7b3'),
+  gold: chalk.hex('#d8bc7a'),
+  coral: chalk.hex('#de9d8f'),
+  slate: chalk.hex('#8a95a6'),
+  ink: chalk.hex('#e6ebf2'),
+};
 
-function box(content, title = '', color = 'cyan') {
-  const lines = content.split('\n');
-  const maxLen = Math.max(...lines.map(l => l.length), title.length + 4);
-  const colorFn = chalk[color] || chalk.cyan;
-  
-  let result = colorFn('╭' + (title ? `─ ${title} ` : '') + '─'.repeat(maxLen - title.length - (title ? 3 : 0)) + '╮') + '\n';
-  for (const line of lines) {
-    result += colorFn('│') + ' ' + line.padEnd(maxLen) + ' ' + colorFn('│') + '\n';
+const BOX_TONES = {
+  cyan: UI.accent,
+  green: UI.mint,
+  yellow: UI.gold,
+  red: UI.coral,
+  magenta: chalk.hex('#b7b9ff'),
+  gray: UI.slate,
+  blue: chalk.hex('#8fb6ff'),
+};
+
+const BADGE_STYLES = {
+  info: UI.accent,
+  success: UI.mint,
+  warning: UI.gold,
+  error: UI.coral,
+  action: chalk.hex('#9bbcff'),
+  neutral: UI.slate,
+};
+
+const ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/g;
+
+function stripAnsi(value = '') {
+  return String(value).replace(ANSI_PATTERN, '');
+}
+
+function visibleLength(value = '') {
+  return stripAnsi(value).length;
+}
+
+function terminalWidth(max = 98) {
+  return Math.max(48, Math.min(max, process.stdout.columns || 88));
+}
+
+function toneColor(tone = 'cyan') {
+  return BOX_TONES[tone] || chalk.cyan;
+}
+
+function padAnsi(value = '', width = 0) {
+  return `${value}${' '.repeat(Math.max(0, width - visibleLength(value)))}`;
+}
+
+function formatBytes(bytes = 0) {
+  if (!bytes || bytes < 1024) return `${bytes || 0} B`;
+
+  const units = ['KB', 'MB', 'GB', 'TB'];
+  let size = bytes / 1024;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
   }
-  result += colorFn('╰' + '─'.repeat(maxLen + 2) + '╯');
-  return result;
+
+  const precision = size >= 100 ? 0 : size >= 10 ? 1 : 2;
+  return `${size.toFixed(precision)} ${units[unitIndex]}`;
 }
 
-function divider(char = '─', color = 'gray') {
-  const width = process.stdout.columns || 60;
-  return chalk[color](char.repeat(Math.min(width, 60)));
+function formatRelativeTime(value) {
+  if (!value) return 'unknown';
+
+  const delta = Math.max(0, Date.now() - new Date(value).getTime());
+  const units = [
+    ['d', 24 * 60 * 60 * 1000],
+    ['h', 60 * 60 * 1000],
+    ['m', 60 * 1000],
+  ];
+
+  for (const [label, size] of units) {
+    const amount = Math.floor(delta / size);
+    if (amount >= 1) return `${amount}${label} ago`;
+  }
+
+  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 box(content, title = '', tone = 'cyan', options = {}) {
+  const width = Math.max(28, Math.min(options.width || terminalWidth(72), terminalWidth(72)));
+  const header = title ? `${toneColor(tone).bold(title)}\n${divider('─', tone, width)}\n` : '';
+  return `${header}${String(content ?? '')}\n${divider('─', tone, width)}`;
+}
+
+function divider(char = '─', tone = 'gray', width = terminalWidth(70)) {
+  return toneColor(tone)(char.repeat(Math.max(12, width)));
+}
+
+function sectionTitle(title, subtitle = '', tone = 'cyan') {
+  return `${toneColor(tone).bold(title)}${subtitle ? ` ${UI.slate(subtitle)}` : ''}`;
 }
 
 function statusBadge(text, type = 'info') {
-  const badges = {
-    info: chalk.bgCyan.black(` ${text} `),
-    success: chalk.bgGreen.black(` ${text} `),
-    warning: chalk.bgYellow.black(` ${text} `),
-    error: chalk.bgRed.white(` ${text} `),
-    action: chalk.bgMagenta.white(` ${text} `)
+  const badge = BADGE_STYLES[type] || BADGE_STYLES.info;
+  return badge(`[${text}]`);
+}
+
+function keyValue(label, value, width = 12) {
+  return `${padAnsi(UI.slate(label), width)} ${value}`;
+}
+
+function commandRow(command, description, width = 18) {
+  return `${padAnsi(UI.accent(command), width)} ${UI.slate('—')} ${UI.ink(description)}`;
+}
+
+function meter(current = 0, total = 0, width = 20) {
+  if (!total || total <= 0) return UI.slate('░'.repeat(width));
+
+  const ratio = Math.max(0, Math.min(1, current / total));
+  const filled = Math.round(ratio * width);
+  const colorFn = ratio >= 0.85 ? toneColor('red') : ratio >= 0.65 ? toneColor('yellow') : toneColor('green');
+  return `${colorFn('█'.repeat(filled))}${UI.slate('░'.repeat(Math.max(0, width - filled)))}`;
+}
+
+function ellipsis(text = '', max = 48) {
+  const plain = String(text);
+  if (plain.length <= max) return plain;
+  return `${plain.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function promptShell(label, detail = '') {
+  return `${UI.slate(label)}${detail ? `\n${detail}` : ''}\n${UI.accent('› ')} `;
+}
+
+function renderedTerminalLineCount(text = '', width = process.stdout.columns || 80) {
+  const terminalColumns = Math.max(1, width || 80);
+  return String(text ?? '')
+    .split('\n')
+    .reduce((count, line) => count + Math.max(1, Math.ceil(Math.max(1, visibleLength(line)) / terminalColumns)), 0);
+}
+
+function clearPromptEcho(promptText, inputText = '') {
+  const totalLines = renderedTerminalLineCount(`${promptText}${inputText}`);
+  for (let index = 0; index < totalLines; index++) {
+    process.stdout.write('\x1B[1A\x1B[2K');
+  }
+  process.stdout.write('\r');
+}
+
+function streamPhaseMessage(message, type = 'neutral') {
+  const colorFn = BADGE_STYLES[type] || UI.slate;
+  return `${colorFn('[status]')} ${UI.slate(message)}`;
+}
+
+function showStreamPhase(message, type = 'neutral') {
+  if (!streamPhaseStatusEnabled()) return;
+  console.log(streamPhaseMessage(message, type));
+}
+
+function renderStreamingHeartbeat({
+  genTokenCount = 0,
+  genStartTime,
+  lastVisibleActivityAt,
+  stage = 'generating',
+}) {
+  const elapsedSeconds = Math.max((Date.now() - genStartTime) / 1000, 0.1);
+  const elapsed = elapsedSeconds.toFixed(1);
+  const idleSeconds = Math.max(0, Math.floor((Date.now() - lastVisibleActivityAt) / 1000));
+  const idleThreshold = streamIdleNoticeSeconds();
+
+  if (stage === 'waiting-first') {
+    const waitNote = idleSeconds >= idleThreshold ? ` · waiting ${idleSeconds}s` : '';
+    process.stdout.write(`\r  ${UI.slate(`Waiting for first model chunk... ${elapsed}s elapsed${waitNote}`)}  ${UI.slate.italic('Ctrl+C to stop')}`);
+    return;
+  }
+
+  const tps = genTokenCount / elapsedSeconds;
+  const waitNote = idleSeconds >= idleThreshold ? ` · waiting ${idleSeconds}s for next chunk` : '';
+  process.stdout.write(`\r  ${UI.slate(`Generating... ${genTokenCount} tokens · ${elapsed}s · ${tps.toFixed(1)} t/s${waitNote}`)}  ${UI.slate.italic('Ctrl+C to stop')}`);
+}
+
+function confirmPrompt(label, type = 'warning', optionsLabel = '[y/N] ') {
+  const colors = {
+    info: UI.accent,
+    success: UI.mint,
+    warning: UI.gold,
+    error: UI.coral,
+    action: chalk.hex('#8fb6ff'),
+    neutral: UI.slate,
+  };
+  const colorFn = colors[type] || UI.gold;
+  return colorFn(`\n${label}? `) + UI.slate(optionsLabel);
+}
+
+function parseApprovalShortcut(input = '') {
+  const trimmed = String(input ?? '').trim();
+  if (!trimmed) return null;
+
+  const match = trimmed.match(/^(f|feedback|e|edit)\b(?:\s*[:=-]?\s*(.*))?$/i);
+  if (!match) return null;
+
+  const command = match[1].toLowerCase();
+  return {
+    type: command.startsWith('e') ? 'edit' : 'feedback',
+    detail: String(match[2] ?? '').trim(),
+  };
+}
+
+async function resolveApprovalInstruction(input, {
+  feedbackPrompt = 'Feedback for Sapper: ',
+  editPrompt = 'Edit instruction for Sapper: ',
+} = {}) {
+  const shortcut = parseApprovalShortcut(input);
+  if (!shortcut) return null;
+
+  let detail = shortcut.detail;
+  if (!detail) {
+    const promptLabel = shortcut.type === 'edit' ? editPrompt : feedbackPrompt;
+    detail = String(await safeQuestion(chalk.cyan(promptLabel))).trim();
+  }
+
+  return {
+    type: shortcut.type,
+    detail,
   };
-  return badges[type] || badges.info;
+}
+
+const shellSessions = new Map();
+let shellSessionCounter = 0;
+const SHELL_OUTPUT_BUFFER_MAX_CHARS = 50000;
+
+function createShellSession(command, cwd, proc) {
+  const id = `shell-${++shellSessionCounter}`;
+  const session = {
+    id,
+    command,
+    cwd,
+    proc,
+    startedAt: Date.now(),
+    output: '',
+    reportedOffset: 0,
+    completed: false,
+    backgrounded: false,
+    exitCode: null,
+    signal: null,
+    error: null,
+    liveEchoEnabled: true,
+  };
+  shellSessions.set(id, session);
+  return session;
+}
+
+function activeShellSessionCount() {
+  return Array.from(shellSessions.values()).filter(session => !session.completed).length;
+}
+
+function appendShellSessionOutput(session, text) {
+  if (!session || !text) return;
+  session.output += text;
+  if (session.output.length > SHELL_OUTPUT_BUFFER_MAX_CHARS) {
+    const overflow = session.output.length - SHELL_OUTPUT_BUFFER_MAX_CHARS;
+    session.output = session.output.slice(overflow);
+    session.reportedOffset = Math.max(0, session.reportedOffset - overflow);
+  }
+}
+
+function formatShellOutputChunk(text = '', emptyLabel = '(no output yet)') {
+  const normalized = String(text ?? '').trim();
+  if (!normalized) return emptyLabel;
+  const maxChars = shellOutputChunkChars();
+  if (normalized.length <= maxChars) return normalized;
+  return `... (showing last ${maxChars.toLocaleString()} chars)\n${normalized.slice(-maxChars)}`;
+}
+
+function shellSessionUsageHint(sessionId) {
+  return `Use run_shell with command \"__shell_read__ ${sessionId}\" to inspect more output, \"__shell_list__\" to list sessions, or \"__shell_stop__ ${sessionId}\" to stop it.`;
+}
+
+function buildShellSessionResult(session, {
+  includeOutput = true,
+  onlyNewOutput = false,
+  markReported = false,
+  backgroundHandoff = false,
+} = {}) {
+  const relevantOutput = onlyNewOutput
+    ? session.output.slice(session.reportedOffset)
+    : session.output;
+
+  if (markReported) {
+    session.reportedOffset = session.output.length;
+  }
+
+  const elapsedSeconds = Math.max(1, Math.round((Date.now() - session.startedAt) / 1000));
+  const statusLine = session.completed
+    ? `Shell session ${session.id} completed in ${elapsedSeconds}s with exit code ${session.exitCode ?? 'unknown'}.`
+    : `Shell session ${session.id} is still running in background after ${elapsedSeconds}s.`;
+
+  const lines = [
+    statusLine,
+    `Command: ${session.command}`,
+    `Directory: ${session.cwd}`,
+  ];
+
+  if (session.error) {
+    lines.push(`Error: ${session.error}`);
+  }
+
+  if (!session.completed || backgroundHandoff) {
+    lines.push(shellSessionUsageHint(session.id));
+  }
+
+  if (includeOutput) {
+    lines.push('');
+    lines.push(onlyNewOutput ? 'Output since last check:' : backgroundHandoff ? 'Initial streamed output:' : 'Captured output:');
+    lines.push(formatShellOutputChunk(relevantOutput, onlyNewOutput ? '(no new output since last check)' : '(no output yet)'));
+  }
+
+  return lines.join('\n');
+}
+
+function parseShellSessionCommand(command = '') {
+  const trimmed = String(command ?? '').trim();
+  if (!trimmed.startsWith('__shell_')) return null;
+
+  const [directive, ...rest] = trimmed.split(/\s+/);
+  const sessionId = rest.join(' ').trim();
+
+  if (directive === '__shell_list__') return { action: 'list' };
+  if (directive === '__shell_read__') return { action: 'read', sessionId };
+  if (directive === '__shell_stop__') return { action: 'stop', sessionId };
+  return { action: 'unknown', directive };
+}
+
+async function handleShellSessionCommand(command = '') {
+  const parsed = parseShellSessionCommand(command);
+  if (!parsed) return null;
+
+  if (parsed.action === 'unknown') {
+    return `Unknown shell session command: ${parsed.directive}. Use __shell_list__, __shell_read__ <session_id>, or __shell_stop__ <session_id>.`;
+  }
+
+  if (parsed.action === 'list') {
+    const sessions = Array.from(shellSessions.values());
+    if (sessions.length === 0) return 'No shell sessions are currently tracked.';
+    return sessions.map(session => {
+      const state = session.completed ? `done (exit ${session.exitCode ?? 'unknown'})` : 'running';
+      return `${session.id} · ${state} · ${session.command}`;
+    }).join('\n');
+  }
+
+  if (!parsed.sessionId) {
+    return 'Missing shell session id. Use __shell_read__ <session_id> or __shell_stop__ <session_id>.';
+  }
+
+  const session = shellSessions.get(parsed.sessionId);
+  if (!session) {
+    return `Shell session not found: ${parsed.sessionId}. Use __shell_list__ to see available sessions.`;
+  }
+
+  if (parsed.action === 'read') {
+    return buildShellSessionResult(session, {
+      includeOutput: true,
+      onlyNewOutput: true,
+      markReported: true,
+      backgroundHandoff: !session.completed,
+    });
+  }
+
+  if (parsed.action === 'stop') {
+    if (session.completed) {
+      return buildShellSessionResult(session, {
+        includeOutput: true,
+        onlyNewOutput: false,
+        markReported: true,
+      });
+    }
+
+    console.log();
+    const confirmation = await safeQuestion(confirmPrompt(`Stop background shell session ${session.id}`, 'error', '[y/N] '));
+    if (!['y', 'yes'].includes(String(confirmation ?? '').trim().toLowerCase())) {
+      return `Stop request cancelled for shell session ${session.id}.`;
+    }
+
+    try {
+      session.proc.kill('SIGTERM');
+      return `Sent SIGTERM to shell session ${session.id}. ${shellSessionUsageHint(session.id)}`;
+    } catch (error) {
+      return `Could not stop shell session ${session.id}: ${error.message}`;
+    }
+  }
+
+  return null;
+}
+
+function getTrackedShellSessions() {
+  return Array.from(shellSessions.values()).sort((left, right) => right.startedAt - left.startedAt);
+}
+
+function shellSessionStatusLabel(session) {
+  if (!session) return 'unknown';
+  if (!session.completed) return 'running';
+  if (session.signal) return `stopped (${session.signal})`;
+  return `done (${session.exitCode ?? 'unknown'})`;
+}
+
+function renderShellSessionsPanel() {
+  const sessions = getTrackedShellSessions();
+  const activeCount = sessions.filter(session => !session.completed).length;
+  const completedCount = sessions.length - activeCount;
+  const lines = [
+    `config        ${chalk.white(shellStreamToModelEnabled() ? 'stream on' : 'stream off')} ${UI.slate('·')} ${chalk.white(`bg ${shellBackgroundMode()}`)} ${UI.slate('·')} ${chalk.white(`after ${shellBackgroundAfterSeconds()}s`)} ${UI.slate('·')} ${chalk.white(`chunk ${shellOutputChunkChars()}`)}`,
+    UI.slate(`visibility    bg off keeps long shell commands fully attached and visible in the terminal`),
+    `sessions      ${chalk.white(`${activeCount} active`)} ${UI.slate('·')} ${chalk.white(`${completedCount} completed`)}`,
+  ];
+
+  if (sessions.length === 0) {
+    lines.push(UI.slate('No background shell sessions are currently tracked.'));
+  } else {
+    for (const session of sessions.slice(0, 8)) {
+      const elapsed = formatElapsed(Date.now() - session.startedAt);
+      const lastOutputLine = String(session.output || '').trim().split('\n').filter(Boolean).slice(-1)[0] || '(no output yet)';
+      lines.push(`${chalk.white(session.id)} ${UI.slate('·')} ${chalk.white(shellSessionStatusLabel(session))} ${UI.slate('·')} ${UI.slate(elapsed)}`);
+      lines.push(`  ${UI.ink(ellipsis(session.command, 90))}`);
+      lines.push(`  ${UI.slate(ellipsis(lastOutputLine, 90))}`);
+    }
+    if (sessions.length > 8) {
+      lines.push(UI.slate(`Showing 8 of ${sessions.length} tracked sessions.`));
+    }
+  }
+
+  return box(lines.join('\n'), 'Shell Sessions', 'cyan');
 }
 
 // Configure marked with terminal renderer
-marked.setOptions({
-  renderer: new TerminalRenderer({
+marked.use(markedTerminal({
     code: chalk.cyan,
     blockquote: chalk.gray.italic,
     html: chalk.gray,
     heading: chalk.bold.cyan,
     firstHeading: chalk.bold.cyan,
-    hr: chalk.gray('─'.repeat(40)),
-    listitem: chalk.yellow('• ') + '%s',
     table: chalk.white,
+    tableOptions: {
+      chars: {
+        top: '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+        bottom: '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+        left: '│', 'left-mid': '├', mid: '─', 'mid-mid': '┼',
+        right: '│', 'right-mid': '┤', middle: '│'
+      },
+      style: { head: ['cyan', 'bold'], border: ['gray'] }
+    },
     paragraph: chalk.white,
     strong: chalk.bold.white,
     em: chalk.italic,
     codespan: chalk.cyan,
     del: chalk.strikethrough,
     link: chalk.underline.blue,
-    href: chalk.gray
-  })
-});
+    href: chalk.gray,
+    showSectionPrefix: true,
+    reflowText: true,
+    width: Math.min(process.stdout.columns || 80, 120)
+}));
 
 // Render markdown to terminal
 function renderMarkdown(text) {
@@ -1539,6 +2558,35 @@ function renderMarkdown(text) {
 let stepMode = false;
 let debugMode = false; // Toggle with /debug command
 let abortStream = false; // Flag to interrupt AI response
+
+// ═══════════════════════════════════════════════════════════════
+// REAL CONTEXT WINDOW TRACKING
+// ═══════════════════════════════════════════════════════════════
+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
+
+// 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) {
+  if (!text) return 0;
+  // Count code blocks separately (denser tokens)
+  const codeBlocks = text.match(/```[\s\S]*?```/g) || [];
+  let codeChars = codeBlocks.reduce((sum, b) => sum + b.length, 0);
+  let textChars = text.length - codeChars;
+  return Math.ceil(textChars / 4 + codeChars / 3.5);
+}
+
+// Estimate total tokens for the messages array
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    // Each message has ~4 tokens of overhead (role, formatting)
+    total += 4;
+    total += estimateTokens(m.content);
+  }
+  return total;
+}
 let rl = readline.createInterface({ 
   input: process.stdin, 
   output: process.stdout,
@@ -1569,6 +2617,181 @@ async function safeQuestion(query) {
   });
 }
 
+function countLines(text = '') {
+  if (!text) return 0;
+  return String(text).split('\n').length;
+}
+
+function formatPreviewLine(line = '', maxWidth = Math.max(32, terminalWidth(82) - 12)) {
+  return ellipsis(String(line).replace(/\t/g, '  '), maxWidth);
+}
+
+function buildPreviewBlock(lines, startIdx, endIdx, changeStart, changeEnd, marker, colorFn, maxLines = 14) {
+  if (lines.length === 0) {
+    return colorFn(`${marker}   | (empty)`);
+  }
+
+  const indexes = [];
+  for (let index = startIdx; index <= endIdx; index++) {
+    indexes.push(index);
+  }
+
+  const clipped = indexes.length > maxLines;
+  const visibleIndexes = clipped
+    ? [
+        ...indexes.slice(0, Math.ceil(maxLines / 2)),
+        -1,
+        ...indexes.slice(-(Math.floor(maxLines / 2)))
+      ]
+    : indexes;
+  const numberWidth = String(Math.max(endIdx + 1, 1)).length;
+  const rows = [];
+
+  if (startIdx > 0) {
+    rows.push(UI.slate('  ...'));
+  }
+
+  for (const index of visibleIndexes) {
+    if (index === -1) {
+      rows.push(UI.slate('  ...'));
+      continue;
+    }
+
+    const prefix = index >= changeStart && index <= changeEnd ? marker : ' ';
+    const row = `${prefix} ${String(index + 1).padStart(numberWidth)} | ${formatPreviewLine(lines[index])}`;
+    rows.push(prefix === marker ? colorFn(row) : UI.slate(row));
+  }
+
+  if (clipped || endIdx < lines.length - 1) {
+    rows.push(UI.slate('  ...'));
+  }
+
+  return rows.join('\n');
+}
+
+function buildFileChangePreview(oldContent = '', newContent = '') {
+  const before = String(oldContent ?? '');
+  const after = String(newContent ?? '');
+
+  if (before === after) {
+    return UI.slate('No visible text changes.');
+  }
+
+  const oldLines = before ? before.split('\n') : [];
+  const newLines = after ? after.split('\n') : [];
+
+  if (oldLines.length === 0) {
+    return [
+      chalk.green('New file content'),
+      buildPreviewBlock(newLines, 0, Math.max(0, Math.min(newLines.length - 1, 13)), 0, Math.max(0, Math.min(newLines.length - 1, 13)), '+', chalk.green)
+    ].join('\n');
+  }
+
+  let start = 0;
+  while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start]) {
+    start++;
+  }
+
+  let oldEnd = oldLines.length - 1;
+  let newEnd = newLines.length - 1;
+  while (oldEnd >= start && newEnd >= start && oldLines[oldEnd] === newLines[newEnd]) {
+    oldEnd--;
+    newEnd--;
+  }
+
+  const contextLines = 3;
+  const oldStart = Math.max(0, start - contextLines);
+  const newStart = Math.max(0, start - contextLines);
+  const oldPreviewEnd = Math.min(oldLines.length - 1, Math.max(oldEnd, start - 1) + contextLines);
+  const newPreviewEnd = Math.min(newLines.length - 1, Math.max(newEnd, start - 1) + contextLines);
+
+  return [
+    chalk.red('Before'),
+    buildPreviewBlock(oldLines, oldStart, oldPreviewEnd, start, oldEnd, '-', chalk.red),
+    '',
+    chalk.green('After'),
+    buildPreviewBlock(newLines, newStart, newPreviewEnd, start, newEnd, '+', chalk.green),
+  ].join('\n');
+}
+
+function ensureParentDirectory(filePath) {
+  const parentDir = dirname(filePath);
+  if (parentDir && parentDir !== '.' && !fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+}
+
+function restoreFileSnapshot(filePath, originalContent, existedBefore) {
+  if (existedBefore) {
+    fs.writeFileSync(filePath, originalContent);
+  } else if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+async function reviewCandidateFile({ filePath, originalContent = '', newContent = '', title = 'File Review', successMessage }) {
+  const existedBefore = fs.existsSync(filePath);
+
+  ensureParentDirectory(filePath);
+  fs.writeFileSync(filePath, newContent);
+
+  while (true) {
+    console.log();
+    console.log(box(
+      `${keyValue('File', chalk.white(filePath), 8)}\n` +
+      `${keyValue('Status', chalk.white(existedBefore ? 'modified' : 'new file'), 8)}\n` +
+      `${keyValue('Lines', chalk.white(`${countLines(originalContent)} -> ${countLines(newContent)}`), 8)}\n` +
+      `${UI.slate('Candidate change written to disk. Review it in your editor now.')}\n` +
+      `${UI.slate('Choose keep to accept it, ignore to revert it, diff to inspect, f for feedback, or e for edit instructions.')}`,
+      title, 'yellow'
+    ));
+
+    const decisionInput = await safeQuestion(chalk.yellow('Review change ') + chalk.gray('[k]eep/[i]gnore/[d]iff/[f]eedback/[e]dit: '));
+    const decisionRaw = String(decisionInput ?? '').trim();
+    const decision = decisionRaw.toLowerCase();
+
+    if (['k', 'keep', 'y', 'yes'].includes(decision)) {
+      return successMessage || `Successfully saved changes to ${filePath}`;
+    }
+
+    if (['i', 'ignore', 'n', 'no'].includes(decision)) {
+      restoreFileSnapshot(filePath, originalContent, existedBefore);
+      return existedBefore
+        ? `Ignored change and restored ${filePath}`
+        : `Ignored change and removed ${filePath}`;
+    }
+
+    if (decision === '' || decision === 'd' || decision === 'diff') {
+      console.log();
+      console.log(box(buildFileChangePreview(originalContent, newContent), 'Change Diff', 'yellow'));
+      continue;
+    }
+
+    const approvalInstruction = await resolveApprovalInstruction(decisionRaw, {
+      feedbackPrompt: 'Feedback for this change: ',
+      editPrompt: 'Edit instruction for this change: ',
+    });
+
+    if (approvalInstruction) {
+      if (!approvalInstruction.detail) {
+        console.log(UI.slate('Enter feedback or edit instructions for Sapper, or choose keep/ignore/diff.'));
+        continue;
+      }
+
+      restoreFileSnapshot(filePath, originalContent, existedBefore);
+      const label = approvalInstruction.type === 'edit' ? 'User edit instruction' : 'User feedback';
+      return `Change rejected by user for ${filePath}.\n${label}: ${approvalInstruction.detail}\nThe original file was restored. Revise the change and try again.`;
+    }
+
+    if (decisionRaw) {
+      restoreFileSnapshot(filePath, originalContent, existedBefore);
+      return `Change rejected by user for ${filePath}.\nUser feedback: ${decisionRaw}\nThe original file was restored. Revise the change and try again.`;
+    }
+
+    console.log(UI.slate('Type k to keep, i to ignore, d to view the diff, f for feedback, e for edit instructions, or write feedback directly.'));
+  }
+}
+
 // Directories to ignore when listing files
 const IGNORE_DIRS = new Set([
   'node_modules', '.git', '.svn', '.hg', 'dist', 'build', 
@@ -1589,6 +2812,157 @@ const CODE_EXTENSIONS = new Set([
 // Max file size to include (skip large files like bundled/minified)
 const MAX_FILE_SIZE = 100000; // 100KB per file
 const MAX_TOTAL_SCAN_SIZE = 1000000; // 1000KB total scan limit
+const MAX_URL_SIZE = 200000; // 200KB max for fetched web pages
+
+// ═══════════════════════════════════════════════════════════════
+// URL FETCHING — Read web pages and learn from them
+// ═══════════════════════════════════════════════════════════════
+import https from 'https';
+import http from 'http';
+
+// Fetch a URL and return extracted text content
+function fetchUrl(url, timeout = 15000) {
+  return new Promise((resolve, reject) => {
+    const lib = url.startsWith('https') ? https : http;
+    const req = lib.get(url, { 
+      headers: { 
+        'User-Agent': 'Sapper-AI/1.0',
+        'Accept': 'text/html,application/json,text/plain,*/*'
+      },
+      timeout 
+    }, (res) => {
+      // Follow redirects (up to 3)
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        const redirectUrl = res.headers.location.startsWith('http') 
+          ? res.headers.location 
+          : new URL(res.headers.location, url).href;
+        return fetchUrl(redirectUrl, timeout).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode}`));
+      }
+      
+      let data = '';
+      let size = 0;
+      res.on('data', (chunk) => {
+        size += chunk.length;
+        if (size > MAX_URL_SIZE) {
+          res.destroy();
+          reject(new Error(`Page too large (>${Math.round(MAX_URL_SIZE/1024)}KB)`));
+          return;
+        }
+        data += chunk;
+      });
+      res.on('end', () => resolve(data));
+      res.on('error', reject);
+    });
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+    req.on('error', reject);
+  });
+}
+
+// Strip HTML tags and extract readable text
+function htmlToText(html) {
+  let text = html;
+  // Remove script and style blocks entirely
+  text = text.replace(/<script[\s\S]*?<\/script>/gi, '');
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, '');
+  text = text.replace(/<nav[\s\S]*?<\/nav>/gi, '');
+  text = text.replace(/<footer[\s\S]*?<\/footer>/gi, '');
+  text = text.replace(/<header[\s\S]*?<\/header>/gi, ''); 
+  // Convert common block elements to newlines
+  text = text.replace(/<\/?(p|div|br|h[1-6]|li|tr|td|th|blockquote|pre|hr)[^>]*>/gi, '\n');
+  // Remove all other HTML tags
+  text = text.replace(/<[^>]+>/g, '');
+  // Decode common HTML entities
+  text = text.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&nbsp;/g, ' ')
+    .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(n));
+  // Clean up whitespace
+  text = text.replace(/[ \t]+/g, ' ');
+  text = text.replace(/\n\s*\n/g, '\n\n');
+  text = text.trim();
+  // Limit to reasonable size
+  if (text.length > 50000) {
+    text = text.substring(0, 50000) + '\n\n[... content truncated at 50KB ...]';
+  }
+  return text;
+}
+
+// Detect URLs in text
+const URL_REGEX = /https?:\/\/[^\s<>"')\]]+/g;
+
+// ═══════════════════════════════════════════════════════════════
+// .sapperignore SUPPORT — like .gitignore for Sapper
+// ═══════════════════════════════════════════════════════════════
+
+// Parse .sapperignore patterns (glob-like, one per line, # comments)
+function loadSapperIgnorePatterns() {
+  const patterns = [];
+  try {
+    if (fs.existsSync(SAPPERIGNORE_FILE)) {
+      const lines = fs.readFileSync(SAPPERIGNORE_FILE, 'utf8').split('\n');
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) continue;
+        // Track negation patterns (lines starting with !)
+        const negate = line.startsWith('!');
+        const pattern = negate ? line.slice(1) : line;
+        patterns.push({ pattern, negate });
+      }
+    }
+  } catch (e) {
+    // Silent fail — ignore file is optional
+  }
+  return patterns;
+}
+
+let _sapperIgnorePatterns = null;
+function getSapperIgnorePatterns() {
+  if (_sapperIgnorePatterns === null) {
+    _sapperIgnorePatterns = loadSapperIgnorePatterns();
+  }
+  return _sapperIgnorePatterns;
+}
+
+// Reload patterns (call when .sapperignore changes)
+function reloadSapperIgnore() {
+  _sapperIgnorePatterns = null;
+}
+
+// Convert a .sapperignore glob pattern to a regex
+function ignorePatternToRegex(pattern) {
+  // Remove trailing slashes (directory markers)
+  let p = pattern.replace(/\/+$/, '');
+  // Escape regex special chars except * and ?
+  p = p.replace(/([.+^${}()|[\]\\])/g, '\\$1');
+  // Convert glob wildcards
+  p = p.replace(/\*\*/g, '<<<GLOBSTAR>>>');
+  p = p.replace(/\*/g, '[^/]*');
+  p = p.replace(/<<<GLOBSTAR>>>/g, '.*');
+  p = p.replace(/\?/g, '[^/]');
+  // Match the whole name or path
+  return new RegExp(`(^|/)${p}($|/)`, 'i');
+}
+
+// Check if a file/dir name or path should be ignored
+function shouldIgnore(nameOrPath) {
+  // Always check built-in IGNORE_DIRS first (fast path)
+  const baseName = nameOrPath.includes('/') ? nameOrPath.split('/').pop() : nameOrPath;
+  if (IGNORE_DIRS.has(baseName)) return true;
+
+  const patterns = getSapperIgnorePatterns();
+  if (patterns.length === 0) return false;
+
+  let ignored = false;
+  for (const { pattern, negate } of patterns) {
+    const regex = ignorePatternToRegex(pattern);
+    if (regex.test(nameOrPath) || regex.test(baseName)) {
+      ignored = !negate;
+    }
+  }
+  return ignored;
+}
 
 // Scan entire codebase and return summary
 function scanCodebase(dir = '.', depth = 0, maxDepth = 5) {
@@ -1603,14 +2977,15 @@ function scanCodebase(dir = '.', depth = 0, maxDepth = 5) {
     for (const entry of entries) {
       const fullPath = dir === '.' ? entry.name : `${dir}/${entry.name}`;
       
-      // Skip ignored directories
+      // Skip ignored directories and files (respects .sapperignore)
       if (entry.isDirectory()) {
-        if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+        if (shouldIgnore(entry.name) || entry.name.startsWith('.')) continue;
         const subResult = scanCodebase(fullPath, depth + 1, maxDepth);
         files = files.concat(subResult.files);
         totalSize += subResult.totalSize;
       } else {
         // Check if file should be included
+        if (shouldIgnore(fullPath) || shouldIgnore(entry.name)) continue;
         const ext = entry.name.includes('.') ? '.' + entry.name.split('.').pop() : entry.name;
         const isCodeFile = CODE_EXTENSIONS.has(ext.toLowerCase()) || CODE_EXTENSIONS.has(entry.name);
         
@@ -1649,7 +3024,7 @@ function getFilesForPicker(dir = '.', prefix = '', maxFiles = 50) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (files.length >= maxFiles) break;
-      if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith('.')) continue;
+      if (shouldIgnore(entry.name) || entry.name.startsWith('.')) continue;
       
       const fullPath = prefix ? `${prefix}/${entry.name}` : entry.name;
       
@@ -1697,8 +3072,9 @@ async function pickFiles() {
     // Clear screen and move cursor to top
     console.clear();
     console.log(box(
-      `${chalk.cyan('↑↓')} Navigate  ${chalk.cyan('Space')} Toggle  ${chalk.cyan('a')} All  ${chalk.cyan('Enter')} Confirm  ${chalk.cyan('q/Esc')} Cancel`,
-      '📎 Select Files', 'cyan'
+      `${statusBadge('Move', 'info')} ↑ ↓   ${statusBadge('Toggle', 'success')} space   ${statusBadge('All', 'warning')} a\n` +
+      `${statusBadge('Confirm', 'success')} enter   ${statusBadge('Cancel', 'error')} q / esc`,
+      'Attach Files', 'cyan'
     ));
     console.log();
     
@@ -1729,7 +3105,7 @@ async function pickFiles() {
     }
     
     console.log();
-    console.log(chalk.gray(`  Selected: ${selected.size} file${selected.size !== 1 ? 's' : ''}`));
+        console.log(`${statusBadge('Selected', 'action')} ${chalk.white(`${selected.size} file${selected.size !== 1 ? 's' : ''}`)}`);
   };
   
   return new Promise((resolve) => {
@@ -1828,13 +3204,127 @@ function formatScanResults(scanResult) {
   return output;
 }
 
+// Interactive model picker with keyboard navigation
+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));
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+
+  const render = () => {
+    const current = models[cursor];
+    console.clear();
+    console.log(BANNER);
+    console.log(`${UI.slate(process.cwd())} ${UI.slate('·')} ${UI.slate(`v${CURRENT_VERSION}`)}`);
+    console.log(divider());
+    console.log(sectionTitle('Model selection', 'use ↑↓ or j/k, enter to confirm', 'cyan'));
+    console.log();
+
+    const startIdx = Math.max(0, Math.min(cursor - Math.floor(pageSize / 2), models.length - pageSize));
+    const endIdx = Math.min(startIdx + pageSize, models.length);
+
+    if (startIdx > 0) {
+      console.log(UI.slate('  ↑ more models'));
+    }
+
+    for (let i = startIdx; i < endIdx; i++) {
+      const model = models[i];
+      const isActive = i === cursor;
+      const marker = isActive ? UI.accent('›') : UI.slate(' ');
+      const index = isActive ? UI.accent(String(i + 1).padStart(2, '0')) : UI.slate(String(i + 1).padStart(2, '0'));
+      const name = isActive ? UI.accentSoft.bold(ellipsis(model.name, 40)) : chalk.white(ellipsis(model.name, 40));
+      const meta = [
+        model.size ? formatBytes(model.size) : null,
+        model.modified_at ? formatRelativeTime(model.modified_at) : null,
+        model.details?.parameter_size || null,
+      ].filter(Boolean).join(' · ');
+
+      console.log(`${marker} ${index}  ${name}`);
+      if (meta) {
+        console.log(`     ${UI.slate(meta)}`);
+      }
+    }
+
+    if (endIdx < models.length) {
+      console.log(UI.slate('  ↓ more 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';
+    console.log();
+    console.log(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'
+    ));
+  };
+
+  return new Promise((resolve) => {
+    render();
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    };
+
+    const onKeypress = (chunk, key) => {
+      if (!key) {
+        const str = chunk.toString();
+        if (str === '\x1b[A') key = { name: 'up' };
+        else if (str === '\x1b[B') key = { name: 'down' };
+        else if (str === '\r' || str === '\n') key = { name: 'return' };
+        else if (str === '\x1b' || str === 'q') key = { name: 'escape' };
+        else if (str === 'j') key = { name: 'down' };
+        else if (str === 'k') key = { name: 'up' };
+        else if (str === '\x03') key = { name: 'c', ctrl: true };
+      }
+
+      if (!key) return;
+
+      if (key.name === 'up') {
+        cursor = cursor > 0 ? cursor - 1 : models.length - 1;
+        render();
+      } else if (key.name === 'down') {
+        cursor = cursor < models.length - 1 ? cursor + 1 : 0;
+        render();
+      } else if (key.name === 'return') {
+        cleanup();
+        console.log(UI.slate(`\nUsing ${models[cursor].name}`));
+        resolve(models[cursor].name);
+      } else if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+        cleanup();
+        console.log(UI.slate(`\nUsing ${models[cursor].name}`));
+        resolve(models[cursor].name);
+      }
+    };
+
+    process.stdin.on('data', onKeypress);
+  });
+}
+
 const tools = {
   read: (path) => {
-    try { return fs.readFileSync(path.trim(), 'utf8'); } 
+    const trimmedPath = typeof path === 'string' ? path.trim() : '';
+    if (!trimmedPath) return 'Error reading file: missing file path';
+    try { return fs.readFileSync(trimmedPath, 'utf8'); } 
     catch (error) { return `Error reading file: ${error.message}`; }
   },
   patch: async (path, oldText, newText) => {
-    const trimmedPath = path.trim();
+    const trimmedPath = typeof path === 'string' ? path.trim() : '';
+    if (!trimmedPath) return 'Error patching file: missing file path';
+    if (typeof oldText !== 'string' || typeof newText !== 'string') {
+      return 'Error patching file: missing old_text or new_text';
+    }
     try {
       const content = fs.readFileSync(trimmedPath, 'utf8');
 
@@ -1846,22 +3336,19 @@ const tools = {
         if (lineNum < 1 || lineNum > lines.length) {
           return `Error: Line ${lineNum} out of range (file has ${lines.length} lines) in ${trimmedPath}`;
         }
-        const oldLine = lines[lineNum - 1];
         lines[lineNum - 1] = newText;
         const newContent = lines.join('\n');
-        console.log();
-        const diffContent =
-          `${chalk.white('File:')} ${chalk.cyan(trimmedPath)} ${chalk.gray(`(line ${lineNum})`)}\n` +
-          chalk.gray('─'.repeat(40)) + '\n' +
-          chalk.red('- ' + oldLine) + '\n' +
-          chalk.green('+ ' + newText);
-        console.log(box(diffContent, '🔧 Patch (line mode)', 'yellow'));
-        const confirm = await safeQuestion(chalk.yellow('\n↪ Apply patch? ') + chalk.gray('(y/n): '));
-        if (confirm.toLowerCase() === 'y') {
-          fs.writeFileSync(trimmedPath, newContent);
-          return `Successfully patched line ${lineNum} of ${trimmedPath}`;
+        if (newContent === content) {
+          return `No changes needed in ${trimmedPath}`;
         }
-        return 'Patch rejected by user.';
+
+        return reviewCandidateFile({
+          filePath: trimmedPath,
+          originalContent: content,
+          newContent,
+          title: 'Patch Review',
+          successMessage: `Successfully patched line ${lineNum} of ${trimmedPath}`,
+        });
       }
 
       // --- Exact match (try as-is first, then trimmed) ---
@@ -1919,104 +3406,185 @@ const tools = {
             `Tip: Use LINE:number mode instead, e.g. [TOOL:PATCH]${trimmedPath}:::LINE:42|||replacement text[/TOOL]`;
         }
       }
-      
-      // Show diff preview
-      console.log();
-      const diffContent = 
-        `${chalk.white('File:')} ${chalk.cyan(trimmedPath)}\n` +
-        chalk.gray('─'.repeat(40)) + '\n' +
-        chalk.red('- ' + matchedOld.split('\n').join('\n- ')) + '\n' +
-        chalk.green('+ ' + (newContent === content.replace(matchedOld, newText.trim()) ? newText.trim() : newText).split('\n').join('\n+ '));
-      console.log(box(diffContent, '🔧 Patch', 'yellow'));
-      
-      const confirm = await safeQuestion(chalk.yellow('\n↪ Apply patch? ') + chalk.gray('(y/n): '));
-      if (confirm.toLowerCase() === 'y') {
-        fs.writeFileSync(trimmedPath, newContent);
-        return `Successfully patched ${trimmedPath}`;
+
+      if (newContent === content) {
+        return `No changes needed in ${trimmedPath}`;
       }
-      return 'Patch rejected by user.';
+
+      return reviewCandidateFile({
+        filePath: trimmedPath,
+        originalContent: content,
+        newContent,
+        title: 'Patch Review',
+        successMessage: `Successfully patched ${trimmedPath}`,
+      });
     } catch (error) { return `Error patching file: ${error.message}`; }
   },
   write: async (path, content) => {
-    const trimmedPath = path.trim();
-    console.log();
-    console.log(box(
-      `${chalk.white('File:')} ${chalk.cyan(trimmedPath)}\n` +
-      `${chalk.white('Size:')} ${content?.length || 0} chars\n` +
-      chalk.gray('─'.repeat(40)) + '\n' +
-      chalk.gray(content?.substring(0, 300)?.split('\n').slice(0, 8).join('\n') + (content?.length > 300 ? '\n...' : '')),
-      '✏️  Write File', 'yellow'
-    ));
-    const confirm = await safeQuestion(chalk.yellow('\n↪ Allow write? ') + chalk.gray('(y/n): '));
-    if (confirm.toLowerCase() === 'y') {
-      try {
-        fs.writeFileSync(trimmedPath, content);
-        return `Successfully saved changes to ${trimmedPath}`;
-      } catch (error) { return `Error writing file: ${error.message}`; }
-    }
-    return "Write blocked by user.";
+    const trimmedPath = typeof path === 'string' ? path.trim() : '';
+    if (!trimmedPath) return 'Error writing file: missing file path';
+    try {
+      const fileExists = fs.existsSync(trimmedPath);
+      const existingContent = fileExists ? fs.readFileSync(trimmedPath, 'utf8') : '';
+      const nextContent = String(content ?? '');
+
+      if (fileExists && existingContent === nextContent) {
+        return `No changes needed in ${trimmedPath}`;
+      }
+
+      return reviewCandidateFile({
+        filePath: trimmedPath,
+        originalContent: existingContent,
+        newContent: nextContent,
+        title: 'Write Review',
+        successMessage: `Successfully saved changes to ${trimmedPath}`,
+      });
+    } catch (error) { return `Error writing file: ${error.message}`; }
   },
   mkdir: (path) => {
+    const trimmedPath = typeof path === 'string' ? path.trim() : '';
+    if (!trimmedPath) return 'Error creating directory: missing directory path';
     try {
-      fs.mkdirSync(path.trim(), { recursive: true });
-      return `Directory created: ${path}`;
+      fs.mkdirSync(trimmedPath, { recursive: true });
+      return `Directory created: ${trimmedPath}`;
     } catch (error) { return `Error creating directory: ${error.message}`; }
   },
   shell: async (cmd) => {
+    const trimmedCmd = String(cmd ?? '').trim();
+    if (!trimmedCmd) return 'Error executing shell: missing command';
+
+    const sessionCommandResult = await handleShellSessionCommand(trimmedCmd);
+    if (sessionCommandResult !== null) {
+      return sessionCommandResult;
+    }
+
+    const backgroundEligible = shouldBackgroundShellCommand(trimmedCmd);
     console.log();
     console.log(box(
-      chalk.white.bold(cmd),
-      '🔐 Shell Command', 'red'
+      `${keyValue('Directory', chalk.white(process.cwd()), 11)}\n` +
+      `${UI.slate('Command')}\n${chalk.white.bold(trimmedCmd)}\n` +
+      `${UI.slate('Type y to run, n to block, f for feedback, e for edit instructions, or write feedback directly.')}\n` +
+      `${UI.slate(backgroundEligible ? `Background handoff ${shellBackgroundMode()} after ${shellBackgroundAfterSeconds()}s if still running.` : 'This command will stay attached unless it exits quickly.')}`,
+      'Shell Approval', 'red'
     ));
-    const confirm = await safeQuestion(chalk.red('\n↪ Execute? ') + chalk.gray('(y/n): '));
-    if (confirm.toLowerCase() === 'y') {
-      return new Promise((resolve) => {
-        const useShell = cmd.includes('&&') || cmd.includes('|') || cmd.includes('cd ') || cmd.includes('>') || cmd.includes('<');
-        console.log(chalk.cyan(`\n[RUNNING] ${cmd}\n`));
-        const proc = spawn('sh', ['-c', cmd], { 
-          cwd: process.cwd()
-        });
-        let output = '';
-        proc.stdout.on('data', (data) => { 
-          const text = data.toString();
-          output += text;
-          process.stdout.write(text); // Still show to user in real-time
-        });
-        proc.stderr.on('data', (data) => { 
-          const text = data.toString();
-          output += text;
-          process.stderr.write(text); // Still show errors to user
-        });
-        proc.on('close', (code) => {
-          // Crucial: give control back to Node
-          if (process.stdin.isTTY) {
-            try { process.stdin.setRawMode(false); } catch (e) {}
+    while (true) {
+      const confirmInput = await safeQuestion(confirmPrompt('Run shell command', 'error', '[y/N/f/e or text] '));
+      const confirmRaw = String(confirmInput ?? '').trim();
+      const confirm = confirmRaw.toLowerCase();
+
+      if (['y', 'yes'].includes(confirm)) {
+        return new Promise((resolve) => {
+          console.log(chalk.cyan(`\n[RUNNING] ${trimmedCmd}\n`));
+          const proc = spawn('sh', ['-c', trimmedCmd], {
+            cwd: process.cwd()
+          });
+          const session = createShellSession(trimmedCmd, process.cwd(), proc);
+          let resolved = false;
+          let backgroundTimer = null;
+
+          const finish = (result) => {
+            if (resolved) return;
+            resolved = true;
+            if (backgroundTimer) {
+              clearTimeout(backgroundTimer);
+              backgroundTimer = null;
+            }
+            resolve(result);
+          };
+
+          if (backgroundEligible) {
+            backgroundTimer = setTimeout(() => {
+              if (resolved || session.completed) return;
+              session.backgrounded = true;
+              session.liveEchoEnabled = false;
+              showStreamPhase(`Shell command still running. Background session ${session.id} is active...`, 'warning');
+              finish(buildShellSessionResult(session, {
+                includeOutput: shellStreamToModelEnabled(),
+                onlyNewOutput: false,
+                markReported: shellStreamToModelEnabled(),
+                backgroundHandoff: true,
+              }));
+            }, shellBackgroundAfterSeconds() * 1000);
           }
-          // Delay slightly to let terminal settle
-          setTimeout(() => {
-            recreateReadline();
-            // Return actual output to AI, truncated if too long
-            const maxOutput = 10000;
-            let result = output.trim();
-            if (result.length > maxOutput) {
-              result = result.substring(0, maxOutput) + '\n... (output truncated)';
+
+          proc.stdout.on('data', (data) => { 
+            const text = data.toString();
+            appendShellSessionOutput(session, text);
+            if (session.liveEchoEnabled) {
+              process.stdout.write(text);
+            }
+          });
+          proc.stderr.on('data', (data) => { 
+            const text = data.toString();
+            appendShellSessionOutput(session, text);
+            if (session.liveEchoEnabled) {
+              process.stderr.write(text);
+            }
+          });
+          proc.on('error', (error) => {
+            session.completed = true;
+            session.error = error.message;
+            session.exitCode = 1;
+            finish(`Shell command failed to start: ${error.message}`);
+          });
+          proc.on('close', (code, signal) => {
+            session.completed = true;
+            session.exitCode = code;
+            session.signal = signal;
+
+            if (resolved) {
+              return;
+            }
+
+            if (process.stdin.isTTY) {
+              try { process.stdin.setRawMode(false); } catch (e) {}
             }
-            resolve(result || `Command completed with exit code ${code}`);
-          }, 200);
+
+            setTimeout(() => {
+              recreateReadline();
+              const maxOutput = 10000;
+              let result = session.output.trim();
+              if (result.length > maxOutput) {
+                result = result.substring(0, maxOutput) + '\n... (output truncated)';
+              }
+              finish(result || `Command completed with exit code ${code}`);
+            }, 200);
+          });
         });
+      }
+
+      if (['', 'n', 'no'].includes(confirm)) {
+        return "Command blocked by user.";
+      }
+
+      const approvalInstruction = await resolveApprovalInstruction(confirmRaw, {
+        feedbackPrompt: 'Feedback for this command: ',
+        editPrompt: 'Edit instruction for this command: ',
       });
+
+      if (approvalInstruction) {
+        if (!approvalInstruction.detail) {
+          console.log(UI.slate('Enter feedback or edit instructions for Sapper, or choose y/n.'));
+          continue;
+        }
+
+        const label = approvalInstruction.type === 'edit' ? 'User edit instruction' : 'User feedback';
+        return `Command blocked by user.\n${label}: ${approvalInstruction.detail}\nNo command was executed. Revise the command and ask again if needed.`;
+      }
+
+      return `Command blocked by user.\nUser feedback: ${confirmRaw}\nNo command was executed. Revise the command and ask again if needed.`;
     }
-    return "Command blocked by user.";
   },
   list: (path) => {
     try {
-      let dir = path.trim() || '.';
+      let dir = typeof path === 'string' ? path.trim() : '';
+      if (!dir) dir = '.';
       // If AI sends "/" (root), treat as current directory "."
       if (dir === '/') dir = '.';
       const entries = fs.readdirSync(dir);
-      // Filter out ignored directories
+      // Filter out ignored files/directories (respects .sapperignore)
       const filtered = entries.filter(entry => {
-        if (IGNORE_DIRS.has(entry)) return false;
+        if (shouldIgnore(entry)) return false;
         // Also skip hidden files/folders (starting with .) except current dir
         if (entry.startsWith('.') && entry !== '.') return false;
         return true;
@@ -2026,7 +3594,12 @@ const tools = {
   },
   search: (pattern) => {
     return new Promise((resolve) => {
-      const excludeDirs = Array.from(IGNORE_DIRS).join(',');
+      // Build exclude dirs from IGNORE_DIRS + .sapperignore directory patterns
+      const allIgnoreDirs = new Set(IGNORE_DIRS);
+      for (const { pattern: p, negate } of getSapperIgnorePatterns()) {
+        if (!negate && p.endsWith('/')) allIgnoreDirs.add(p.replace(/\/+$/, ''));
+      }
+      const excludeDirs = Array.from(allIgnoreDirs).join(',');
       // Use grep to search for pattern, excluding ignored directories
       const cmd = `grep -rEin "${pattern.replace(/"/g, '\\"')}" . --exclude-dir={${excludeDirs}} --include="*.{js,ts,jsx,tsx,py,java,go,rs,rb,php,c,cpp,h,css,scss,html,json,md,txt,yml,yaml,toml,sh}" 2>/dev/null | head -50`;
       
@@ -2054,10 +3627,8 @@ async function checkForUpdates() {
     const latestVersion = data.version;
     
     if (latestVersion && latestVersion !== CURRENT_VERSION) {
-      console.log(chalk.yellow('🔄 UPDATE AVAILABLE!'));
-      console.log(chalk.gray(`   Current: v${CURRENT_VERSION}`));
-      console.log(chalk.green(`   Latest:  v${latestVersion}`));
-      console.log(chalk.cyan('   Run: npm update -g sapper-iq\n'));
+      console.log(UI.gold(`Update available: v${CURRENT_VERSION} -> v${latestVersion}`));
+      console.log(UI.slate('Run npm update -g sapper-iq\n'));
     }
   } catch (error) {
     // Silently fail if update check fails
@@ -2067,23 +3638,31 @@ async function checkForUpdates() {
 async function runSapper() {
   console.clear();
   console.log(BANNER);
-  console.log(chalk.gray.dim('  ') + chalk.white.bold(`v${CURRENT_VERSION}`) + chalk.gray(' │ ') + chalk.cyan('Autonomous AI Coding Agent'));
-  console.log(chalk.gray.dim('  ') + chalk.gray('📁 ') + chalk.white(process.cwd()));
-  console.log();
-  
-  // Quick tips box
-  console.log(box(
-    `${chalk.yellow('💡')} Use ${chalk.cyan('@file')} to attach files (e.g., "fix @app.js")\n` +
-    `${chalk.yellow('💡')} Type ${chalk.cyan('/scan')} to load entire codebase\n` +
-    `${chalk.yellow('💡')} Type ${chalk.cyan('/agents')} to see agents, ${chalk.cyan('/agentname')} to switch\n` +
-    `${chalk.yellow('💡')} Type ${chalk.cyan('/help')} for all commands`,
-    'Quick Tips', 'gray'
-  ));
+  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'));
   console.log();
   
   // Check for updates
   await checkForUpdates();
   
+  // Ensure .sapperignore exists (create default on first run)
+  const sapperIgnoreCreated = ensureSapperIgnore();
+  if (sapperIgnoreCreated) {
+    console.log(chalk.green('📋 Created .sapperignore') + chalk.gray(' — edit it to customize ignored files'));
+  } else {
+    // Reload patterns in case file was modified since last run
+    reloadSapperIgnore();
+  }
+
+  // Ensure config file exists with defaults, or reload user's config
+  if (!fs.existsSync(CONFIG_FILE)) {
+    saveConfig(sapperConfig);
+  } else {
+    // Reload in case user edited config.json manually
+    sapperConfig = loadConfig();
+  }
+  
   // Auto-load or build workspace graph
   let workspace = loadWorkspaceGraph();
   if (!workspace.indexed) {
@@ -2101,30 +3680,39 @@ async function runSapper() {
     }
   }
   
-  // Show memory status
-  console.log(chalk.gray(`📁 Memory: .sapper/ folder`));
-  console.log(chalk.gray(`🔗 Auto-attach: ${sapperConfig.autoAttach ? 'ON' : 'OFF'} (toggle with /auto)`));
-  
   // Initialize agents and skills
   const newlyCreated = createDefaultAgentsAndSkills();
   const agents = loadAgents();
   const skills = loadSkills();
   const agentCount = Object.keys(agents).length;
   const skillCount = Object.keys(skills).length;
-  console.log(chalk.gray(`🤖 Agents: ${agentCount} available`) + chalk.gray(` │ `) + chalk.gray(`📘 Skills: ${skillCount} available`));
+  const workspaceFileCount = Object.keys(workspace.files).length;
+  const workspaceSymbolCount = Object.values(workspace.files).reduce((sum, f) => sum + (f.symbols?.length || 0), 0);
+  const workspaceAgeMinutes = workspace.indexed
+    ? 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}`)}`,
+  ];
   if (newlyCreated > 0) {
-    console.log(chalk.green(`   ✨ Created ${newlyCreated} default agents/skills in .sapper/`));
-  }
-  if (agentCount > 0) {
-    console.log(chalk.gray(`   Agents: ${Object.keys(agents).map(a => '/' + a).join(', ')}`));
+    startupLines.push(UI.slate(`${newlyCreated} default agents or skills created in .sapper/`));
   }
+  console.log(box(startupLines.join('\n'), 'Workspace', 'gray'));
   console.log();
   
   let messages = [];
   if (fs.existsSync(CONTEXT_FILE)) {
-    console.log();
-    console.log(box('Previous session found! Resume where you left off?', '📂 Session', 'green'));
-    const resume = await safeQuestion(chalk.green('\n↪ Resume? ') + chalk.gray('(y/n): '));
+    console.log(divider());
+    console.log(UI.ink('Previous session found in .sapper/context.json'));
+    const resume = await safeQuestion(confirmPrompt('Resume session', 'success'));
     if (resume.toLowerCase() === 'y') {
       messages = JSON.parse(fs.readFileSync(CONTEXT_FILE, 'utf8'));
       console.log(chalk.green('  ✓ Session restored\n'));
@@ -2165,30 +3753,58 @@ async function runSapper() {
     process.exit(1);
   }
   
-  console.log(divider());
-  console.log(statusBadge('MODELS', 'info') + chalk.gray(' Available Ollama models:\n'));
-  localModels.models.forEach((m, i) => {
-    const num = chalk.cyan.bold(`[${i + 1}]`);
-    const name = chalk.white(m.name);
-    console.log(`  ${num} ${name}`);
-  });
-  console.log(divider());
-  const choice = await safeQuestion(chalk.cyan('\n⚡ Select model: '));
-  const selectedModel = localModels.models[parseInt(choice) - 1]?.name || localModels.models[0].name;
+  const selectedModel = await pickModel(localModels.models) || localModels.models[0].name;
 
-  // ─── Detect native tool-calling support ───────────────────────────
+  // ─── Detect model capabilities & context window ───────────────────
   let useNativeTools = false;
+  let toolModeLabel = 'tool detection unavailable';
+  let contextLabel = '4,096 tokens (fallback)';
   try {
     const modelInfo = await ollama.show({ model: selectedModel });
     if (modelInfo.capabilities && modelInfo.capabilities.includes('tools')) {
       useNativeTools = true;
-      console.log(chalk.green('  ✓ ') + chalk.gray('Native tool calling: ') + chalk.green('enabled'));
+      toolModeLabel = 'native tool calling';
     } else {
-      console.log(chalk.yellow('  ℹ ') + chalk.gray('Native tool calling: ') + chalk.yellow('unavailable — using text markers'));
+      toolModeLabel = 'text markers';
+    }
+    // Extract context window size from model_info
+    // Different model families use different keys: llama.context_length, qwen2.context_length, etc.
+    if (modelInfo.model_info) {
+      for (const [key, value] of Object.entries(modelInfo.model_info)) {
+        if (key.endsWith('.context_length') && typeof value === 'number') {
+          modelContextLength = value;
+          break;
+        }
+      }
+    }
+    // Fallback: parse from parameters string (e.g. "num_ctx 4096")
+    if (!modelContextLength && modelInfo.parameters) {
+      const match = modelInfo.parameters.match(/num_ctx\s+(\d+)/);
+      if (match) modelContextLength = parseInt(match[1]);
+    }
+    if (modelContextLength) {
+      contextLabel = `${modelContextLength.toLocaleString()} tokens`;
+    } else {
+      modelContextLength = 4096; // Conservative default
+      contextLabel = '4,096 tokens (default)';
     }
   } catch (e) {
-    console.log(chalk.gray('  ℹ Tool detection skipped — using text markers'));
+    modelContextLength = 4096;
+    toolModeLabel = 'default mode';
+    contextLabel = '4,096 tokens (fallback)';
+  }
+  // Show custom limit if set
+  const effectiveCtx = effectiveContextLength();
+  if (sapperConfig.contextLimit && effectiveCtx !== modelContextLength) {
+    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)}`,
+    'Session', 'cyan'
+  ));
+  console.log();
   _useNativeToolsFlag = useNativeTools; // Set global for buildSystemPrompt
 
   // Native Ollama tool definitions (used when useNativeTools=true)
@@ -2197,13 +3813,12 @@ async function runSapper() {
       type: 'function',
       function: {
         name: 'list_directory',
-        description: 'List the contents of a directory. Use "." for current directory.',
+        description: 'List the contents of a directory. If path is omitted, use the current directory ".".',
         parameters: {
           type: 'object',
           properties: {
             path: { type: 'string', description: 'Directory path to list' }
-          },
-          required: ['path']
+          }
         }
       }
     },
@@ -2284,7 +3899,7 @@ async function runSapper() {
       type: 'function',
       function: {
         name: 'run_shell',
-        description: 'Execute a shell command in the project directory',
+        description: 'Execute a shell command in the project directory. Special commands: __shell_list__, __shell_read__ <session_id>, __shell_stop__ <session_id>.',
         parameters: {
           type: 'object',
           properties: {
@@ -2313,22 +3928,55 @@ async function runSapper() {
   // Main conversation loop - never exits unless user types 'exit'
   while (true) {
     try {
-      // Context size check - auto-summarize when too large
-      const contextSize = JSON.stringify(messages).length;
-      if (contextSize > 32000) {
+      const previousConfig = JSON.stringify(sapperConfig);
+      const reloadedConfig = loadConfig();
+      if (JSON.stringify(reloadedConfig) !== previousConfig) {
+        sapperConfig = reloadedConfig;
+        if (messages.length > 0 && messages[0]?.role === 'system') {
+          refreshSystemPrompt(messages);
+        }
+        console.log(chalk.gray(`↻ Reloaded ${CONFIG_FILE}`));
+        console.log(chalk.gray('   System prompt and runtime settings refreshed from config.'));
+      }
+
+      // Context size check - auto-summarize when approaching effective context limit
+      let estimatedTokens = estimateMessagesTokens(messages);
+      const ctxLen = effectiveContextLength();
+      const tokenThreshold = summaryTokenThreshold(ctxLen);
+      if (estimatedTokens > tokenThreshold) {
         messages = await autoSummarizeContext(messages, selectedModel);
+        estimatedTokens = estimateMessagesTokens(messages);
       }
       
       // Build prompt label with active agent/skills
-      let promptLabel = chalk.white.bold('You');
-      if (currentAgent) {
-        promptLabel += chalk.gray(' → ') + chalk.magenta.bold(currentAgent);
-      }
+      const contextPercent = ctxLen ? Math.round((estimatedTokens / ctxLen) * 100) : null;
+      const promptParts = [
+        statusBadge(selectedModel.split(':')[0] || selectedModel, 'action'),
+        currentAgent ? statusBadge(`/${currentAgent}`, 'info') : statusBadge('default', 'neutral'),
+      ];
       if (loadedSkills.length > 0) {
-        promptLabel += chalk.gray(' [') + chalk.blue(loadedSkills.join(', ')) + chalk.gray(']');
+        promptParts.push(statusBadge(`${loadedSkills.length} skill${loadedSkills.length !== 1 ? 's' : ''}`, 'success'));
       }
+      if (contextPercent !== null) {
+        const tone = contextPercent >= 85 ? 'error' : contextPercent >= 65 ? 'warning' : 'neutral';
+        promptParts.push(statusBadge(`${contextPercent}% ctx`, tone));
+      }
+
+      const promptDetail = ctxLen
+        ? `${meter(estimatedTokens, ctxLen, 24)} ${UI.slate(`${estimatedTokens.toLocaleString()}/${ctxLen.toLocaleString()} tokens`)}`
+        : UI.slate(`${estimatedTokens.toLocaleString()} estimated tokens`);
+
+      const promptText = `\n${promptShell(promptParts.join(' '), promptDetail)}`;
+      const input = await safeQuestion(promptText);
+      clearPromptEcho(promptText, input);
       
-      const input = await safeQuestion(chalk.cyan('\n┌─[') + promptLabel + chalk.cyan(']\n└─➤ '));
+      // Block empty prompts
+      if (!input.trim()) {
+        continue;
+      }
+
+      const preview = input.length > 120 ? input.substring(0, 120) + chalk.gray('...') : input;
+      console.log(UI.accent('› ') + chalk.white(preview));
       
       if (input.toLowerCase() === 'exit') {
         const stats = getSessionStats();
@@ -2369,42 +4017,57 @@ async function runSapper() {
           continue;
         }
         
-        messages = await autoSummarizeContext(messages, selectedModel);
+        messages = await autoSummarizeContext(messages, selectedModel, true);
         continue;
       }
       
       // Handle help command
       if (input.toLowerCase() === '/help') {
         console.log();
-        const helpContent = 
-          `${chalk.cyan('@')} or ${chalk.cyan('/attach')}  ${chalk.gray('│')} Pick files to attach (interactive)\n` +
-          `${chalk.cyan('@file')}          ${chalk.gray('│')} Attach file inline (e.g., @src/app.js)\n` +
-          `${chalk.cyan('/scan')}          ${chalk.gray('│')} Scan codebase into context\n` +
-          `${chalk.cyan('/index')}         ${chalk.gray('│')} Rebuild workspace graph\n` +
-          `${chalk.cyan('/graph file')}    ${chalk.gray('│')} Show related files\n` +
-          `${chalk.cyan('/symbol name')}   ${chalk.gray('│')} Search functions/classes\n` +
-          `${chalk.cyan('/auto')}          ${chalk.gray('│')} Toggle auto-attach related files\n` +
-          `${chalk.cyan('/recall')}        ${chalk.gray('│')} Search memory for relevant context\n` +
-          `${chalk.cyan('/reset /clear')}  ${chalk.gray('│')} Clear all context\n` +
-          `${chalk.cyan('/prune')}         ${chalk.gray('│')} AI-summarize context + save to memory\n` +
-          `${chalk.cyan('/context')}       ${chalk.gray('│')} Show context size\n` +
-          `${chalk.cyan('/debug')}         ${chalk.gray('│')} Toggle debug mode\n` +
-          `${chalk.cyan('/log')}           ${chalk.gray('│')} Show activity timeline\n` +
-          `${chalk.cyan('/log stats')}     ${chalk.gray('│')} Show session statistics\n` +
-          `${chalk.cyan('/log file')}      ${chalk.gray('│')} Show log file path & history\n` +
-          `${chalk.cyan('/help')}          ${chalk.gray('│')} Show this help\n` +
-          `${chalk.cyan('exit')}           ${chalk.gray('│')} Quit Sapper\n` +
-          `\n` +
-          chalk.bold.white('🤖 Agents & Skills:\n') +
-          `${chalk.cyan('/agents')}        ${chalk.gray('│')} List available agents\n` +
-          `${chalk.cyan('/skills')}        ${chalk.gray('│')} List available skills\n` +
-          `${chalk.cyan('/agentname')}     ${chalk.gray('│')} Switch to agent (e.g., /salesmanager)\n` +
-          `${chalk.cyan('/default')}       ${chalk.gray('│')} Switch back to default Sapper\n` +
-          `${chalk.cyan('/use skill')}     ${chalk.gray('│')} Load a skill (e.g., /use react)\n` +
-          `${chalk.cyan('/unload skill')}  ${chalk.gray('│')} Unload a skill\n` +
-          `${chalk.cyan('/newagent')}      ${chalk.gray('│')} Create a new agent\n` +
-          `${chalk.cyan('/newskill')}      ${chalk.gray('│')} Create a new skill`;
-        console.log(box(helpContent, '📚 Commands', 'cyan'));
+        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();
         continue;
       }
@@ -2572,12 +4235,197 @@ async function runSapper() {
       }
       
       // Handle context size command
+      // Handle /ctx command — view or set context window limit
+      if (input.toLowerCase().startsWith('/ctx')) {
+        const arg = input.substring(4).trim();
+        if (arg === 'reset' || arg === 'auto') {
+          sapperConfig.contextLimit = null;
+          saveConfig(sapperConfig);
+          console.log(chalk.green(`✅ Context limit reset to model default (${modelContextLength ? modelContextLength.toLocaleString() : 'auto'} tokens)`));
+        } else if (arg) {
+          // Parse number with optional k/K suffix (e.g. 64k, 32768)
+          let limit = null;
+          const kMatch = arg.match(/^(\d+\.?\d*)\s*[kK]$/);
+          if (kMatch) {
+            limit = Math.round(parseFloat(kMatch[1]) * 1024);
+          } else {
+            limit = parseInt(arg);
+          }
+          if (!limit || limit < 1024) {
+            console.log(chalk.yellow('Usage: /ctx <tokens>  — e.g. /ctx 64k, /ctx 32768, /ctx reset'));
+            console.log(chalk.gray('  Minimum: 1024 tokens'));
+          } else {
+            sapperConfig.contextLimit = limit;
+            saveConfig(sapperConfig);
+            const effective = effectiveContextLength();
+            console.log(chalk.green(`✅ Context limit set to ${chalk.white.bold(effective.toLocaleString())} tokens`));
+            if (modelContextLength && limit < modelContextLength) {
+              console.log(chalk.gray(`   Model supports ${modelContextLength.toLocaleString()} but will use ${limit.toLocaleString()} (saves RAM)`));
+            } else if (modelContextLength && limit > modelContextLength) {
+              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'));
+        }
+        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() === '/context') {
         const contextSize = JSON.stringify(messages).length;
-        console.log(chalk.cyan(`\n📊 Context: ${messages.length} messages, ~${Math.round(contextSize/1024)}KB`));
-        if (contextSize > 50000) {
-          console.log(chalk.yellow('⚠️  Context is large! Will auto-summarize on next message, or use /prune now.'));
+        const estTokens = estimateMessagesTokens(messages);
+        const ctxLen = effectiveContextLength();
+        const triggerPercent = summaryTriggerPercent();
+        const promptConfig = getPromptConfig();
+        const contextLines = [
+          `messages ${chalk.white(String(messages.length))} ${UI.slate('·')} raw ${chalk.white(Math.round(contextSize / 1024) + 'KB')} ${UI.slate('·')} tokens ${chalk.white('~' + estTokens.toLocaleString())}`,
+        ];
+        contextLines.push(`prompt ${chalk.white(hasCustomPromptConfig() ? 'customized' : 'default')} ${UI.slate('·')} ${chalk.white(`prepend ${promptConfig.prepend.trim() ? 'yes' : 'no'}`)} ${UI.slate('·')} ${chalk.white(`append ${promptConfig.append.trim() ? 'yes' : 'no'}`)}`);
+        contextLines.push(`thinking ${chalk.white(thinkingMode())} ${UI.slate('·')} ${UI.slate(thinkingMode() === 'auto' ? 'simple prompts skip reasoning' : thinkingMode() === 'off' ? 'reasoning hidden for all prompts' : 'reasoning enabled for all prompts')}`);
+        contextLines.push(`tools ${chalk.white(`limit ${toolRoundLimit()} rounds`)} ${UI.slate('·')} ${UI.slate('per prompt turn')}`);
+        contextLines.push(`shell ${chalk.white(shellStreamToModelEnabled() ? 'stream on' : 'stream off')} ${UI.slate('·')} ${chalk.white(`bg ${shellBackgroundMode()}`)} ${UI.slate('·')} ${chalk.white(`after ${shellBackgroundAfterSeconds()}s`)} ${UI.slate('·')} ${chalk.white(`${activeShellSessionCount()} active`)}`);
+        contextLines.push(`stream ${chalk.white(streamHeartbeatEnabled() ? 'heartbeat on' : 'heartbeat off')} ${UI.slate('·')} ${chalk.white(streamPhaseStatusEnabled() ? 'phase status on' : 'phase status off')} ${UI.slate('·')} ${chalk.white(`idle ${streamIdleNoticeSeconds()}s`)}`);
+        if (ctxLen) {
+          const usagePercent = Math.round((estTokens / ctxLen) * 100);
+          const threshold = summaryTokenThreshold(ctxLen);
+          const limitLabel = sapperConfig.contextLimit
+            ? `${ctxLen.toLocaleString()} tokens ${chalk.cyan('(custom)')}`
+            : `${ctxLen.toLocaleString()} tokens`;
+          contextLines.push(`limit ${chalk.white(limitLabel)} ${UI.slate('·')} usage ${chalk.white(usagePercent + '%')}`);
+          contextLines.push(`summary ${chalk.white(`trigger ${triggerPercent}%`)} ${UI.slate('·')} ${chalk.white(summaryPhasesEnabled() ? 'phases on' : 'phases off')}`);
+          contextLines.push(`${meter(estTokens, ctxLen, 28)} ${UI.slate(`summarize near ${threshold.toLocaleString()} tokens`)}`);
+        }
+        if (lastPromptTokens > 0) {
+          contextLines.push(`last turn ${UI.slate(`${lastPromptTokens.toLocaleString()} prompt • ${lastEvalTokens.toLocaleString()} response`)}`);
+        }
+        console.log();
+        console.log(box(contextLines.join('\n'), 'Context', 'gray'));
+        continue;
+      }
+
+      if (input.toLowerCase().startsWith('/shell')) {
+        const arg = input.substring(6).trim();
+
+        if (!arg || ['sessions', 'session', 'list', 'ls', 'status'].includes(arg.toLowerCase())) {
+          console.log();
+          console.log(renderShellSessionsPanel());
+          console.log(UI.slate('  Usage: /shell  |  /shell sessions  |  /shell read <session_id>  |  /shell stop <session_id>'));
+          continue;
+        }
+
+        const [subcommandRaw, ...rest] = arg.split(/\s+/);
+        const subcommand = subcommandRaw.toLowerCase();
+        const sessionId = rest.join(' ').trim();
+
+        if (['read', 'show', 'tail'].includes(subcommand)) {
+          const result = await handleShellSessionCommand(`__shell_read__ ${sessionId}`);
+          console.log();
+          console.log(box(String(result), sessionId ? `Shell ${sessionId}` : 'Shell Read', 'cyan'));
+          continue;
+        }
+
+        if (['stop', 'kill', 'end'].includes(subcommand)) {
+          const result = await handleShellSessionCommand(`__shell_stop__ ${sessionId}`);
+          console.log();
+          console.log(box(String(result), sessionId ? `Shell ${sessionId}` : 'Shell Stop', 'red'));
+          continue;
         }
+
+        console.log(chalk.yellow('Usage: /shell  |  /shell sessions  |  /shell read <session_id>  |  /shell stop <session_id>'));
         continue;
       }
       
@@ -2917,12 +4765,15 @@ async function runSapper() {
             messages[0] = { role: 'system', content: buildSystemPrompt(agent.content, skillContents) };
             
             console.log();
-            console.log(statusBadge(`AGENT: ${agent.description}`, 'action'));
-            const toolsInfo = agent.tools ? chalk.gray(` [tools: ${agent.tools.join(', ')}]`) : chalk.gray(' [all tools]');
-            console.log(chalk.green(`Switched to /${cmdPart} agent`) + toolsInfo);
+            console.log(box(
+              `${statusBadge('Active Agent', 'action')} ${chalk.white('/' + cmdPart)}\n` +
+              `${keyValue('Role', chalk.white(agent.description), 8)}\n` +
+              `${keyValue('Tools', agent.tools ? UI.slate(agent.tools.join(', ')) : UI.slate('all tools'), 8)}`,
+              'Agent Mode', 'magenta'
+            ));
             
             if (!prompt) {
-              console.log(chalk.gray(`Type your prompt to chat with this agent.`));
+              console.log(UI.slate('Type your prompt to chat with this agent.'));
               continue; // Just switched, no prompt to send
             }
             
@@ -2934,6 +4785,46 @@ async function runSapper() {
         }
       }
       
+      // Handle /fetch command - fetch a URL and add to context
+      if (input.toLowerCase().startsWith('/fetch')) {
+        const url = input.slice(6).trim();
+        if (!url || !url.match(/^https?:\/\//)) {
+          console.log(chalk.yellow('Usage: /fetch <url>'));
+          console.log(chalk.gray('  Example: /fetch https://docs.example.com/api'));
+          continue;
+        }
+        try {
+          const fetchSpinner = ora({ text: chalk.cyan(`🌐 Fetching ${url}...`), spinner: 'dots' }).start();
+          const rawContent = await fetchUrl(url);
+          fetchSpinner.stop();
+          
+          const isJson = rawContent.trim().startsWith('{') || rawContent.trim().startsWith('[');
+          const isHtml = rawContent.trim().startsWith('<') || rawContent.includes('<html');
+          let text;
+          if (isJson) {
+            try { text = JSON.stringify(JSON.parse(rawContent), null, 2); } catch { text = rawContent; }
+          } else if (isHtml) {
+            text = htmlToText(rawContent);
+          } else {
+            text = rawContent;
+          }
+          
+          if (text.trim().length > 0) {
+            const webContent = `\n\n══════════════════════════════════════\n🌐 WEB PAGE CONTENT\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'));
+          } else {
+            console.log(chalk.yellow('⚠️  No readable content found on that page.'));
+          }
+        } catch (e) {
+          console.log(chalk.yellow(`⚠️  Could not fetch: ${e.message}`));
+        }
+        continue;
+      }
+      
       // Handle recall command - search embeddings
       if (input.toLowerCase().startsWith('/recall')) {
         const query = input.slice(7).trim();
@@ -3022,14 +4913,24 @@ async function runSapper() {
         const fileAttachments = [];
         for (const filePath of selectedFiles) {
           try {
+            // Check .sapperignore
+            if (shouldIgnore(filePath)) {
+              console.log(chalk.yellow(`⚠️  ${filePath} is in .sapperignore — skipped`));
+              continue;
+            }
             const stats = fs.statSync(filePath);
             if (stats.size > MAX_FILE_SIZE) {
-              console.log(chalk.yellow(`⚠️  ${filePath} is too large, skipping`));
+              console.log(chalk.red.bold(`\n╔══════════════════════════════════════════════════════════╗`));
+              console.log(chalk.red.bold(`║  ⛔ FILE TOO LARGE — Cannot attach                       ║`));
+              console.log(chalk.red.bold(`╚══════════════════════════════════════════════════════════╝`));
+              console.log(chalk.yellow(`   File: ${filePath}`));
+              console.log(chalk.yellow(`   Size: ${Math.round(stats.size/1024)}KB (limit: ${Math.round(MAX_FILE_SIZE/1024)}KB)`));
+              console.log(chalk.gray(`   Tip: Use a smaller file or increase limit in .sapper/config.json\n`));
               continue;
             }
             const content = fs.readFileSync(filePath, 'utf8');
             fileAttachments.push({ path: filePath, content, size: stats.size });
-            console.log(chalk.green(`📎 Attached: ${filePath}`));
+            console.log(chalk.green(`📎 Attached: ${filePath} (${Math.round(stats.size/1024)}KB)`));
           } catch (e) {
             console.log(chalk.yellow(`⚠️  Could not read ${filePath}`));
           }
@@ -3071,10 +4972,19 @@ async function runSapper() {
         const filePath = attachMatch[1];
         try {
           if (fs.existsSync(filePath)) {
+            // Check .sapperignore
+            if (shouldIgnore(filePath)) {
+              console.log(chalk.yellow(`⚠️  @${filePath} is in .sapperignore — skipped`));
+              continue;
+            }
             const stats = fs.statSync(filePath);
             if (stats.isFile()) {
               if (stats.size > MAX_FILE_SIZE) {
-                console.log(chalk.yellow(`⚠️  @${filePath} is too large (${Math.round(stats.size/1024)}KB), skipping`));
+                console.log(chalk.red.bold(`\n╔══════════════════════════════════════════════════════════╗`));
+                console.log(chalk.red.bold(`║  ⛔ FILE TOO LARGE — Cannot attach @${filePath.padEnd(22).slice(0, 22)}║`));
+                console.log(chalk.red.bold(`╚══════════════════════════════════════════════════════════╝`));
+                console.log(chalk.yellow(`   Size: ${Math.round(stats.size/1024)}KB — exceeds ${Math.round(MAX_FILE_SIZE/1024)}KB limit`));
+                console.log(chalk.gray(`   Tip: Use a smaller file or increase limit in .sapper/config.json\n`));
               } else {
                 const content = fs.readFileSync(filePath, 'utf8');
                 fileAttachments.push({ path: filePath, content, size: stats.size });
@@ -3122,6 +5032,60 @@ async function runSapper() {
         processedInput = input + attachedContent;
       }
       
+      // ── Detect and fetch URLs in the message ──
+      const urlMatches = input.match(URL_REGEX);
+      if (urlMatches && urlMatches.length > 0) {
+        const uniqueUrls = [...new Set(urlMatches)].slice(0, 5); // Max 5 URLs
+        const urlContents = [];
+        
+        for (const url of uniqueUrls) {
+          try {
+            const urlSpinner = ora({ text: chalk.cyan(`🌐 Fetching ${url}...`), spinner: 'dots' }).start();
+            const rawContent = await fetchUrl(url);
+            urlSpinner.stop();
+            
+            // Detect content type
+            const isJson = rawContent.trim().startsWith('{') || rawContent.trim().startsWith('[');
+            const isHtml = rawContent.trim().startsWith('<') || rawContent.includes('<html');
+            
+            let text;
+            if (isJson) {
+              // Pretty-print JSON
+              try { text = JSON.stringify(JSON.parse(rawContent), null, 2); } 
+              catch { text = rawContent; }
+            } else if (isHtml) {
+              text = htmlToText(rawContent);
+            } else {
+              text = rawContent; // Plain text, markdown, etc.
+            }
+            
+            if (text.trim().length > 0) {
+              urlContents.push({ url, content: text, size: text.length });
+              console.log(chalk.green(`🌐 Fetched: ${url} (${Math.round(text.length/1024)}KB)`));
+            } else {
+              console.log(chalk.yellow(`⚠️  ${url} — no readable content`));
+            }
+          } catch (e) {
+            console.log(chalk.yellow(`⚠️  Could not fetch ${url}: ${e.message}`));
+          }
+        }
+        
+        if (urlContents.length > 0) {
+          let urlAttached = '\n\n══════════════════════════════════════\n';
+          urlAttached += `🌐 FETCHED WEB PAGES (${urlContents.length})\n`;
+          urlAttached += '══════════════════════════════════════\n\n';
+          
+          for (const page of urlContents) {
+            urlAttached += `┌─── ${page.url} ───\n`;
+            urlAttached += page.content;
+            if (!page.content.endsWith('\n')) urlAttached += '\n';
+            urlAttached += `└─── END ${page.url} ───\n\n`;
+          }
+          
+          processedInput = processedInput + urlAttached;
+        }
+      }
+      
       messages.push({ role: 'user', content: processedInput });
 
       // Log user input
@@ -3134,9 +5098,10 @@ async function runSapper() {
       } // End of if (!agentHandled)
 
       let toolRounds = 0; // Prevent infinite loops
-      const MAX_TOOL_ROUNDS = 20;
+      const MAX_TOOL_ROUNDS = toolRoundLimit();
       const patchFailures = {}; // Track consecutive PATCH failures per file: { path: count }
       const MAX_PATCH_RETRIES = 3;
+      const turnThinkingEnabled = shouldUseThinkingForInput(input);
       
       let active = true;
       while (active) {
@@ -3148,6 +5113,11 @@ async function runSapper() {
         try {
           // Build chat options — pass native tools when supported
           const chatOpts = { model: selectedModel, messages, stream: true };
+          if (effectiveContextLength()) {
+            chatOpts.options = { num_ctx: effectiveContextLength() };
+          }
+          // Thinking can be forced on, forced off, or auto-disabled for simple prompts.
+          chatOpts.think = turnThinkingEnabled;
           if (useNativeTools) {
             // Filter tool defs by agent restrictions if any
             if (currentAgentTools) {
@@ -3173,6 +5143,7 @@ async function runSapper() {
         spinner.stop();
 
         let msg = '';
+        let thinkMsg = ''; // Thinking/reasoning content from thinking models
         const MAX_RESPONSE_LENGTH = 100000; // 100KB - allow long code generation
         let lastChunkTime = Date.now();
         let repetitionCount = 0;
@@ -3181,23 +5152,88 @@ async function runSapper() {
         let wasRepetitionStopped = false;
         let nativeToolCalls = []; // Collect native tool_calls from streaming chunks
         abortStream = false; // Reset abort flag before streaming
+        let chunkPromptTokens = 0; // Track actual tokens from Ollama
+        let chunkEvalTokens = 0;
+        let isThinking = false; // Track if we're currently in thinking mode
+        let thinkingContinuationNeedsPrefix = false;
+        let lastThinkingIdleNoticeAt = 0;
+        const genStartTime = Date.now(); // Track generation elapsed time
+        let genTokenCount = 0; // Count response tokens as they stream
+        let lastVisibleActivityAt = Date.now();
+        let heartbeatInterval = null;
         
-        console.log(chalk.magenta('┌─[') + chalk.white.bold('Sapper') + chalk.magenta(']'));
-        process.stdout.write(chalk.magenta('│ '));
+        console.log(sectionTitle('Sapper', selectedModel, 'cyan'));
+        if (streamHeartbeatEnabled()) {
+          heartbeatInterval = setInterval(() => {
+            if (abortStream) return;
+
+            if (isThinking) {
+              const idleSeconds = Math.max(0, Math.floor((Date.now() - lastVisibleActivityAt) / 1000));
+              const idleThreshold = streamIdleNoticeSeconds();
+              if (idleSeconds >= idleThreshold && Date.now() - lastThinkingIdleNoticeAt >= 5000) {
+                process.stdout.write(`\n${UI.slate('  │ ')}${UI.slate.italic(`... waiting ${idleSeconds}s for more reasoning`)}\n`);
+                thinkingContinuationNeedsPrefix = true;
+                lastThinkingIdleNoticeAt = Date.now();
+              }
+              return;
+            }
+
+            renderStreamingHeartbeat({
+              genTokenCount,
+              genStartTime,
+              lastVisibleActivityAt,
+              stage: genTokenCount > 0 ? 'generating' : 'waiting-first',
+            });
+          }, 1000);
+        }
         for await (const chunk of response) {
           // Check if user pressed Ctrl+C
           if (abortStream) {
-            console.log(chalk.yellow('\n│ [Response interrupted]'));
+            console.log(UI.slate('\n[response interrupted]'));
             wasInterrupted = true;
             break;
           }
           
+          // Handle thinking/reasoning content (deepseek-r1, qwq, etc.)
+          const thinking = chunk.message.thinking;
+          if (thinking) {
+            if (!isThinking) {
+              isThinking = true;
+              process.stdout.write(`\n${UI.slate.italic('  ◇ Thinking')}\n${UI.slate('  │ ')}`);
+            }
+            // Live-stream thinking — dim italic, wrap at line breaks
+            const lines = thinking.split('\n');
+            for (let li = 0; li < lines.length; li++) {
+              if (li > 0 || thinkingContinuationNeedsPrefix) process.stdout.write(`\n${UI.slate('  │ ')}`);
+              thinkingContinuationNeedsPrefix = false;
+              process.stdout.write(UI.slate.italic(lines[li]));
+            }
+            thinkMsg += thinking;
+            lastVisibleActivityAt = Date.now();
+            lastThinkingIdleNoticeAt = 0;
+          }
+          
           const content = chunk.message.content;
           if (content) {
-            process.stdout.write(content);
+            if (isThinking) {
+              isThinking = false;
+              process.stdout.write(`\n${UI.slate('  └─')}\n\n`);
+            }
             msg += content;
+            genTokenCount++;
+            lastVisibleActivityAt = Date.now();
+            renderStreamingHeartbeat({
+              genTokenCount,
+              genStartTime,
+              lastVisibleActivityAt,
+              stage: 'generating',
+            });
           }
           
+          // Capture token stats from the final chunk (done: true)
+          if (chunk.prompt_eval_count) chunkPromptTokens = chunk.prompt_eval_count;
+          if (chunk.eval_count) chunkEvalTokens = chunk.eval_count;
+          
           // Collect native tool_calls (arrive in chunks, usually the final one)
           if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {
             nativeToolCalls.push(...chunk.message.tool_calls);
@@ -3227,32 +5263,58 @@ async function runSapper() {
             // Don't break - just warn. User can Ctrl+C if needed
           }
         }
-        console.log(chalk.magenta('└─────────────────────────────────────'));
+        if (heartbeatInterval) {
+          clearInterval(heartbeatInterval);
+          heartbeatInterval = null;
+        }
+        if (isThinking) {
+          isThinking = false;
+          process.stdout.write(`\n${UI.slate('  └─')}\n`);
+        }
+        // Clear progress line and render formatted markdown
+        process.stdout.write('\r\x1b[K');
+        showStreamPhase('Finalizing streamed response...');
+        if (msg.trim()) {
+          showStreamPhase('Rendering markdown output...');
+          console.log(renderMarkdown(msg));
+        } else {
+          console.log();
+        }
 
-        // Render AI response with markdown (only for non-tool responses displayed to user)
-        const hasTextToolCalls = msg.includes('[TOOL:') && msg.includes('[/TOOL]');
-        const hasNativeToolCalls = nativeToolCalls.length > 0;
-        if (!hasTextToolCalls && !hasNativeToolCalls && msg.trim().length > 0) {
-          try {
-            const rendered = renderMarkdown(msg);
-            // Clear raw output and re-render with markdown
-            process.stdout.write('\x1B[2K'); // clear current line
-            console.log(chalk.magenta('┌─[') + chalk.white.bold('Sapper') + chalk.magenta('] ') + chalk.gray('(rendered)'));
-            console.log(rendered);
-            console.log(chalk.magenta('└─────────────────────────────────────'));
-          } catch (e) {
-            // Markdown rendering failed, raw output already shown
+        // Update global token tracking from actual Ollama response
+        if (chunkPromptTokens > 0) {
+          lastPromptTokens = chunkPromptTokens;
+          lastEvalTokens = chunkEvalTokens;
+          const totalTokens = chunkPromptTokens + chunkEvalTokens;
+          const ctxLenDisplay = effectiveContextLength();
+          if (ctxLenDisplay) {
+            const usagePercent = Math.round((totalTokens / ctxLenDisplay) * 100);
+            const thinkNote = thinkMsg ? ` · ${UI.slate.italic(`${thinkMsg.length.toLocaleString()} chars thinking`)}` : '';
+            console.log(`${meter(totalTokens, ctxLenDisplay, 22)} ${UI.slate(`${chunkPromptTokens.toLocaleString()} prompt · ${chunkEvalTokens.toLocaleString()} response · ${usagePercent}% of context`)}${thinkNote}`);
           }
         }
+        console.log(divider('─', 'gray', 56));
 
         const aiDuration = Date.now() - aiStartTime;
-        // Build assistant message — include tool_calls if native tools were invoked
+        // Build assistant message — include tool_calls and thinking if present
         const assistantMsg = { role: 'assistant', content: msg };
+        if (thinkMsg) {
+          assistantMsg.thinking = thinkMsg;
+        }
         if (nativeToolCalls.length > 0) {
           assistantMsg.tool_calls = nativeToolCalls;
         }
         messages.push(assistantMsg);
 
+        // If interrupted, skip tool processing — go straight back to prompt
+        if (wasInterrupted) {
+          ensureSapperDir();
+          fs.writeFileSync(CONTEXT_FILE, JSON.stringify(messages, null, 2));
+          active = false;
+          resetTerminal();
+          continue;
+        }
+
         // Log AI response
         logEntry('ai', {
           charCount: msg.length,
@@ -3278,6 +5340,8 @@ async function runSapper() {
             write_file: 'WRITE', patch_file: 'PATCH', create_directory: 'MKDIR', run_shell: 'SHELL'
           };
 
+          showStreamPhase(`Running ${nativeToolCalls.length} native tool call${nativeToolCalls.length === 1 ? '' : 's'}...`);
+
           for (const tc of nativeToolCalls) {
             const fn = tc.function;
             const toolType = nativeToolNameMap[fn.name] || fn.name.toUpperCase();
@@ -3301,8 +5365,8 @@ async function runSapper() {
             try {
               switch (fn.name) {
                 case 'list_directory':
-                  result = tools.list(args.path);
-                  logEntry('file', { action: 'list', path: args.path });
+                  result = tools.list(args.path ?? '.');
+                  logEntry('file', { action: 'list', path: args.path ?? '.' });
                   break;
                 case 'read_file':
                   result = tools.read(args.path);
@@ -3360,8 +5424,11 @@ async function runSapper() {
           fs.writeFileSync(CONTEXT_FILE, JSON.stringify(messages, null, 2));
 
           if (hitToolLimit) {
+            showStreamPhase('Tool limit reached. Requesting final answer...');
             resetTerminal();
             messages.push({ role: 'user', content: 'STOP using tools now. Provide your analysis based on what you have.' });
+          } else {
+            showStreamPhase('Tool results ready. Continuing response generation...');
           }
           continue; // Loop back for AI to process tool results
         }
@@ -3430,6 +5497,8 @@ async function runSapper() {
             if (lastAiLog) lastAiLog.toolCount = toolMatches.length;
           }
 
+          showStreamPhase(`Running ${toolMatches.length} parsed tool call${toolMatches.length === 1 ? '' : 's'}...`);
+
           for (const match of toolMatches) {
             const [_, type, path, content] = match;
             
@@ -3527,11 +5596,14 @@ async function runSapper() {
           
           // If tool limit was reached, stop after processing this round
           if (hitToolLimit) {
+            showStreamPhase('Tool limit reached. Requesting final answer...');
             resetTerminal();
             messages.push({ 
               role: 'user', 
               content: 'STOP using tools now. You have enough information. Please provide your analysis based on what you have read.' 
             });
+          } else {
+            showStreamPhase('Tool results ready. Continuing response generation...');
           }
         } else {
           // No tools found - check if malformed command