@axplusb/kepler 2.0.7 → 2.2.0

package/src/tools/bash.mjs

@@ -17,6 +17,7 @@ function stripAnsi(str) {
 }
 
 const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
+const TIMEOUT_TAIL_BYTES = 64 * 1024;
 
 export const BashTool = {
     name: 'Bash',
@@ -47,6 +48,8 @@ export const BashTool = {
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
+            let stdoutTail = '';
+            let stderrTail = '';
             let killed = false;
             let exitCode = null;
 
@@ -54,27 +57,28 @@ export const BashTool = {
                 cwd: input.cwd,
                 env: { ...process.env },
                 stdio: ['pipe', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
                 timeout: 0, // we handle timeout ourselves
             });
 
             proc.stdout.on('data', (chunk) => {
-                if (stdout.length < MAX_OUTPUT_BYTES) {
-                    stdout += chunk.toString();
-                }
+                const text = chunk.toString();
+                stdout = appendHead(stdout, text, MAX_OUTPUT_BYTES);
+                stdoutTail = appendTail(stdoutTail, text, TIMEOUT_TAIL_BYTES);
             });
 
             proc.stderr.on('data', (chunk) => {
-                if (stderr.length < MAX_OUTPUT_BYTES) {
-                    stderr += chunk.toString();
-                }
+                const text = chunk.toString();
+                stderr = appendHead(stderr, text, MAX_OUTPUT_BYTES);
+                stderrTail = appendTail(stderrTail, text, TIMEOUT_TAIL_BYTES);
             });
 
             // Timeout: SIGTERM first, then SIGKILL after 5s
             const timer = setTimeout(() => {
                 killed = true;
-                proc.kill('SIGTERM');
+                killProcess(proc, 'SIGTERM');
                 setTimeout(() => {
-                    try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+                    killProcess(proc, 'SIGKILL');
                 }, 5000);
             }, timeout);
 
@@ -95,7 +99,8 @@ export const BashTool = {
                 stderr = stripAnsi(stderr);
 
                 if (killed) {
-                    resolve(`Error: Command timed out after ${timeout}ms\n${stdout}\n${stderr}`.trim());
+                    const tail = formatTimeoutTail(stdoutTail, stderrTail);
+                    resolve(`Error: Command timed out after ${timeout}ms\n${tail}`.trim());
                     return;
                 }
 
@@ -118,6 +123,49 @@ export const BashTool = {
     },
 };
 
+function appendHead(current, chunk, maxBytes) {
+    if (current.length >= maxBytes) return current;
+    const next = current + chunk;
+    return next.length > maxBytes ? next.slice(0, maxBytes) : next;
+}
+
+function appendTail(current, chunk, maxBytes) {
+    const next = current + chunk;
+    return next.length > maxBytes ? next.slice(next.length - maxBytes) : next;
+}
+
+function formatTimeoutTail(stdoutTail, stderrTail) {
+    const out = stripAnsi(stdoutTail || '').trim();
+    const err = stripAnsi(stderrTail || '').trim();
+    const lines = [];
+    if (out) {
+        lines.push('[stdout tail]');
+        lines.push(tailLines(out, 80));
+    }
+    if (err) {
+        if (lines.length) lines.push('');
+        lines.push('[stderr tail]');
+        lines.push(tailLines(err, 80));
+    }
+    return lines.length ? lines.join('\n') : '(no output captured before timeout)';
+}
+
+function tailLines(text, maxLines) {
+    const lines = String(text || '').split('\n');
+    return lines.slice(-maxLines).join('\n');
+}
+
+function killProcess(proc, signal) {
+    if (!proc?.pid) return;
+    try {
+        if (process.platform !== 'win32') {
+            process.kill(-proc.pid, signal);
+            return;
+        }
+    } catch { /* fall through to direct process kill */ }
+    try { proc.kill(signal); } catch { /* already exited */ }
+}
+
 // Background jobs store
 const backgroundJobs = new Map();
 let bgJobId = 0;

package/src/tools/project-overview.mjs

@@ -64,6 +64,19 @@ function isWithin(root, candidate) {
     return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 
+function uniqueValues(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+
+function canonicalRoot(rootPath) {
+    const resolved = path.resolve(normalizePathInput(rootPath));
+    try {
+        return fs.realpathSync(resolved);
+    } catch {
+        return resolved;
+    }
+}
+
 function canonicalizeCandidate(candidate) {
     if (fs.existsSync(candidate)) return fs.realpathSync(candidate);
 
@@ -233,6 +246,9 @@ function formatResource(resource) {
     if (resource.project_context) {
         lines.push('', '--- Project Context ---', resource.project_context);
     }
+    if (resource.style) {
+        lines.push('', '--- Project Style ---', resource.style);
+    }
     if (resource.goal) {
         lines.push('', '--- Current Goal ---', resource.goal);
     }
@@ -261,27 +277,53 @@ function _scanSkills(keplerDir) {
     const skillsDir = path.join(keplerDir, 'skills');
     if (!fs.existsSync(skillsDir)) return [];
     try {
-        return fs.readdirSync(skillsDir)
-            .filter(f => f.endsWith('.md'))
-            .map(f => {
-                const content = fs.readFileSync(path.join(skillsDir, f), 'utf-8');
+        return fs.readdirSync(skillsDir, { withFileTypes: true })
+            .map(entry => {
+                const file = entry.isDirectory()
+                    ? path.join(skillsDir, entry.name, 'SKILL.md')
+                    : path.join(skillsDir, entry.name);
+                if (!fs.existsSync(file) || !file.endsWith('.md')) return null;
+                const content = fs.readFileSync(file, 'utf-8');
                 const descMatch = content.match(/^#\s+.*\n+(.+)/);
                 return {
-                    name: f.replace('.md', ''),
-                    description: descMatch ? descMatch[1].slice(0, 100) : f.replace('.md', ''),
+                    name: entry.isDirectory() ? entry.name : entry.name.replace('.md', ''),
+                    description: content.match(/^description:\s*(.+)$/mi)?.[1]?.trim()
+                        || (descMatch ? descMatch[1].slice(0, 100) : entry.name.replace('.md', '')),
                 };
-            });
+            })
+            .filter(Boolean);
     } catch { return []; }
 }
 
+function defaultScratchRoots() {
+    return uniqueValues([
+        '/tmp',
+        '/private/tmp',
+        os.tmpdir(),
+        process.env.TMPDIR,
+        ...(process.env.KEPLER_SCRATCH_ROOTS || '')
+            .split(path.delimiter)
+            .map(s => s.trim())
+            .filter(Boolean),
+    ]).map(canonicalRoot);
+}
+
 export class ProjectRegistry {
     constructor() {
         this.projects = new Map();
+        this.scratchRoots = new Set(defaultScratchRoots());
         this._globalIdentity = null;
         this._globalPreferences = null;
         this._globalSkills = null;
     }
 
+    addScratchRoot(rawPath) {
+        if (!rawPath) return null;
+        const root = canonicalRoot(rawPath);
+        this.scratchRoots.add(root);
+        return root;
+    }
+
     /**
      * Load global context from ~/.kepler/ (once per session).
      */
@@ -382,10 +424,13 @@ export class ProjectRegistry {
             fs.writeFileSync(resourcePath, JSON.stringify(resource));
         }
 
-        // Read project-level context files (.kepler/project.md, goal.md, skills/)
+        // Read project-level context files (.kepler/KEPLER.md, project.md, goal.md, plan.md, style.md, skills/)
         const keplerDir = path.join(root, '.kepler');
         resource.environment = detectEnvironment();
-        resource.project_context = _readIfExists(keplerDir, 'project.md', 8000);
+        resource.project_context = _readIfExists(keplerDir, 'KEPLER.md', 10000) ||
+            _readIfExists(root, 'KEPLER.md', 10000) ||
+            _readIfExists(keplerDir, 'project.md', 8000);
+        resource.style = _readIfExists(keplerDir, 'style.md', 4000);
         resource.goal = _readIfExists(keplerDir, 'goal.md', 2000);
         resource.plan = _readIfExists(keplerDir, 'plan.md', 6000);
         resource.skills_index = _scanSkills(keplerDir);
@@ -410,6 +455,23 @@ export class ProjectRegistry {
         return this.projects.get(projectIdValue) || null;
     }
 
+    projectScratchRoots() {
+        return this.resources().map(resource => path.join(resource.root, '.kepler', 'tmp'));
+    }
+
+    allowedScratchRoots() {
+        return uniqueValues([
+            ...this.scratchRoots,
+            ...this.projectScratchRoots(),
+        ]).map(canonicalRoot);
+    }
+
+    isAllowedScratchPath(filePath) {
+        const normalized = normalizePathInput(filePath);
+        const candidate = canonicalizeCandidate(path.resolve(normalized));
+        return this.allowedScratchRoots().some(root => isWithin(root, candidate));
+    }
+
     resolvePath(rawPath, projectIdValue, { allowMissing = false } = {}) {
         let root = null;
         if (projectIdValue) {
@@ -453,8 +515,12 @@ export class ProjectRegistry {
         const findContaining = (cand) => [...this.projects.values()].find(({ resource }) =>
             isWithin(resource.root, cand)
         );
+        const findScratchRoot = (cand) => this.allowedScratchRoots().find(scratchRoot =>
+            isWithin(scratchRoot, cand)
+        );
 
         let containingProject = findContaining(candidate);
+        let containingScratchRoot = containingProject ? null : findScratchRoot(candidate);
 
         // Two reasons to try the unescaped variant:
         //   (1) candidate is outside every project root (literal "Tarang\ Orca"
@@ -473,12 +539,19 @@ export class ProjectRegistry {
                     if (altProject && (allowMissing || fs.existsSync(altCandidate))) {
                         candidate = altCandidate;
                         containingProject = altProject;
+                        containingScratchRoot = null;
+                    } else {
+                        const altScratchRoot = findScratchRoot(altCandidate);
+                        if (altScratchRoot && (allowMissing || fs.existsSync(altCandidate))) {
+                            candidate = altCandidate;
+                            containingScratchRoot = altScratchRoot;
+                        }
                     }
                 } catch { /* fall through to the original error */ }
             }
         }
 
-        if (!containingProject) {
+        if (!containingProject && !containingScratchRoot) {
             throw new Error(`Path is outside registered project roots: ${rawPath}`);
         }
         if (!allowMissing && !fs.existsSync(candidate)) {

package/src/ui/approval.mjs

@@ -34,20 +34,19 @@ const PAD_X = 3;
  *   hint  — secondary description shown to the right of the label
  */
 export function defaultOptions(tier) {
+  const shared = [
+    { key: 'y', label: 'approve once',  value: 'approve',  hint: 'run this call' },
+    { key: 'r', label: 're-plan with note...',  value: 'replan',   hint: 'steer the agent' },
+    { key: 'n', label: 'stop', value: 'reject',   hint: 'do not run' },
+    { key: '?', label: 'why',      value: 'why',      hint: 'show reasoning' },
+  ];
   if (requiresExplicitApproval(tier)) {
-    return [
-      { key: 'y', label: 'approve',  value: 'approve',  hint: 'run this once' },
-      { key: 'e', label: 'edit',     value: 'edit',     hint: 'tweak the args before running' },
-      { key: 'r', label: 're-plan',  value: 'replan',   hint: 'send back to the agent' },
-      { key: 'n', label: 'reject',   value: 'reject',   hint: 'do not run' },
-      { key: '?', label: 'why',      value: 'why',      hint: 'show reasoning' },
-    ];
+    return shared;
   }
   return [
-    { key: 'y', label: 'approve',         value: 'approve',     hint: 'run this once' },
+    shared[0],
     { key: 't', label: 'always allow',    value: 'allow-type',  hint: 'auto-approve future calls to this tool' },
-    { key: 'n', label: 'reject',          value: 'reject',      hint: 'do not run' },
-    { key: '?', label: 'why',             value: 'why',         hint: 'show reasoning' },
+    ...shared.slice(1),
   ];
 }
 
@@ -88,22 +87,30 @@ export function renderApprovalPrompt({
   const explicit = requiresExplicitApproval(tier);
   const accent = explicit ? paint.brand.accent : paint.brand.data;
   const opts = options || defaultOptions(tier);
-
-  const summary = toolDisplaySummary(tool, args, {});
-  const toolLine = `${icon(tool)} ${paint.text.primary(toolDisplayLabel(tool))} ${paint.text.muted(summary ? `"${truncate(summary, cols - 20)}"` : '')}`;
+  const available = cols - 2 - PAD_X * 2;
+  const title = `${riskIcon(tier)}  ${approvalTitle(tier)} · ${tierLabel(tier)} · ${tool || 'tool'}`;
 
   const lines = [
     bar(cols, accent),
-    fill(' AWAITING APPROVAL', cols, accent, paint.bold(accent('AWAITING APPROVAL'))),
+    fill(' ' + ' '.repeat(PAD_X - 1) + paint.bold(accent(title)), cols, accent),
     fill('', cols, accent),
-    fill(' ' + ' '.repeat(PAD_X - 1) + toolLine, cols, accent),
+    ...subjectRows(tool, args, cols, accent),
     fill('', cols, accent),
-    fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('Tier: ') + accent(tierLabel(tier)), cols, accent),
   ];
   if (why) {
-    lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('Why:  ') + paint.text.primary(truncate(why, cols - PAD_X - 12)), cols, accent));
+    const whyLines = wrapText(why, Math.max(20, available - 6));
+    lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('Why  ') + paint.text.primary(whyLines[0]), cols, accent));
+    for (const line of whyLines.slice(1, 4)) {
+      lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('     ') + paint.text.primary(line), cols, accent));
+    }
+    if (whyLines.length > 4) {
+      lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('     ...'), cols, accent));
+    }
+  } else {
+    lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('Why  ') + paint.text.muted('No additional reason provided'), cols, accent));
   }
   lines.push(fill('', cols, accent));
+  lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + paint.text.dim('Decision:'), cols, accent));
 
   for (let i = 0; i < opts.length; i++) {
     const o = opts[i];
@@ -111,7 +118,7 @@ export function renderApprovalPrompt({
     const cursor = isSel ? accent('▸ ') : paint.text.dim('  ');
     const keyTag = paint.text.dim('[') + (isSel ? accent(o.key) : paint.brand.data(o.key)) + paint.text.dim('] ');
     const label = isSel ? paint.bold(accent(o.label)) : paint.text.primary(o.label);
-    const hint = o.hint ? '   ' + paint.text.muted(o.hint) : '';
+    const hint = o.hint ? '  ' + paint.text.muted(o.hint) : '';
     lines.push(fill(' ' + ' '.repeat(PAD_X - 1) + cursor + keyTag + label + hint, cols, accent));
   }
 
@@ -119,12 +126,20 @@ export function renderApprovalPrompt({
   lines.push(fill(' ' + ' '.repeat(PAD_X - 1) +
     paint.text.dim('↑↓ ') + paint.brand.data('move') +
     paint.text.dim('  ·  Enter ') + paint.brand.data('pick') +
-    paint.text.dim('  ·  or press a letter'), cols, accent));
+    paint.text.dim('  ·  letter shortcut  ·  Esc stop'), cols, accent));
   lines.push(bar(cols, accent));
 
   return '\n' + lines.join('\n');
 }
 
+export function renderTrustedApproval({ tool, args = {}, scope = 'session', ruleId = '', delaySeconds = 0 } = {}) {
+  const summary = toolDisplaySummary(tool, args, {});
+  const subject = `${tool || 'tool'}${summary ? ` "${truncate(summary, 80)}"` : ''}`;
+  const rule = ruleId ? ` · rule ${ruleId}` : '';
+  const delay = delaySeconds > 0 ? ` · auto-approved after ${delaySeconds}s` : '';
+  return `  ${paint.state.success('✓')} ${paint.text.primary(subject)} ${paint.text.dim(`· pre-approved (${String(scope || 'session').toLowerCase()}${rule})${delay}`)}\n`;
+}
+
 function bar(width, painter) {
   // Top / bottom rule: a magenta vertical-stack line spanning the full width.
   return painter('▔'.repeat(width));
@@ -142,26 +157,130 @@ function truncate(text, n) {
   return s.slice(0, Math.max(0, n - 1)) + '…';
 }
 
-// ── Inline (safe-default) prompt for shell-medium / network ────────────
+// ── Compatibility wrapper ──────────────────────────────────────────────
 
 /**
- * Render the compact one-line prompt used for safe-default tiers.
- * The bordered block is reserved for explicit-approval tiers.
- *
- *   ? Run `npm install lodash`?  Tier: SHELL-MEDIUM   [Enter=yes  n=no  ?=why]
+ * Render the unified approval prompt. Kept as a named export for older call
+ * sites/tests that imported the previous inline renderer.
  */
 export function renderInlinePrompt({ tool, args = {}, tier, why = '' } = {}) {
-  const summary = toolDisplaySummary(tool, args, {});
-  const label = toolDisplayLabel(tool);
-  const lines = [];
-  const head = `${paint.brand.data('?')} ${paint.text.primary(label)} ${paint.text.muted(summary ? `"${truncate(summary, 80)}"` : '')}`;
-  lines.push('  ' + head);
-  lines.push('  ' + paint.text.dim('Tier ') + paint.brand.data(tierLabel(tier)) +
-             (why ? '   ' + paint.text.dim('Why ') + paint.text.muted(truncate(why, 60)) : ''));
-  lines.push('  ' + paint.text.dim('[') + paint.brand.data('Enter') + paint.text.dim('=yes  ') +
-             paint.brand.data('n') + paint.text.dim('=no  ') +
-             paint.brand.data('?') + paint.text.dim('=why]'));
-  return '\n' + lines.join('\n');
+  return renderApprovalPrompt({ tool, args, tier, why });
 }
 
 export { TIERS };
+
+function riskIcon(tier) {
+  switch (tier) {
+    case TIERS.SENSITIVE_READ:
+      return '🔐';
+    case TIERS.SHELL_DANGEROUS:
+    case TIERS.DESTRUCTIVE:
+      return '🔴';
+    case TIERS.SHELL_MEDIUM:
+      return '⚠';
+    case TIERS.NETWORK:
+      return '🌐';
+    case TIERS.LOCAL_EDIT:
+      return '✎';
+    default:
+      return '◈';
+  }
+}
+
+function tierTitle(tier) {
+  switch (tier) {
+    case TIERS.SENSITIVE_READ: return 'SENSITIVE';
+    case TIERS.SHELL_DANGEROUS: return 'DANGEROUS';
+    case TIERS.DESTRUCTIVE: return 'DESTRUCTIVE';
+    case TIERS.SHELL_MEDIUM: return 'MEDIUM';
+    case TIERS.NETWORK: return 'NETWORK';
+    case TIERS.LOCAL_EDIT: return 'EDIT';
+    case TIERS.SHELL_SAFE: return 'SAFE';
+    case TIERS.READ: return 'READ';
+    default: return tierLabel(tier);
+  }
+}
+
+function approvalTitle(tier) {
+  switch (tier) {
+    case TIERS.SENSITIVE_READ:
+    case TIERS.SHELL_DANGEROUS:
+    case TIERS.DESTRUCTIVE:
+      return tierTitle(tier);
+    default:
+      return 'APPROVAL';
+  }
+}
+
+function subjectRows(tool, args, cols, accent) {
+  const available = cols - 2 - PAD_X * 2;
+  const prefix = ' ' + ' '.repeat(PAD_X - 1);
+  const rows = [];
+  const summary = toolDisplaySummary(tool, args, {});
+  const label = `${icon(tool)} ${paint.text.primary(toolDisplayLabel(tool))}`;
+  rows.push(fill(prefix + label, cols, accent));
+
+  for (const line of subjectDetails(tool, args, summary, available)) {
+    rows.push(fill(prefix + paint.text.primary(line), cols, accent));
+  }
+  return rows;
+}
+
+function subjectDetails(tool, args = {}, summary = '', available = 72) {
+  if (tool === 'shell') {
+    const command = args.command || args.cmd || summary || '';
+    const lines = wrapText(command, available);
+    return lines.length ? lines : ['(empty command)'];
+  }
+  if (tool === 'write_file') {
+    const file = args.file_path || args.path || summary || '';
+    const lineCount = typeof args.content === 'string' ? args.content.split('\n').length : null;
+    return [`${file}${lineCount ? ` · ${lineCount} lines` : ''}`];
+  }
+  if (tool === 'edit_file') {
+    const file = args.file_path || args.path || '';
+    const search = String(args.search || args.old_string || '').trim();
+    const replacement = String(args.replace || args.new_string || '').trim();
+    const details = [`${file || summary}`];
+    if (search) details.push(`match: ${truncate(search, available - 7)}`);
+    if (replacement) details.push(`replace: ${truncate(replacement, available - 9)}`);
+    return details.slice(0, 4);
+  }
+  if (tool === 'delete_file') {
+    return [args.file_path || args.path || summary || ''];
+  }
+  if (tool === 'WebFetch' || tool === 'fetch_url') {
+    const url = args.url || summary || '';
+    return [`Target ${hostFromUrl(url) || url}`];
+  }
+  return wrapText(summary || JSON.stringify(args || {}), available).slice(0, 4);
+}
+
+function hostFromUrl(url) {
+  try {
+    return new URL(String(url)).host;
+  } catch {
+    return '';
+  }
+}
+
+function wrapText(text, width) {
+  const words = String(text || '').split(/\s+/).filter(Boolean);
+  if (!words.length) return [''];
+  const lines = [];
+  let line = '';
+  for (const word of words) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if ((line + ' ' + word).length <= width) {
+      line += ' ' + word;
+    } else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}

package/src/ui/formatter.mjs

@@ -9,6 +9,7 @@
  */
 
 import { toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import { formatMessageWindow } from '../core/rate-limit-display.mjs';
 
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -65,6 +66,9 @@ export class EventFormatter {
                 this._toolDone(data);
                 return true;
             case 'complete':
+                if (data?.rate_limit) {
+                    this.sessionInfo = { ...(this.sessionInfo || {}), rate_limit: data.rate_limit };
+                }
                 this._complete(data);
                 return true;
             case 'error':
@@ -121,12 +125,11 @@ export class EventFormatter {
 
     _status(data) {
         const msg = data?.message || '';
-        // Skip noisy statuses
+        // Skip noisy per-turn statuses. Backend emits "Creating agent..." and
+        // "Task type: ..." on every SSE turn (v3_sse.py:566), not just the first —
+        // repeating them clutters the transcript.
         if (!msg || msg === 'Agent started') return;
-        if (msg.startsWith('Creating agent') || msg.startsWith('Task type:')) {
-            process.stderr.write(`${DIM}  ${msg}${RESET}\n`);
-            return;
-        }
+        if (msg.startsWith('Creating agent') || msg.startsWith('Task type:')) return;
         process.stderr.write(`  ${this._spinner()} ${CYAN}${msg}${RESET}\n`);
     }
 
@@ -183,6 +186,14 @@ export class EventFormatter {
 
         const label = toolDisplayLabel(tool);
         const summary = toolDisplaySummary(tool, args);
+        if (tool === 'shell' && summary) {
+            process.stderr.write(`  ${this._spinner()} [${this.toolCount}] ${CYAN}${label}${RESET}\n`);
+            for (const line of wrapShellSummary(summary, 100)) {
+                process.stderr.write(`  ${DIM}  ${line}${RESET}\n`);
+            }
+            this.toolCalls.push({ name: tool, callId, startTime: Date.now() });
+            return;
+        }
         const detail = summary ? `${DIM}${summary}${RESET}` : '';
         process.stderr.write(`  ${this._spinner()} [${this.toolCount}] ${CYAN}${label}${RESET}${detail ? `  ${detail}` : ''}\n`);
 
@@ -334,6 +345,11 @@ export class EventFormatter {
             process.stderr.write(`\n  ${GREEN}✓ Done${stats}${RESET}\n`);
         }
 
+        const rateLimitLine = formatMessageWindow(data?.rate_limit || this.sessionInfo?.rate_limit);
+        if (rateLimitLine) {
+            process.stderr.write(`  ${DIM}Messages: ${rateLimitLine}${RESET}\n`);
+        }
+
         // Token usage if available
         const usage = data?.usage;
         if (usage && (usage.input_tokens || usage.total_tokens)) {
@@ -343,3 +359,21 @@ export class EventFormatter {
         }
     }
 }
+
+function wrapShellSummary(command, width = 100) {
+    const max = Math.max(32, Number(width) || 100);
+    const text = String(command || '');
+    const lines = [];
+    let line = '';
+    for (const token of text.match(/\S+\s*/g) || [text]) {
+        const next = line + token;
+        if (line && next.trimEnd().length > max) {
+            lines.push(line.trimEnd());
+            line = token;
+            continue;
+        }
+        line = next;
+    }
+    if (line.trimEnd()) lines.push(line.trimEnd());
+    return lines.length ? lines : ['(empty command)'];
+}