@bahulam/code 2.6.12 → 2.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bahulam/code",
-  "version": "2.6.12",
+  "version": "2.6.14",
   "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.12",
-    "@bahulam/runtime-linux-x64": "2.6.12",
-    "@bahulam/runtime-win32-x64": "2.6.12"
+    "@bahulam/runtime-darwin-arm64": "2.6.14",
+    "@bahulam/runtime-linux-x64": "2.6.14",
+    "@bahulam/runtime-win32-x64": "2.6.14"
   }
 }

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

@@ -2,6 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 
 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 +51,10 @@ 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);
+  try { return JSON.stringify(sanitizeForLog(args || {})).slice(0, MAX_ARG_LOG_CHARS); }
+  catch { return redactSensitive(String(args || '')).slice(0, MAX_ARG_LOG_CHARS); }
 }
 
 function safeText(value, max = 500) {
@@ -59,6 +62,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 +84,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 +94,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,10 +20,11 @@ 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 { clearInputPrompt, isInputDockMounted, moveToContent, renderDockOverlay } from '../ui/input-dock.mjs';
 import { validateShellCommand } from './safety.mjs';
 import { classifyCommand } from '../permissions/command-classifier.mjs';
 import { ApprovalLog } from './approval-log.mjs';
@@ -72,12 +73,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';
@@ -111,9 +122,10 @@ export class ApprovalManager {
 
     setReadline(rl) { this._rl = rl; }
 
-    setExecutionHooks({ onPause, onResume } = {}) {
+    setExecutionHooks({ onPause, onResume, onApprovalPromptEnd } = {}) {
         this._execPause = onPause || null;
         this._execResume = onResume || null;
+        this._approvalPromptEnd = onApprovalPromptEnd || null;
     }
 
     revoke() {
@@ -143,7 +155,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 +216,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,7 +270,7 @@ 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;
         };
@@ -266,6 +302,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,11 +319,18 @@ 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': {
@@ -290,7 +338,7 @@ export class ApprovalManager {
                 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 };
             }
 
@@ -299,7 +347,7 @@ export class ApprovalManager {
                 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,7 +356,7 @@ 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 };
             }
@@ -318,14 +366,15 @@ export class ApprovalManager {
                 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);
                 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':
@@ -340,7 +389,7 @@ 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 };
             }
@@ -439,8 +488,8 @@ export class ApprovalManager {
         });
     }
 
-    _optionsFor(tier) {
-        return approvalOptions(tier);
+    _optionsFor(tier, toolName, args) {
+        return approvalOptions(tier, { tool: toolName, args });
     }
 
     getSummary() {
@@ -474,3 +523,102 @@ 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.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/headless.mjs

@@ -272,7 +272,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
                     tool_calls: data?.tool_calls || 0,
                     success: data?.success !== false,
                 });
-                emit({ type: 'sub_agent', ...data });
+                emit({ ...data, type: 'sub_agent', agent_type: data?.type || '' });
                 log(`SubAgent done: ${data?.type} (${data?.tool_calls} tools, ${data?.duration_s}s)`);
             }
 
@@ -360,8 +360,19 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     const subAgentToolBreakdown = countBreakdown(toolCalls.filter(t => t.internal));
 
     const subAgentReportedToolCount = subAgents.reduce((sum, sa) => sum + (sa.tool_calls || 0), 0);
