@bahulam/code 2.6.17 → 2.6.18

package/src/core/tool-executor.mjs

@@ -41,6 +41,7 @@ export function createToolExecutor({
     skillInstaller = null,
     checkpoints = null,
     hookRunner = null,
+    interactionHandler = null,
 } = {}) {
     const occRegistry = createToolRegistry();
     const skillTool = occRegistry.get('Skill');
@@ -49,6 +50,23 @@ export function createToolExecutor({
         cwd: process.cwd(),
         homeDir: skillsLoader.homeDir || os.homedir(),
     });
+
+    // ── Auto-register the current working directory as a project ──
+    // Without this, shell / list_files / read_attachment fail with
+    // "No projects registered. Call get_project_overview first." on
+    // any fresh folder — including a legitimate user CWD they just
+    // cd'd into to start work. The model then has to spend a turn
+    // registering before it can do anything, which is a poor first-run
+    // UX. Fire-and-forget: if registration fails (permissions, weird
+    // FS), the model can still call get_project_overview explicitly.
+    // bypassProjectMarkers=true because we don't require a .git etc.
+    // for the current directory to be usable — the user chose to be here.
+    // Opt out via BAHULAM_SKIP_AUTO_REGISTER=true for tests or headless
+    // scripts that want a truly empty registry.
+    if (process.env.BAHULAM_SKIP_AUTO_REGISTER !== 'true') {
+        projectRegistry.register(process.cwd(), { bypassProjectMarkers: true })
+            .catch(() => { /* silent — model can register explicitly */ });
+    }
     let _searchCodeUsed = false; // tracks if search_code was called (for read_file nudge)
     let _readOnlyCacheGeneration = 0;
     const readOnlyResultCache = new Map();
@@ -595,6 +613,240 @@ export function createToolExecutor({
     // ── Tool mapping table ──────────────────────────────────────
 
     const toolMap = {
+        // 0. ask_user → interactive direction question (client-executed).
+        // The UI form is injected by the REPL via `interactionHandler`;
+        // headless/piped sessions have none and get the best-judgment
+        // fallback so the agent is never blocked on a missing human.
+        ask_user: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const question = String(args?.question || '').trim();
+            const choices = Array.isArray(args?.options)
+                ? args.options.map(o => String(o || '').trim()).filter(Boolean)
+                : [];
+            if (!question) {
+                return { success: false, output: 'ask_user requires a question.', _tool: 'ask_user' };
+            }
+            if (choices.length < 2 || choices.length > 4) {
+                return { success: false, output: 'ask_user requires 2-4 options.', _tool: 'ask_user' };
+            }
+            if (!interactionHandler || !process.stdin.isTTY) {
+                return {
+                    success: true,
+                    output: 'No interactive user is available in this session. Proceed with your best judgment and state the assumption you made.',
+                    _tool: 'ask_user',
+                };
+            }
+            const res = await interactionHandler({ question, options: choices, context: args?.context });
+            throwIfAborted(options.signal);
+            if (!res || !res.answer) {
+                return {
+                    success: true,
+                    output: 'The user declined to answer. Proceed with your best judgment and state the assumption you made.',
+                    _tool: 'ask_user',
+                };
+            }
+            return {
+                success: true,
+                output: `User answered: ${res.answer}${res.source === 'free_text' ? ' (typed answer, not one of the offered options)' : ''}`,
+                _tool: 'ask_user',
+            };
+        },
+
+        // 0b. read_attachment → chunked text extraction from a local document.
+        // Backend registers the schema; execution happens client-side because
+        // only the CLI has the user's filesystem. Supports the `path` mode
+        // (local file); `upload_id` is chat-only and returns a redirect
+        // error. Uses the shared prose-chunker so chunk boundaries and
+        // page/chunk numbering match the server-side path executor byte-
+        // for-byte (documents.py). Supports total_chunks metadata mode,
+        // chunk_range/chunk_no selection, page filtering (PDFs), and
+        // case-insensitive query substring filtering.
+        read_attachment: async (args, options = {}) => {
+            throwIfAborted(options.signal);
+            const uploadId = String(args?.upload_id || '').trim();
+            const rawPath = String(args?.path || '').trim();
+            if (uploadId && !rawPath) {
+                return {
+                    success: false,
+                    output: 'upload_id is a chat-only mode. In the CLI, pass path=<local path> to read a file the user has on disk.',
+                    _tool: 'read_attachment',
+                };
+            }
+            if (!rawPath) {
+                return {
+                    success: false,
+                    output: 'read_attachment requires path=<local path> (upload_id is chat-only).',
+                    _tool: 'read_attachment',
+                };
+            }
+            // Route through projectRegistry.resolvePath — the same helper
+            // read_file/edit_file use. This handles shell-escape unescaping,
+            // LLM-quoting normalization, and external-file registration for
+            // paths outside registered project roots (attachments in
+            // ~/Downloads, /tmp, etc. are legitimate).
+            let abs;
+            try {
+                abs = await resolvePath(rawPath, args, { allowExternalFileRead: true });
+            } catch (err) {
+                return { success: false, output: String(err?.message || err), _tool: 'read_attachment' };
+            }
+
+            const { extractFromPath } = await import('../context/prose-chunker.mjs');
+            let mime, chunks;
+            try {
+                ({ mime, chunks } = await extractFromPath(abs));
+            } catch (err) {
+                return { success: false, output: `Failed to read ${abs}: ${err?.message || err}`, _tool: 'read_attachment' };
+            }
+            if (!mime) {
+                return { success: false, output: `File not found or not a regular file: ${abs}`, _tool: 'read_attachment' };
+            }
+            if (!chunks.length) {
+                return {
+                    success: false,
+                    output: `Unsupported or empty file (mime=${mime}). Supported: pdf, txt, md/mdx, csv, tsv, json, yaml, toml, html, log, rst. For CSV/Excel analysis use read_table; for images use analyze_image.`,
+                    _tool: 'read_attachment',
+                };
+            }
+
+            // Ingest into the project's BM25 index so subsequent search_code
+            // (and future search_document) calls surface this doc's chunks.
+            // Best-effort: skip if the file isn't inside a registered project
+            // (external attachment like ~/Downloads/foo.pdf), and never let
+            // an index write fail the tool.
+            try {
+                const owningProject = projectRegistry.projectForPath(abs);
+                if (owningProject?.retriever?.addProseChunks) {
+                    const rel = path.relative(owningProject.resource.root, abs);
+                    owningProject.retriever.addProseChunks(rel, chunks);
+                }
+            } catch { /* best-effort */ }
+
+            const totalChunks = chunks.length;
+            const totalPages = new Set(chunks.map(c => c.page).filter(p => p != null)).size;
+            const totalChars = chunks.reduce((s, c) => s + c.text.length, 0);
+
+            // total_chunks metadata mode — size-before-read for large docs.
+            if (args?.total_chunks) {
+                const previewLen = Math.min(400, chunks[0].text.length);
+                const preview = chunks[0].text.slice(0, previewLen);
+                const previewSuffix = previewLen < chunks[0].text.length ? '…' : '';
+                const pagesLine = totalPages ? ` · ${totalPages} pages` : '';
+                return {
+                    success: true,
+                    output: `📄 ${path.basename(abs)} · ${totalChars} chars · ${totalChunks} chunks (0-${totalChunks - 1})${pagesLine}\n\nFirst chunk preview:\n${preview}${previewSuffix}\n\nUse chunk_range='N-M' or chunk_no=N to read specific chunks.`,
+                    _tool: 'read_attachment',
+                    _path: abs,
+                    _mime: mime,
+                    _total_chunks: totalChunks,
+                    _total_pages: totalPages,
+                    _total_chars: totalChars,
+                };
+            }
+
+            // chunk_range / chunk_no selection.
+            let selected = chunks;
+            const rangeStr = String(args?.chunk_range ?? '').trim()
+                || (args?.chunk_no !== undefined && args?.chunk_no !== null
+                    ? String(args.chunk_no).trim()
+                    : '');
+            if (rangeStr) {
+                const m = rangeStr.match(/^(\d+)(?:\s*-\s*(\d+))?$/);
+                if (!m) {
+                    return {
+                        success: false,
+                        output: `Invalid chunk_range: '${rangeStr}'. Use 'N' for a single chunk or 'N-M' for an inclusive range.`,
+                        _tool: 'read_attachment',
+                    };
+                }
+                const start = parseInt(m[1], 10);
+                const end = m[2] != null ? parseInt(m[2], 10) : start;
+                if (end < start) {
+                    return {
+                        success: false,
+                        output: `Invalid chunk_range '${rangeStr}': end (${end}) is before start (${start}).`,
+                        _tool: 'read_attachment',
+                    };
+                }
+                selected = chunks.filter(c => c.chunk_no >= start && c.chunk_no <= end);
+                if (!selected.length) {
+                    return {
+                        success: false,
+                        output: `No chunks in range ${start}-${end}. Doc has ${totalChunks} chunks (0-${totalChunks - 1}).`,
+                        _tool: 'read_attachment',
+                    };
+                }
+            }
+
+            // page filter (PDF only — no-op on text docs where page is null).
+            if (args?.page !== undefined && args?.page !== null) {
+                const p = parseInt(args.page, 10);
+                if (Number.isFinite(p)) {
+                    selected = selected.filter(c => c.page === p);
+                    if (!selected.length) {
+                        return {
+                            success: false,
+                            output: `No chunks on page ${p}. Doc has ${totalPages} pages.`,
+                            _tool: 'read_attachment',
+                        };
+                    }
+                }
+            }
+
+            // query substring filter (case-insensitive, per-chunk).
+            const query = String(args?.query || '').trim();
+            if (query) {
+                const q = query.toLowerCase();
+                selected = selected.filter(c => c.text.toLowerCase().includes(q));
+                if (!selected.length) {
+                    return {
+                        success: true,
+                        output: `(No chunks matched query="${query}".)`,
+                        _tool: 'read_attachment',
+                        _path: abs,
+                        _total_chunks: totalChunks,
+                        _returned_chunks: 0,
+                    };
+                }
+            }
+
+            // Render chunks — matches server _render_chunks format:
+            // [page N, chunk M]\n<text>\n\n
+            const maxChars = Math.max(1000, Number(args?.max_chars) || 100_000);
+            const lines = [];
+            let total = 0;
+            let truncated = false;
+            let renderedCount = 0;
+            for (const c of selected) {
+                const headerBits = [];
+                if (c.page != null) headerBits.push(`page ${c.page}`);
+                headerBits.push(`chunk ${c.chunk_no}`);
+                const block = `[${headerBits.join(', ')}]\n${c.text}`;
+                if (total + block.length + 2 > maxChars) {
+                    lines.push(`... [truncated at chunk ${c.chunk_no} to fit max_chars=${maxChars}. Use chunk_range='${c.chunk_no}-${selected[selected.length - 1].chunk_no}' to read the rest.]`);
+                    truncated = true;
+                    break;
+                }
+                lines.push(block);
+                total += block.length + 2;
+                renderedCount += 1;
+            }
+
+            const pagesLine = totalPages ? ` · ${totalPages} pages` : '';
+            const truncNote = truncated ? ' (truncated)' : '';
+            const header = `📄 ${path.basename(abs)} · ${totalChunks} chunks total${pagesLine} · showing ${renderedCount}${truncNote}\n\n`;
+            return {
+                success: true,
+                output: header + lines.join('\n\n'),
+                _tool: 'read_attachment',
+                _path: abs,
+                _mime: mime,
+                _total_chunks: totalChunks,
+                _returned_chunks: renderedCount,
+                _truncated: truncated,
+            };
+        },
+
         // 1. shell → Bash + classification + smart output filtering
         shell: async (args, options = {}) => {
             throwIfAborted(options.signal);

package/src/terminal/repl-ask-form.mjs

@@ -0,0 +1,120 @@
+/**
+ * Interactive ask_user form — rendered when the agent calls the ask_user
+ * tool mid-turn to get direction (architecture choice, design decision,
+ * ambiguous next step, conflicting instructions, …).
+ *
+ * Same raw-stdin overlay pattern as repl-model-form.mjs: pause readline,
+ * raw mode on, redraw in place, restore on exit. Two input modes:
+ *   list — ↑↓ move across options (+ an "Other" row), Enter selects,
+ *          Esc declines (agent proceeds with its own judgment)
+ *   text — the "Other" row opens a free-text line; Enter submits,
+ *          Esc returns to the list
+ */
+
+import { c } from './ansi.mjs';
+import { fitAnsiLine, writeOverlayFrame, eraseOverlayFrame } from './repl-format.mjs';
+
+const OTHER_SENTINEL = '__other__';
+
+/**
+ * @param {object} opts
+ * @param {object|null} opts.rl       readline instance to pause/resume
+ * @param {string} opts.question      the question to display
+ * @param {string[]} opts.options     2-4 option labels from the agent
+ * @param {string} [opts.context]     optional one-line context above the question
+ * @returns {Promise<{answer: string, source: 'option'|'free_text'}|null>}
+ *          null = user declined (Esc) — the agent should proceed on its own
+ */
+export async function askUserForm({ rl, question, options, context }) {
+  if (!process.stdin.isTTY) return null;
+  if (rl) rl.pause();
+
+  const optionRows = (options || []).map(o => String(o || '').trim()).filter(Boolean);
+  const rows = [...optionRows, OTHER_SENTINEL];
+
+  return await new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    let cursor = 0;
+    let renderedLines = 0;
+    let mode = 'list';   // 'list' | 'text'
+    let freeText = '';
+
+    const render = () => {
+      const cols = Math.max(60, process.stderr.columns || 120);
+      const lines = [];
+      lines.push(`  ${c.bold('Agent question')} ${c.dim('· pick an option or type your own · Esc to let the agent decide')}`);
+      if (context) {
+        lines.push(fitAnsiLine(`  ${c.dim(String(context))}`, cols - 1));
+      }
+      lines.push('');
+      lines.push(fitAnsiLine(`  ${c.brand('?')} ${c.bold(String(question || ''))}`, cols - 1));
+      lines.push('');
+      rows.forEach((row, i) => {
+        const active = i === cursor;
+        const marker = active ? c.brand('▸') : ' ';
+        if (row === OTHER_SENTINEL) {
+          if (mode === 'text' && active) {
+            lines.push(fitAnsiLine(`  ${marker} ${c.brand('Other:')} ${freeText}${c.brand('▎')}`, cols - 1));
+          } else {
+            lines.push(fitAnsiLine(`  ${marker} ${active ? c.brand('Other — type your own answer') : c.dim('Other — type your own answer')}`, cols - 1));
+          }
+        } else {
+          lines.push(fitAnsiLine(`  ${marker} ${active ? c.brand(row) : row}`, cols - 1));
+        }
+      });
+      lines.push('');
+      lines.push(fitAnsiLine(
+        mode === 'text'
+          ? `  ${c.dim('type your answer · Enter submit · Esc back to options')}`
+          : `  ${c.dim('↑↓ move · Enter select · Esc decline (agent decides)')}`,
+        cols - 1,
+      ));
+      writeOverlayFrame(renderedLines, lines);
+      renderedLines = lines.length;
+    };
+
+    const cleanup = (value) => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.setRawMode(wasRaw || false);
+      eraseOverlayFrame(renderedLines);
+      if (rl) rl.resume();
+      resolve(value);
+    };
+
+    const onData = (data) => {
+      const key = data.toString('utf8');
+
+      if (mode === 'text') {
+        if (key === '\x1b') { mode = 'list'; freeText = ''; render(); return; }
+        if (key === '\x03') { cleanup(null); return; }
+        if (key === '\r' || key === '\n') {
+          const answer = freeText.trim();
+          if (answer) { cleanup({ answer, source: 'free_text' }); }
+          return;
+        }
+        if (key === '\x7f' || key === '\b') { freeText = freeText.slice(0, -1); render(); return; }
+        // Ignore other escape sequences (arrows etc.) while typing.
+        if (key.startsWith('\x1b')) return;
+        const printable = [...key].filter(ch => ch >= ' ').join('');
+        if (printable) { freeText += printable; render(); }
+        return;
+      }
+
+      // list mode
+      if (key === '\x1b' || key === '\x03' || key === 'q') { cleanup(null); return; }
+      if (key === '\r' || key === '\n') {
+        const row = rows[cursor];
+        if (row === OTHER_SENTINEL) { mode = 'text'; freeText = ''; render(); return; }
+        cleanup({ answer: row, source: 'option' });
+        return;
+      }
+      if (key === '\x1b[A') { cursor = Math.max(0, cursor - 1); render(); return; }
+      if (key === '\x1b[B') { cursor = Math.min(rows.length - 1, cursor + 1); render(); return; }
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', onData);
+    render();
+  });
+}

package/src/terminal/repl-render.mjs

@@ -385,8 +385,11 @@ export function renderToolResult(data, eventType = 'tool_result') {
   // ── Single-line combined emit ──
   // If the head for this call is still buffered (no interleaving content
   // landed), and the combined line fits the terminal width, emit ONE line
-  // and skip the gutter entirely.
-  if (runtime.pendingHead && runtime.pendingHead.callId === callId && !hasLint && !runtime.pendingHead.head.includes('\n')) {
+  // and skip the gutter entirely. Multi-line result text (shell preview
+  // with rows + "+ N more" tail) skips this path — a wrapped multi-line
+  // block needs its own real estate.
+  const outcomeIsMultiLine = outcome.includes('\n');
+  if (runtime.pendingHead && runtime.pendingHead.callId === callId && !hasLint && !runtime.pendingHead.head.includes('\n') && !outcomeIsMultiLine) {
     const cols = process.stderr.columns || 120;
     const combined = `${runtime.pendingHead.head}  ${outcome}`;
     if (stripAnsi(combined).length <= cols) {
@@ -421,7 +424,15 @@ export function renderToolResult(data, eventType = 'tool_result') {
   }
 
   // Two-line shape: gutter under the (already-printed or just-flushed) head.
-  process.stderr.write(`${gutter}${outcome}\n`);
+  // Multi-line outcome (shell preview with rows + "+ N more" tail): prepend
+  // the gutter to each line so the block stays aligned instead of ragged.
+  if (outcomeIsMultiLine) {
+    for (const line of outcome.split('\n')) {
+      process.stderr.write(`${gutter}${line}\n`);
+    }
+  } else {
+    process.stderr.write(`${gutter}${outcome}\n`);
+  }
   if (diffPreview) {
     process.stderr.write(`${diffPreview}\n`);
     rememberFileDiffPreview(data);

package/src/terminal/repl.mjs

@@ -30,6 +30,7 @@ import { buildWorkScope, promptProjectRoots } from '../core/work-scope.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { readShippedCatalog } from '../config/model-catalog.mjs';
+import { askUserForm } from './repl-ask-form.mjs';
 import { runPreflight } from '../onboarding/preflight.mjs';
 import { printBanner as printBrandedBanner } from '../ui/banner.mjs';
 import { renderMissionReport, saveReport, toMarkdown as missionMarkdown } from '../ui/mission-report.mjs';
@@ -1437,6 +1438,33 @@ function renderEvent(event) {
       break;
     }
 
+    case 'summarize': {
+      // Backend collapsed older history into a summary. Two phases:
+      //   pre_turn  — fires at the start of a new turn before hydration
+      //   mid_turn  — fires between iterations during a long autonomous run
+      // Both share the same env threshold (BAHULAM_SUMMARIZE_THRESHOLD,
+      // default 160k est tokens). One cache miss per fire; each fires at
+      // most once per turn.
+      stopSpinner();
+      flushContent();
+      flushPendingHead();
+      renderBlockBoundary('status', { compactSame: true });
+      const phase = String(data?.phase || 'pre_turn');
+      const phaseTag = phase === 'mid_turn' ? 'mid-turn' : 'pre-turn';
+      const collapsed = Number(data?.collapsed_messages || 0);
+      const kept = Number(data?.kept_recent || 0);
+      const before = Number(data?.before_est_tokens || 0);
+      const beforeK = before ? ` · ~${Math.round(before / 1000)}k est tokens` : '';
+      const keptPart = kept ? ` · kept last ${kept}` : '';
+      const preview = String(data?.summary_preview || '').trim();
+      process.stderr.write(`  ${c.brand('✎')} ${c.dim(`context summarized (${phaseTag}) · ${collapsed} older message${collapsed === 1 ? '' : 's'} collapsed${keptPart}${beforeK}`)}\n`);
+      if (preview) {
+        process.stderr.write(`    ${c.dim('› ' + preview)}\n`);
+      }
+      runtime.lastRenderedBlock = 'status';
+      break;
+    }
+
     case 'reconnecting': {
       stopSpinner();
       flushContent();
@@ -1686,6 +1714,23 @@ function renderEvent(event) {
       // diverts for explore-category tools and folded verbosity modes.
       // Dedup-consecutive inside the push keeps repeat tools quiet.
       pushSubAgentWindowLine(`→ ${tool}`);
+      // Rich-mode fallback: when the render queue isn't active (bare TTY,
+      // --plain, or before the input dock mounts), the live window under
+      // the spinner is invisible — pushSubAgentWindowLine feeds into a
+      // status block that never renders. Guarantee sub-agent tool activity
+      // is visible by emitting a small dim transcript line too, dedup'd
+      // per (agentType, tool). Queue-active mode keeps its clean spinner
+      // + window; the fallback line is only for the "otherwise blind"
+      // case that surfaced in 2.6.17 reports.
+      if (!rqueue.isActive()) {
+        const label = data?.label || '';
+        const hint = label ? ` · ${label}` : '';
+        const key = `${agentType}:${tool}:${label}`;
+        if (session._lastSubAgentInlineKey !== key) {
+          session._lastSubAgentInlineKey = key;
+          process.stderr.write(`    ${c.dim(`→ ${agentType} · ${tool}${hint}`)}\n`);
+        }
+      }
       // Don't clobber an active explore-run spinner. "exploring · 5 read ·
       // 2 searched" is more informative than "explore → search_code", and
       // sub_agent_tool fires on every step of a sub-agent — otherwise the
@@ -2877,8 +2922,9 @@ async function handleCommand(input, ctx) {
       // Session autopilot for long-running jobs: auto-approve routine
       // writes/shell while STILL prompting for dangerous tiers (rm,
       // force-push, command substitution, …) and never overriding hard
-      // safety blocks. Distinct from the launch-time --freeswim flag,
-      // which approves everything including dangerous tiers.
+      // safety blocks. Distinct from the launch-time
+      // --dangerously-skip-permissions flag, which approves everything
+      // including dangerous tiers.
       const sub = (rest || '').trim().toLowerCase();
       if (sub === 'off') {
         ctx.approval.approveAll = false;
@@ -3182,8 +3228,30 @@ export async function startTerminalRepl() {
   let latestProjectContext = null;
   let latestEnvelope = null;
   let hookRunner = new HookRunner({ cwd: safeCwd() });
-  let toolExecutor = createToolExecutor({ checkpoints, hookRunner });
-  const skipPerms = cliArgs.freeswim;
+
+  // ask_user tool → interactive overlay form (repl-ask-form.mjs). `ctx` is
+  // declared below; the arrow only dereferences it at call time (mid-turn),
+  // so the lazy reference is safe. Stop the spinner and flush streamed
+  // content first so the overlay doesn't fight the render queue.
+  const askUserInteraction = async (req) => {
+    stopSpinner();
+    flushContent();
+    const res = await askUserForm({
+      rl: ctx?._rl || null,
+      question: req?.question || '',
+      options: Array.isArray(req?.options) ? req.options : [],
+      context: req?.context || '',
+    });
+    if (res?.answer) {
+      process.stderr.write(`  ${c.green('✓')} ${c.dim('answered:')} ${c.brand(res.answer)}\n`);
+    } else {
+      process.stderr.write(`  ${c.dim('Question declined — agent proceeds with its own judgment.')}\n`);
+    }
+    return res;
+  };
+
+  let toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
+  const skipPerms = cliArgs.skipPermissions;
   let approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
 
   // Session manager — persists conversation messages to .bahulam/conversations/
@@ -3276,7 +3344,7 @@ export async function startTerminalRepl() {
     checkpoints = new CheckpointManager(safeCwd());
     effectivePolicy = loadEffectivePolicy({ cwd: safeCwd() });
     hookRunner = new HookRunner({ cwd: safeCwd() });
-    toolExecutor = createToolExecutor({ checkpoints, hookRunner });
+    toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
     approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
     if (ctx._rl) approval.setReadline(ctx._rl);
     sessionMgr = new SessionManager(safeCwd());
@@ -3456,7 +3524,7 @@ export async function startTerminalRepl() {
     checkpoints = new CheckpointManager(safeCwd());
     effectivePolicy = loadEffectivePolicy({ cwd: safeCwd() });
     hookRunner = new HookRunner({ cwd: safeCwd(), sessionId });
-    toolExecutor = createToolExecutor({ checkpoints, hookRunner });
+    toolExecutor = createToolExecutor({ checkpoints, hookRunner, interactionHandler: askUserInteraction });
     approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
     if (ctx._rl) approval.setReadline(ctx._rl);
     sessionMgr = new SessionManager(safeCwd());
@@ -3576,7 +3644,7 @@ export async function startTerminalRepl() {
 
     // Preflight diagnostic (PRD-055 §9). Non-blocking; opt-out via
     // KEPLER_NO_PREFLIGHT=1 (used by tests / scripted runs).
-    if (process.env.KEPLER_NO_PREFLIGHT !== '1' && !cliArgs.freeswim) {
+    if (process.env.KEPLER_NO_PREFLIGHT !== '1' && !cliArgs.skipPermissions) {
       try { await runPreflight({ auth, cwd: safeCwd(), version: VERSION }); }
       catch { /* preflight is best-effort */ }
     }
@@ -4714,7 +4782,10 @@ export async function startTerminalRepl() {
       startSpinner('thinking…');
 
       const execContext = { cwd: safeCwd() };
-      if (skipPerms) execContext.freeswim = true;
+      if (skipPerms) {
+        execContext.skip_permissions = true;
+        execContext.freeswim = true; // legacy wire alias — drop after cloud backend 2.7 rollout
+      }
       effectivePolicy = loadEffectivePolicy({ cwd: safeCwd() });
       approval.policy = effectivePolicy.policy;
       if (approval.trustStore) approval.trustStore.policy = effectivePolicy.policy;
@@ -4754,7 +4825,10 @@ export async function startTerminalRepl() {
       ctx.latestProjectContext = latestProjectContext;
       ctx.latestEnvelope = latestEnvelope;
       Object.assign(execContext, latestEnvelope);
-      if (skipPerms) execContext.freeswim = true;
+      if (skipPerms) {
+        execContext.skip_permissions = true;
+        execContext.freeswim = true; // legacy wire alias — drop after cloud backend 2.7 rollout
+      }
       const modelOverrides = Object.fromEntries(sessionModelOverrideEntries());
       if (Object.keys(modelOverrides).length > 0) {
         execContext.model_overrides = modelOverrides;

package/src/ui/tool-card.mjs

@@ -156,6 +156,14 @@ export function summarizeResult(tool, data) {
       if (tool === 'shell') {
         const structured = structuredOutputSummary(data.output_preview || data.output);
         if (structured) return structured;
+        // Multi-row preview: first N rows + a "+ M more" tail so long
+        // outputs (e.g. `ls`) surface their scale instead of collapsing
+        // to a single first line with no hint that more exists.
+        const { preview, remaining } = outputPreviewRows(data, shellPreviewRows());
+        if (!preview) return { text: 'ok', tone: 'success' };
+        if (remaining === 0) return { text: preview, tone: 'success' };
+        const tail = paint.text.dim(`+ ${remaining} more row${remaining === 1 ? '' : 's'}`);
+        return { text: `${preview}\n${tail}`, tone: 'success' };
       }
       const head = firstOutputLine(data).slice(0, 100);
       return { text: head || 'ok', tone: 'success' };
@@ -413,6 +421,24 @@ function firstOutputLine(data) {
   return String(o).split('\n').map(l => l.trim()).find(Boolean) || '';
 }
 
+// Preview the first N non-empty output rows, joined by \n. Returns
+// { preview, remaining, total } — remaining is how many non-empty rows
+// were dropped past N. Long individual rows get clipped to `perRow` chars.
+function outputPreviewRows(data, n, perRow = 200) {
+  const o = data?.output_preview ?? data?.output ?? data?.message ?? '';
+  const rows = String(o).split('\n').map(l => l.trim()).filter(Boolean);
+  const shown = rows.slice(0, n).map(l => l.length > perRow ? l.slice(0, perRow - 1) + '…' : l);
+  return { preview: shown.join('\n'), remaining: Math.max(0, rows.length - n), total: rows.length };
+}
+
+// Default rows shown in the shell result preview. Overridable via env for
+// power users; keep it small — the result line rides above every command
+// and eats vertical space in a long session.
+function shellPreviewRows() {
+  const raw = parseInt(process.env.BAHULAM_SHELL_PREVIEW_ROWS ?? '', 10);
+  return Number.isFinite(raw) && raw >= 1 ? raw : 2;
+}
+
 function lineCount(s) {
   if (!s) return 0;
   return String(s).split('\n').filter(Boolean).length;