@bahulam/code 2.6.13 → 2.6.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "2.6.13",
+  "version": "2.6.15",
   "description": "Bahulam Code \u2014 abundance, in your terminal. CLI-first, reliability-first, sub-agents, 65.6% SWE-bench Verified.",
   "type": "module",
   "bin": {
@@ -49,8 +49,8 @@
     "web-tree-sitter": "^0.26.9"
   },
   "optionalDependencies": {
-    "@bahulam/runtime-darwin-arm64": "2.6.13",
-    "@bahulam/runtime-linux-x64": "2.6.13",
-    "@bahulam/runtime-win32-x64": "2.6.13"
+    "@bahulam/runtime-darwin-arm64": "2.6.15",
+    "@bahulam/runtime-linux-x64": "2.6.15",
+    "@bahulam/runtime-win32-x64": "2.6.15"
   }
 }

package/src/agents/scaffold.mjs

@@ -204,6 +204,7 @@ export async function syncAgentsToBackend({
     headers: {
       Authorization: `Bearer ${token}`,
       'Content-Type': 'application/json',
+      'X-Product': 'bahulam',
     },
     body: JSON.stringify(payload),
     signal: AbortSignal.timeout(timeoutMs),

package/src/commands/agent.mjs

@@ -59,7 +59,7 @@ function getAuth() {
     const auth = new TarangAuth();
     const creds = auth.loadCredentials();
     if (!creds.token) {
-        process.stderr.write(`${RED}✗ Not authenticated. Run `bahulam-code login` first.${RESET}\n`);
+        process.stderr.write(`${RED}✗ Not authenticated. Run bahulam-code login first.${RESET}\n`);
         process.exit(1);
     }
     return creds;
@@ -76,13 +76,14 @@ async function apiFetch(path, options = {}) {
     const headers = {
         'Authorization': `Bearer ${creds.token}`,
         'Content-Type': 'application/json',
+        'X-Product': 'bahulam',
         ...options.headers,
     };
     const url = `${baseUrl}${path}`;
     const response = await fetch(url, { ...options, headers });
 
     if (response.status === 401) {
-        process.stderr.write(`${RED}✗ Authentication failed. Run `bahulam-code login` to re-authenticate.${RESET}\n`);
+        process.stderr.write(`${RED}✗ Authentication failed. Run bahulam-code login to re-authenticate.${RESET}\n`);
         process.exit(1);
     }
 

package/src/core/approval-log.mjs

@@ -1,7 +1,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { isSensitiveConfigPath } from './safety.mjs';
 
 const REDACTED = 'REDACTED';
+const MAX_ARG_LOG_CHARS = 4000;
+const MAX_PROMPT_SUBJECT_CHARS = 4000;
+const MAX_PROMPT_REASON_CHARS = 1200;
 const SENSITIVE_KEY_RE = /^(?:authorization|api[-_]?key|apikey|key|token|access[-_]?token|refresh[-_]?token|secret|password|passwd|pwd|access[-_]?key|secret[-_]?access[-_]?key)$|(?:^|[-_])(?:api[-_]?key|apikey|token|secret|password|passwd|pwd|access[-_]?key|secret[-_]?access[-_]?key)(?:$|[-_])/i;
 const SENSITIVE_ASSIGNMENT_KEY = String.raw`[A-Z0-9_-]*(?:API[-_]?KEY|APIKEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|ACCESS[-_]?KEY|SECRET[-_]?ACCESS[-_]?KEY)[A-Z0-9_-]*`;
 const SENSITIVE_JSON_KEY = String.raw`(?:authorization|api[-_]?key|apikey|key|token|access[-_]?token|refresh[-_]?token|secret|password|passwd|pwd|access[-_]?key|secret[-_]?access[-_]?key|[A-Z0-9_-]*(?:API[-_]?KEY|APIKEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|ACCESS[-_]?KEY|SECRET[-_]?ACCESS[-_]?KEY)[A-Z0-9_-]*)`;
@@ -48,10 +52,32 @@ function sanitizeForLog(value, depth = 0) {
 }
 
 function safeArgs(args) {
-  if (args?.command) return redactSensitive(String(args.command)).slice(0, 500);
-  if (args?.file_path || args?.path) return redactSensitive(String(args.file_path || args.path)).slice(0, 500);
-  try { return JSON.stringify(sanitizeForLog(args || {})).slice(0, 500); }
-  catch { return redactSensitive(String(args || '')).slice(0, 500); }
+  if (args?.command) return redactSensitive(String(args.command)).slice(0, MAX_ARG_LOG_CHARS);
+  if (args?.file_path || args?.path) return redactSensitive(String(args.file_path || args.path)).slice(0, MAX_ARG_LOG_CHARS);
+  if (Array.isArray(args?.files)) {
+    try {
+      const { files, ...rest } = args;
+      return JSON.stringify({
+        ...sanitizeForLog(rest),
+        files: files.slice(0, 100).map(file => sanitizeProjectFileArg(file)),
+      }).slice(0, MAX_ARG_LOG_CHARS);
+    } catch {
+      return '[files omitted]';
+    }
+  }
+  try { return JSON.stringify(sanitizeForLog(args || {})).slice(0, MAX_ARG_LOG_CHARS); }
+  catch { return redactSensitive(String(args || '')).slice(0, MAX_ARG_LOG_CHARS); }
+}
+
+function sanitizeProjectFileArg(file) {
+  if (typeof file === 'string') return redactSensitive(file);
+  if (!file || typeof file !== 'object') return sanitizeForLog(file);
+  const out = sanitizeForLog(file);
+  const filePath = file.path || file.file_path || '';
+  if (isSensitiveConfigPath(filePath) && typeof out.content === 'string') {
+    out.content = '[redacted sensitive config]';
+  }
+  return out;
 }
 
 function safeText(value, max = 500) {
@@ -59,6 +85,19 @@ function safeText(value, max = 500) {
   return redactSensitive(String(value)).slice(0, max);
 }
 
+function safePrompt(prompt) {
+  if (!prompt || typeof prompt !== 'object') return undefined;
+  const out = {
+    title: safeText(prompt.title, 200),
+    subject: safeText(prompt.subject, MAX_PROMPT_SUBJECT_CHARS),
+    reason: safeText(prompt.reason, MAX_PROMPT_REASON_CHARS),
+  };
+  for (const key of Object.keys(out)) {
+    if (out[key] === undefined) delete out[key];
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
 export class ApprovalLog {
   constructor({ cwd = process.cwd() } = {}) {
     this.cwd = cwd;
@@ -68,6 +107,7 @@ export class ApprovalLog {
   append(entry) {
     try {
       fs.mkdirSync(path.dirname(this.filePath), { recursive: true, mode: 0o700 });
+      const prompt = safePrompt(entry.prompt);
       const line = JSON.stringify({
         ts: new Date().toISOString(),
         tier: entry.tier,
@@ -77,6 +117,7 @@ export class ApprovalLog {
         scope: entry.scope || 'once',
         rule_id: entry.rule_id || null,
         reason: safeText(entry.reason),
+        ...(prompt ? { prompt } : {}),
       });
       fs.appendFileSync(this.filePath, line + '\n', { mode: 0o600 });
       try { fs.chmodSync(this.filePath, 0o600); } catch {}

package/src/core/approval.mjs

@@ -10,7 +10,7 @@
  * Shell commands are risk-assessed (safe/medium/high).
  */
 
-import { shellCommandDisplay, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import { shellCommandDisplay, shellCommandProfile, toolDisplaySummary } from '../terminal/tool-display.mjs';
 import {
   classify as classifyTier,
   TIERS,
@@ -20,11 +20,12 @@ import {
 } from './risk-tier.mjs';
 import {
   renderApprovalPrompt,
+  renderApprovalDockPrompt,
   renderTrustedApproval,
   defaultOptions as approvalOptions,
 } from '../ui/approval.mjs';
-import { isInputDockMounted, moveToContent } from '../ui/input-dock.mjs';
-import { validateShellCommand } from './safety.mjs';
+import { clearInputPrompt, isInputDockMounted, moveToContent, renderDockOverlay } from '../ui/input-dock.mjs';
+import { isApprovalRequiredWritePath, isSensitiveConfigPath, validateShellCommand } from './safety.mjs';
 import { classifyCommand } from '../permissions/command-classifier.mjs';
 import { ApprovalLog } from './approval-log.mjs';
 import { TrustStore } from './trust.mjs';
@@ -45,9 +46,19 @@ const WRITE_TOOLS = new Set([
 
 function defaultWhy(tier, tool, args) {
     const subject = approvalSummary(tool, args);
+    const protectedTarget = protectedWriteTarget(tool, args);
+    if (protectedTarget) {
+        const target = protectedTarget.path;
+        if (protectedTarget.sensitive) {
+            return `Edits sensitive environment config (${target}). Confirm before writing; values stay redacted in summaries and diffs.`;
+        }
+        return `Edits protected project file (${subject || target}). Confirm before writing.`;
+    }
     switch (tier) {
         case TIERS.SENSITIVE_READ:
             return `Reads a sensitive path (${subject || 'secret-like file'}). Confirm before exposing its contents to the agent.`;
+        case TIERS.PROTECTED_EDIT:
+            return `Edits a protected project file. Confirm before writing.`;
         case TIERS.SHELL_DANGEROUS:
             return `Shell command matches a high-risk pattern (rm -rf, sudo, force push, etc.). Confirm before running.`;
         case TIERS.DESTRUCTIVE:
@@ -61,6 +72,26 @@ function defaultWhy(tier, tool, args) {
     }
 }
 
+function protectedWriteTarget(tool, args = {}) {
+    const paths = writeTargetPaths(tool, args);
+    const path = paths.find(isApprovalRequiredWritePath);
+    if (!path) return null;
+    return { path, sensitive: isSensitiveConfigPath(path) };
+}
+
+function writeTargetPaths(tool, args = {}) {
+    const key = String(tool || '').toLowerCase();
+    if (key === 'write_file' || key === 'edit_file') {
+        return [args.file_path || args.path].filter(Boolean);
+    }
+    if (key === 'write_project') {
+        return (args.files || [])
+            .map(file => typeof file === 'string' ? file : file?.path || file?.file_path)
+            .filter(Boolean);
+    }
+    return [];
+}
+
 function approvalSummary(tool, args = {}) {
     const summary = toolDisplaySummary(tool, args);
     if (tool !== 'shell') return summary;
@@ -72,12 +103,22 @@ function shellHardBlockReason(tool, args = {}) {
     if (tool !== 'shell') return '';
     const command = args.command || args.cmd || '';
     const safety = validateShellCommand(command);
-    if (!safety.safe) return safety.reason || 'Blocked by shell safety policy';
+    if (!safety.safe) return withShellRetryHint(safety.reason || 'Blocked by shell safety policy');
     const classification = classifyCommand(command);
-    if (classification.classification === 'blocked') return classification.reason || 'Blocked by shell safety policy';
+    if (classification.classification === 'blocked') {
+        return withShellRetryHint(classification.reason || 'Blocked by shell safety policy');
+    }
     return '';
 }
 
+function withShellRetryHint(reason) {
+    const text = String(reason || '').trim();
+    if (/command substitution|backticks|\$\(\)/i.test(text)) {
+        return `${text}. Retry with separate simple shell commands instead of backticks or $().`;
+    }
+    return text;
+}
+
 // ── ANSI helpers ──
 
 const RST = '\x1b[0m';
@@ -107,13 +148,39 @@ export class ApprovalManager {
         this.history = [];
         this.rejectionHints = [];
         this._rl = null;
+        this._approvalPromptActive = false;
+        this._approvalPromptWasRaw = false;
     }
 
     setReadline(rl) { this._rl = rl; }
 
-    setExecutionHooks({ onPause, onResume } = {}) {
+    setExecutionHooks({ onPause, onResume, onApprovalPromptEnd } = {}) {
         this._execPause = onPause || null;
         this._execResume = onResume || null;
+        this._approvalPromptEnd = onApprovalPromptEnd || null;
+    }
+
+    _beginApprovalInput() {
+        if (this._approvalPromptActive || !process.stdin.isTTY) return false;
+        this._approvalPromptActive = true;
+        this._approvalPromptWasRaw = process.stdin.isRaw;
+        if (this._execPause) this._execPause();
+        if (this._rl) this._rl.pause();
+        if (typeof process.stdin.setRawMode === 'function') {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        return true;
+    }
+
+    _endApprovalInput() {
+        if (!this._approvalPromptActive) return;
+        if (typeof process.stdin.setRawMode === 'function') {
+            process.stdin.setRawMode(this._approvalPromptWasRaw || false);
+        }
+        if (this._rl) this._rl.resume();
+        if (this._execResume) this._execResume();
+        this._approvalPromptActive = false;
     }
 
     revoke() {
@@ -143,7 +210,8 @@ export class ApprovalManager {
             const reason = `Blocked by safety policy: ${hardBlock}`;
             this.history.push({ tool: toolName, decision: 'safety-block', tier, time: Date.now(), reason });
             this.approvalLog.append({ tool: toolName, args, tier, decision: 'safety_block', scope: 'none', reason });
-            write(`  ${RED}✗${RST}  ${DIM}${reason}${RST}\n\n`);
+            if (isInputDockMounted()) moveToContent();
+            writeSafetyBlock(reason);
             return { approved: false, tier, reason, blocked: true, code: 'safety_block' };
         }
 
@@ -203,25 +271,48 @@ export class ApprovalManager {
     async _prompt(toolName, args, context = {}) {
         const tier = context.tier || classifyTier(toolName, args);
         const why = context.reason || context.why || defaultWhy(tier, toolName, args);
-        const options = this._optionsFor(tier);
+        const options = this._optionsFor(tier, toolName, args);
 
         let selected = 0; // arrow-driven cursor
         let printedHeight = 0;
+        let showDetails = false;
+
+        const isInteractive = process.stdin.isTTY;
 
-        // Approval must render ABOVE the fixed input dock (in the scrollable
-        // content area) so it doesn't collide with the "+ add instruction"
-        // prompt. Move cursor into content once; the in-place redraw below
-        // stays within that region because printedHeight tracks the anchor.
-        if (isInputDockMounted()) moveToContent();
+        // In rich TTY mode approval lives in the fixed input dock, replacing
+        // "+ add instruction" until the user decides. Fallback/plain mode
+        // still renders in the transcript.
+        const useDockPrompt = isInteractive && isInputDockMounted();
+        if (!useDockPrompt && isInputDockMounted()) moveToContent();
 
         // For TTYs we redraw in place on every arrow key so the prompt feels
         // live. For non-TTYs / pipes we just print once and read a line.
-        const isInteractive = process.stdin.isTTY;
         if (!isInteractive) {
-            write(renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options }) + '\n');
+            write(renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options, showDetails }) + '\n');
         }
 
         const drawPrompt = () => {
+            if (useDockPrompt) {
+                const dock = renderApprovalDockPrompt({
+                    tool: toolName,
+                    args,
+                    tier,
+                    why,
+                    selected,
+                    options,
+                    showDetails,
+                    width: process.stderr.columns || process.stdout.columns || 96,
+                });
+                renderDockOverlay({
+                    context: dock.context,
+                    lines: dock.lines || [`${dock.prefix || ''}${dock.value || ''}`],
+                    meta: dock.meta,
+                    tips: dock.tips,
+                    maxRows: dock.maxRows,
+                });
+                printedHeight = 0;
+                return;
+            }
             // Move up over the previous render before re-printing. Use a
             // bounded per-line clear instead of \x1b[J — a full clear-to-end
             // would wipe the input dock's bottom rule and tips row that live
@@ -234,11 +325,14 @@ export class ApprovalManager {
                 }
                 write(`\x1b[${printedHeight}F`); // back to the anchor row
             }
-            const block = renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options });
+            const block = renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options, showDetails });
             write(block + '\n');
             printedHeight = block.split('\n').length;
         };
 
+        const ownsApprovalInput = isInteractive ? this._beginApprovalInput() : false;
+
+        try {
         if (isInteractive) drawPrompt();
 
         // ── Input loop ─────────────────────────────────────────────────
@@ -266,6 +360,11 @@ export class ApprovalManager {
                 // Letter shortcut: match against option.key
                 if (typeof k === 'string' && k.length === 1) {
                     const lower = k.toLowerCase();
+                    if (lower === 'd' && toolName === 'shell') {
+                        showDetails = !showDetails;
+                        if (isInteractive) drawPrompt();
+                        continue;
+                    }
                     const idx = options.findIndex(o => o.key === lower);
                     if (idx >= 0) {
                         selected = idx;
@@ -278,28 +377,35 @@ export class ApprovalManager {
         };
 
         const value = await choose();
+        if (useDockPrompt) {
+            clearInputPrompt();
+            if (this._approvalPromptEnd) this._approvalPromptEnd();
+            moveToContent();
+        }
+        const prompt = promptForLog(toolName, args, tier, why);
 
         switch (value) {
             case 'approve':
                 this.history.push({ tool: toolName, decision: 'yes', tier, time: Date.now() });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve', scope: 'once' });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve', scope: 'once', prompt });
+                writeApprovalConfirmation(toolName, args, 'approved once');
                 return { approved: true, tier };
 
             case 'allow-session': {
-                if (!this.policy.hitl?.allowSessionTrust) return this._prompt(toolName, args, context);
+                if (!this.policy.hitl?.allowSessionTrust) return await this._prompt(toolName, args, context);
                 const rule = this.trustStore.add({ tool: toolName, args, tier, scope: 'SESSION' });
                 write(`  ${GREEN}✓${RST}  ${DIM}trusted for this session: ${rule.pattern}${RST}\n\n`);
                 this.history.push({ tool: toolName, decision: 'session-trust', tier, time: Date.now(), rule_id: rule.id });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'SESSION', rule_id: rule.id });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'SESSION', rule_id: rule.id, prompt });
                 return { approved: true, tier, scope: 'SESSION', rule_id: rule.id };
             }
 
             case 'allow-project': {
-                if (!this.policy.hitl?.allowProjectTrust) return this._prompt(toolName, args, context);
+                if (!this.policy.hitl?.allowProjectTrust) return await this._prompt(toolName, args, context);
                 const rule = this.trustStore.add({ tool: toolName, args, tier, scope: 'PROJECT' });
                 write(`  ${GREEN}✓${RST}  ${DIM}trusted for this project: ${rule.pattern}${RST}\n\n`);
                 this.history.push({ tool: toolName, decision: 'project-trust', tier, time: Date.now(), rule_id: rule.id });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'PROJECT', rule_id: rule.id });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve_trusted', scope: 'PROJECT', rule_id: rule.id, prompt });
                 return { approved: true, tier, scope: 'PROJECT', rule_id: rule.id };
             }
 
@@ -308,30 +414,31 @@ export class ApprovalManager {
                 const reason = 'User stopped the command';
                 write(`  ${RED}✗${RST}  ${DIM}stopped${RST}\n\n`);
                 this.history.push({ tool: toolName, decision: 'no', tier, time: Date.now(), reason });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'reject', scope: 'once', reason });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'reject', scope: 'once', reason, prompt });
                 this._rememberRejection({ tool: toolName, args, tier, decision: 'reject', reason, note: '' });
                 return { approved: false, tier, reason };
             }
 
             case 'allow-all':
-                if (requiresExplicitApproval(tier)) return this._prompt(toolName, args, context);
+                if (requiresExplicitApproval(tier)) return await this._prompt(toolName, args, context);
                 this.approveAll = true;
                 write(`  ${GREEN}✓✓${RST} ${DIM}allow-all activated${RST}\n\n`);
                 this.history.push({ tool: toolName, decision: 'approve-all', tier, time: Date.now() });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve-all', scope: 'session' });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'approve-all', scope: 'session', prompt });
                 return { approved: true, tier };
 
             case 'allow-type':
-                if (requiresExplicitApproval(tier)) return this._prompt(toolName, args, context);
+                if (requiresExplicitApproval(tier)) return await this._prompt(toolName, args, context);
                 this.approvedToolTypes.add(toolName);
                 this.history.push({ tool: toolName, decision: 'type-approve', tier, time: Date.now() });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'type-approve', scope: 'session' });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'type-approve', scope: 'session', prompt });
+                writeApprovalConfirmation(toolName, args, 'always allow');
                 return { approved: true, tier };
 
             case 'why':
                 write(`\n  ${DIM}${(context.reason || why).slice(0, 400)}${RST}\n\n`);
                 printedHeight = 0;
-                return this._prompt(toolName, args, context);
+                return await this._prompt(toolName, args, context);
 
             case 'edit':
             case 'replan':
@@ -340,13 +447,16 @@ export class ApprovalManager {
                 const reason = note ? `User asked to re-plan: ${note}` : 'User asked to re-plan';
                 write(`  ${YELLOW}↩${RST}  ${DIM}${note ? `re-plan — ${truncateNote(note)}` : 'reject with hint — rework the plan'}${RST}\n\n`);
                 this.history.push({ tool: toolName, decision: 'replan', tier, time: Date.now(), reason });
-                this.approvalLog.append({ tool: toolName, args, tier, decision: 'replan', scope: 'once', reason });
+                this.approvalLog.append({ tool: toolName, args, tier, decision: 'replan', scope: 'once', reason, prompt });
                 this._rememberRejection({ tool: toolName, args, tier, decision: 'replan', reason, note });
                 return { approved: false, tier, reason };
             }
 
             default:
-                return this._prompt(toolName, args, context);
+                return await this._prompt(toolName, args, context);
+        }
+        } finally {
+            if (ownsApprovalInput) this._endApprovalInput();
         }
     }
 
@@ -357,16 +467,25 @@ export class ApprovalManager {
                 return;
             }
 
-            if (this._execPause) this._execPause();
-            if (this._rl) this._rl.pause();
+            const managesInput = !this._approvalPromptActive;
+            if (managesInput) {
+                if (this._execPause) this._execPause();
+                if (this._rl) this._rl.pause();
+            }
 
             const wasRaw = process.stdin.isRaw;
-            process.stdin.setRawMode(true);
+            if (managesInput && typeof process.stdin.setRawMode === 'function') {
+                process.stdin.setRawMode(true);
+            }
             process.stdin.resume();
             process.stdin.once('data', (data) => {
-                process.stdin.setRawMode(wasRaw || false);
-                if (this._rl) this._rl.resume();
-                if (this._execResume) this._execResume();
+                if (managesInput) {
+                    if (typeof process.stdin.setRawMode === 'function') {
+                        process.stdin.setRawMode(wasRaw || false);
+                    }
+                    if (this._rl) this._rl.resume();
+                    if (this._execResume) this._execResume();
+                }
 
                 const bytes = [...data];
                 const str = data.toString();
@@ -395,8 +514,11 @@ export class ApprovalManager {
                 return;
             }
 
-            if (this._execPause) this._execPause();
-            if (this._rl) this._rl.pause();
+            const managesInput = !this._approvalPromptActive;
+            if (managesInput) {
+                if (this._execPause) this._execPause();
+                if (this._rl) this._rl.pause();
+            }
 
             const wasRaw = process.stdin.isRaw;
             if (typeof process.stdin.setRawMode === 'function') {
@@ -411,8 +533,10 @@ export class ApprovalManager {
                 if (typeof process.stdin.setRawMode === 'function') {
                     process.stdin.setRawMode(wasRaw || false);
                 }
-                if (this._rl) this._rl.resume();
-                if (this._execResume) this._execResume();
+                if (managesInput) {
+                    if (this._rl) this._rl.resume();
+                    if (this._execResume) this._execResume();
+                }
             };
             const finish = () => {
                 cleanup();
@@ -439,8 +563,8 @@ export class ApprovalManager {
         });
     }
 
-    _optionsFor(tier) {
-        return approvalOptions(tier);
+    _optionsFor(tier, toolName, args) {
+        return approvalOptions(tier, { tool: toolName, args });
     }
 
     getSummary() {
@@ -474,3 +598,103 @@ function truncateNote(note) {
     const text = String(note || '').trim();
     return text.length <= 120 ? text : text.slice(0, 119) + '…';
 }
+
+function promptForLog(tool, args, tier, why) {
+    return {
+        title: `${approvalTitleForLog(tier)} · ${tierLabel(tier)} · ${tool || 'tool'}`,
+        subject: approvalSummary(tool, args),
+        reason: why || '',
+    };
+}
+
+function approvalTitleForLog(tier) {
+    switch (tier) {
+        case TIERS.SENSITIVE_READ:
+        case TIERS.PROTECTED_EDIT:
+        case TIERS.SHELL_DANGEROUS:
+        case TIERS.DESTRUCTIVE:
+            return 'EXPLICIT APPROVAL';
+        default:
+            return 'APPROVAL';
+    }
+}
+
+function writeApprovalConfirmation(tool, args, label) {
+    if (tool === 'shell') {
+        write(`  ${GREEN}✓${RST}  ${DIM}${label} · shell ${shellApprovalSubject(args)}${RST}\n`);
+        return;
+    }
+    const subject = approvalSummary(tool, args);
+    const suffix = subject ? ` · ${truncateNote(subject)}` : '';
+    write(`  ${GREEN}✓${RST}  ${DIM}${label}${suffix}${RST}\n\n`);
+}
+
+function shellApprovalSubject(args = {}) {
+    const profile = shellCommandProfile(args.command || args.cmd || '');
+    const subject = profile.compact ? profile.summary : profile.command;
+    return `$ ${truncateNote(subject)}`;
+}
+
+function writeSafetyBlock(reason) {
+    const cols = Math.max(40, Math.min(process.stderr.columns || process.stdout.columns || 80, 140));
+    const firstPrefix = `  ${RED}✗${RST}  ${DIM}`;
+    const nextPrefix = `     ${DIM}`;
+    const firstWidth = Math.max(24, cols - 5);
+    const nextWidth = Math.max(24, cols - 5);
+    const lines = wrapSafetyText(reason, firstWidth, nextWidth);
+
+    write(`${firstPrefix}${lines[0] || ''}${RST}\n`);
+    for (const line of lines.slice(1)) {
+        write(`${nextPrefix}${line}${RST}\n`);
+    }
+    write('\n');
+}
+
+function wrapSafetyText(text, firstWidth, nextWidth) {
+    const words = String(text || '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
+    if (!words.length) return [''];
+
+    const lines = [];
+    let line = '';
+    let width = firstWidth;
+
+    for (const word of words) {
+        if (!line) {
+            if (word.length <= width) {
+                line = word;
+            } else {
+                const chunks = splitWord(word, width);
+                lines.push(...chunks.slice(0, -1));
+                line = chunks[chunks.length - 1] || '';
+            }
+            continue;
+        }
+
+        if (line.length + 1 + word.length <= width) {
+            line += ` ${word}`;
+            continue;
+        }
+
+        lines.push(line);
+        width = nextWidth;
+        if (word.length <= width) {
+            line = word;
+        } else {
+            const chunks = splitWord(word, width);
+            lines.push(...chunks.slice(0, -1));
+            line = chunks[chunks.length - 1] || '';
+        }
+    }
+
+    if (line) lines.push(line);
+    return lines;
+}
+
+function splitWord(word, width) {
+    const size = Math.max(8, width);
+    const chunks = [];
+    for (let i = 0; i < word.length; i += size) {
+        chunks.push(word.slice(i, i + size));
+    }
+    return chunks;
+}

package/src/core/file-diff.mjs

@@ -8,7 +8,7 @@ export function buildFileDiff({
   after = '',
   cwd = process.cwd(),
   context = 3,
-  maxDiffLines = 400,
+  maxDiffLines = Infinity,
 } = {}) {
   const oldText = before == null ? '' : String(before);
   const newText = after == null ? '' : String(after);