-    const subAgentToolCount = backendSubAgentToolCount ?? Math.max(subAgentReportedToolCount, subAgentForwardedToolCount);
-    const totalToolCount = backendToolCount ?? (primaryToolCount + subAgentToolCount);
+    const observedSubAgentToolCount = Math.max(
+        subAgentReportedToolCount,
+        subAgentForwardedToolCount,
+    );
+    const subAgentToolCount = (
+        backendSubAgentToolCount && backendSubAgentToolCount > 0
+    )
+        ? backendSubAgentToolCount
+        : observedSubAgentToolCount;
+    const computedToolCount = primaryToolCount + subAgentToolCount;
+    const totalToolCount = backendToolCount != null
+        ? Math.max(backendToolCount, computedToolCount)
+        : computedToolCount;
     const primaryToolTotal = backendPrimaryToolCount ?? (
         backendToolCount != null
             ? Math.max(0, totalToolCount - subAgentToolCount)

package/src/core/local-agent.mjs

@@ -21,11 +21,11 @@ const MAX_ITERATIONS = 50;
 const TOOL_SCHEMAS = [
     {
         name: 'shell',
-        description: 'Run a shell command and return stdout/stderr. Use for: installing packages, running tests, builds, git operations, or any terminal command.',
+        description: 'Run one non-interactive shell command and return stdout/stderr. Do not use command substitution, backticks, or $(); run separate simple shell calls instead.',
         input_schema: {
             type: 'object',
             properties: {
-                command: { type: 'string', description: 'The shell command to execute' },
+                command: { type: 'string', description: 'The command to execute. Avoid backticks and $(); split dependent checks into separate commands.' },
                 timeout: { type: 'number', description: 'Timeout in milliseconds (default: 120000)' },
             },
             required: ['command'],
@@ -478,6 +478,7 @@ export class LocalAgent {
             'You are Bahulam Code, Bahulam\'s AI coding agent running in local mode.',
             'You have access to tools for reading, writing, and executing code.',
             'Use tools to accomplish the user\'s request. Be concise and direct.',
+            'For shell tools, never use command substitution, backticks, or $(). Run separate simple commands and carry values forward in text.',
         ];
         if (context.cwd) parts.push(`Working directory: ${context.cwd}`);
         if (context.gitBranch) parts.push(`Git branch: ${context.gitBranch}`);

package/src/core/tool-executor.mjs

@@ -74,6 +74,14 @@ export function createToolExecutor({
         return path.resolve(cwd, value);
     }
 
+    function blockedShellOutput(reason) {
+        const text = String(reason || 'Blocked by shell safety policy').trim();
+        const hint = /command substitution|backticks|\$\(\)/i.test(text)
+            ? 'Retry with separate simple shell commands instead of backticks or $().'
+            : 'Work only inside a registered project root.';
+        return `BLOCKED: ${text}. ${hint}`;
+    }
+
     function longRunningObservationTimeoutMs() {
         const configured = Number(process.env.KEPLER_LONG_RUNNING_TIMEOUT_MS);
         return Number.isFinite(configured) && configured > 0 ? configured : 15_000;
@@ -578,7 +586,7 @@ export function createToolExecutor({
             if (!shellCheck.safe) {
                 return {
                     success: false,
-                    output: `BLOCKED: ${shellCheck.reason}. Work only inside a registered project root.`,
+                    output: blockedShellOutput(shellCheck.reason),
                     _tool: 'shell', _blocked: true,
                 };
             }
@@ -588,7 +596,7 @@ export function createToolExecutor({
             if (classification.classification === 'blocked') {
                 return {
                     success: false,
-                    output: `BLOCKED: ${classification.reason}`,
+                    output: blockedShellOutput(classification.reason),
                     _tool: 'shell', _blocked: true,
                 };
             }
@@ -1513,7 +1521,9 @@ print('OK: replaced')
             const created = listLocalAgents(process.cwd()).find(agent => agent.slug === result.slug);
             const payload = {
                 ...result,
-                agent: created ? compactAgentMetadata(created) : null,
+                agent: created
+                    ? { ...compactAgentMetadata(created), spec: created.spec }
+                    : null,
                 next_actions: [
                     `Edit ${result.filePath}`,
                     `Run /agents sync ${result.slug} when ready`,

package/src/index.mjs

@@ -35,7 +35,7 @@ import { printBanner, printProjectInfo, printHints, printAuthStatus, printStyled
 import { ContextRetriever } from './context/retriever.mjs';
 import { loadSettings } from './config/settings.mjs';
 
-const VERSION = '2.6.12';
+const VERSION = '2.6.14';
 
 // ── Arg Parsing (consolidated from index.mjs + cli-args.mjs) ──