agent-sh 0.1.0 → 0.3.0

package/dist/acp-client.d.ts

@@ -16,8 +16,11 @@ export declare class AcpClient {
     private terminalCounter;
     private fileWatcher;
     private pendingToolCalls;
+    private autoCancelled;
     private pendingToolCounter;
     private agentInfo;
+    private modes;
+    private currentModeId;
     constructor(opts: {
         bus: EventBus;
         contextManager: ContextManager;
@@ -28,6 +31,12 @@ export declare class AcpClient {
      * Send a user query to the agent.
      */
     sendPrompt(query: string): Promise<void>;
+    /**
+     * Silently cancel the prompt after a shell tool completes.
+     * Unlike user-initiated cancel(), this doesn't show "(cancelled)" —
+     * the tool already ran, we just skip the unnecessary LLM follow-up.
+     */
+    private autoCancel;
     /**
      * Cancel the current prompt and force-recover shell mode.
      */
@@ -48,10 +57,25 @@ export declare class AcpClient {
         version: string;
     } | null;
     getModel(): string | undefined;
+    /**
+     * Get the current mode (e.g. thinking level).
+     */
+    getCurrentMode(): {
+        id: string;
+        name: string;
+    } | null;
     /**
      * Check if agent is connected.
      */
     isConnected(): boolean;
+    /**
+     * Parse modes from a session response and notify listeners.
+     */
+    private updateModes;
+    /**
+     * Cycle to the next session mode.
+     */
+    private cycleMode;
     private log;
     /**
      * Create the Client handler that responds to agent requests.

package/dist/acp-client.js

@@ -21,9 +21,12 @@ export class AcpClient {
     terminalDonePromises = new Map();
     terminalCounter = 0;
     fileWatcher;
-    pendingToolCalls = new Map();
+    pendingToolCalls = new Map(); // toolCallId → title
+    autoCancelled = false;
     pendingToolCounter = 0;
     agentInfo = null;
+    modes = [];
+    currentModeId = null;
     constructor(opts) {
         this.bus = opts.bus;
         this.contextManager = opts.contextManager;
@@ -32,10 +35,20 @@ export class AcpClient {
     }
     async start() {
         this.log(`Starting agent: ${this.config.agentCommand} ${this.config.agentArgs.join(" ")}`);
-        // Spawn the agent subprocess
-        // Spawn the agent — wait briefly to catch ENOENT and other spawn errors
+        // Spawn the agent subprocess with the user's full shell environment
+        // (includes vars from .zshrc/.bashrc that process.env may not have).
+        // Merge in any runtime env vars set by extensions (e.g. AGENT_SH_SOCKET)
+        // that weren't present when shellEnv was captured at startup.
+        const baseEnv = this.config.shellEnv ?? process.env;
+        const agentEnv = { ...baseEnv };
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined && !(k in agentEnv)) {
+                agentEnv[k] = v;
+            }
+        }
         this.agentProcess = spawn(this.config.agentCommand, this.config.agentArgs, {
             stdio: ["pipe", "pipe", process.env.DEBUG ? "inherit" : "ignore"],
+            env: agentEnv,
         });
         // Catch spawn errors (ENOENT, EACCES, etc.) before proceeding
         await new Promise((resolve, reject) => {
@@ -65,19 +78,23 @@ export class AcpClient {
         this.log("Creating ACP connection");
         // Create the client-side connection, providing our Client handler
         this.connection = new acp.ClientSideConnection((_agent) => this.createClientHandler(), stream);
-        // Initialize the connection
+        // Initialize the connection with timeout
         this.log("Sending initialize request");
-        const initResponse = await this.connection.initialize({
-            protocolVersion: acp.PROTOCOL_VERSION,
-            clientInfo: { name: "agent-sh", version: "0.1.0" },
-            clientCapabilities: {
-                terminal: true,
-                fs: {
-                    readTextFile: true,
-                    writeTextFile: true,
+        const initTimeoutMs = 30000; // 30 seconds
+        const initResponse = await Promise.race([
+            this.connection.initialize({
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientInfo: { name: "agent-sh", version: "0.1.0" },
+                clientCapabilities: {
+                    terminal: true,
+                    fs: {
+                        readTextFile: true,
+                        writeTextFile: true,
+                    },
                 },
-            },
-        });
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Initialize timeout after ${initTimeoutMs}ms`)), initTimeoutMs)),
+        ]);
         this.log("Initialize successful");
         // Store agent info for display
         if (initResponse.agentInfo) {
@@ -87,15 +104,27 @@ export class AcpClient {
             };
             this.log(`Agent info: ${this.agentInfo.name} v${this.agentInfo.version}`);
         }
-        // Create a session
+        // Create a session — let extensions add MCP servers via pipe
         const cwd = this.contextManager.getCwd();
         this.log(`Creating new session with cwd: ${cwd}`);
-        const sessionResponse = await this.connection.newSession({
+        const sessionConfig = this.bus.emitPipe("session:configure", {
             cwd,
             mcpServers: [],
         });
+        const sessionTimeoutMs = 30000; // 30 seconds
+        const sessionResponse = await Promise.race([
+            this.connection.newSession({
+                cwd: sessionConfig.cwd,
+                mcpServers: sessionConfig.mcpServers,
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`newSession timeout after ${sessionTimeoutMs}ms`)), sessionTimeoutMs)),
+        ]);
         this.sessionId = sessionResponse.sessionId;
         this.log(`Session created: ${this.sessionId}`);
+        // Parse session modes (thinking level, etc.)
+        this.updateModes(sessionResponse);
+        // Listen for mode cycle requests from input handler
+        this.bus.on("config:cycle", () => this.cycleMode());
     }
     /**
      * Send a user query to the agent.
@@ -109,6 +138,7 @@ export class AcpClient {
         this.bus.emit("agent:processing-start", {});
         await this.fileWatcher.snapshot();
         this.currentResponseText = "";
+        this.autoCancelled = false;
         let cancelled = false;
         // Emit agent query event (TUI renders echo+spinner, ContextManager records it)
         this.bus.emit("agent:query", { query });
@@ -116,19 +146,25 @@ export class AcpClient {
         const contextBlock = this.contextManager.getContext();
         try {
             this.log("sending prompt...");
-            const response = await this.connection.prompt({
-                sessionId: this.sessionId,
-                prompt: [
-                    {
-                        type: "text",
-                        text: contextBlock + "\n" + query,
-                    },
-                ],
-            });
+            const promptTimeoutMs = 300000; // 5 minutes timeout for LLM response
+            const response = await Promise.race([
+                this.connection.prompt({
+                    sessionId: this.sessionId,
+                    prompt: [
+                        {
+                            type: "text",
+                            text: contextBlock + "\n" + query,
+                        },
+                    ],
+                }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Prompt timeout after ${promptTimeoutMs}ms`)), promptTimeoutMs)),
+            ]);
             this.log(`prompt resolved: stopReason=${response.stopReason}`);
             if (response.stopReason === "cancelled") {
                 cancelled = true;
-                this.bus.emit("agent:cancelled", {});
+                if (!this.autoCancelled) {
+                    this.bus.emit("agent:cancelled", {});
+                }
             }
         }
         catch (err) {
@@ -154,6 +190,18 @@ export class AcpClient {
             this.promptInProgress = false;
         }
     }
+    /**
+     * Silently cancel the prompt after a shell tool completes.
+     * Unlike user-initiated cancel(), this doesn't show "(cancelled)" —
+     * the tool already ran, we just skip the unnecessary LLM follow-up.
+     */
+    autoCancel() {
+        if (!this.connection || !this.sessionId || !this.promptInProgress)
+            return;
+        this.log("auto-cancel: shell tool completed, skipping LLM follow-up");
+        this.autoCancelled = true;
+        this.connection.cancel({ sessionId: this.sessionId }).catch(() => { });
+    }
     /**
      * Cancel the current prompt and force-recover shell mode.
      */
@@ -185,13 +233,18 @@ export class AcpClient {
     async resetSession() {
         if (!this.connection)
             return;
-        const sessionResponse = await this.connection.newSession({
+        const sessionConfig = this.bus.emitPipe("session:configure", {
             cwd: this.contextManager.getCwd(),
             mcpServers: [],
         });
+        const sessionResponse = await this.connection.newSession({
+            cwd: sessionConfig.cwd,
+            mcpServers: sessionConfig.mcpServers,
+        });
         this.sessionId = sessionResponse.sessionId;
         this.lastResponseText = "";
         this.currentResponseText = "";
+        this.updateModes(sessionResponse);
     }
     /**
      * Get the text of the last agent response (for /copy).
@@ -208,6 +261,14 @@ export class AcpClient {
     getModel() {
         return this.config.model;
     }
+    /**
+     * Get the current mode (e.g. thinking level).
+     */
+    getCurrentMode() {
+        if (!this.currentModeId)
+            return null;
+        return this.modes.find((m) => m.id === this.currentModeId) ?? null;
+    }
     /**
      * Check if agent is connected.
      */
@@ -216,6 +277,45 @@ export class AcpClient {
         // Session ID may not be set yet if we're still initializing
         return this.connection !== null && this.agentInfo !== null;
     }
+    /**
+     * Parse modes from a session response and notify listeners.
+     */
+    updateModes(response) {
+        const modes = response.modes;
+        if (!modes)
+            return;
+        if (modes.availableModes) {
+            this.modes = modes.availableModes.map((m) => ({
+                id: m.id,
+                name: m.name || m.id,
+            }));
+        }
+        if (modes.currentModeId) {
+            this.currentModeId = modes.currentModeId;
+        }
+        this.bus.emit("config:changed", {});
+    }
+    /**
+     * Cycle to the next session mode.
+     */
+    async cycleMode() {
+        if (!this.connection || !this.sessionId || this.modes.length === 0)
+            return;
+        const currentIdx = this.modes.findIndex((m) => m.id === this.currentModeId);
+        const nextIdx = (currentIdx + 1) % this.modes.length;
+        const nextMode = this.modes[nextIdx];
+        try {
+            await this.connection.setSessionMode({
+                sessionId: this.sessionId,
+                modeId: nextMode.id,
+            });
+            this.currentModeId = nextMode.id;
+            this.bus.emit("config:changed", {});
+        }
+        catch (err) {
+            this.log(`Failed to set mode: ${err}`);
+        }
+    }
     log(msg) {
         if (process.env.DEBUG) {
             process.stderr.write(`[agent-sh] ${msg}\n`);
@@ -282,29 +382,61 @@ export class AcpClient {
                 break;
             }
             case "tool_call": {
-                // Use toolCallId if available, otherwise generate a simple ID
                 const toolId = update.toolCallId || `tool-${this.pendingToolCounter++}`;
-                this.pendingToolCalls.set(toolId, true);
-                this.bus.emit("agent:tool-started", { title: update.title, toolCallId: toolId });
+                this.pendingToolCalls.set(toolId, update.title ?? "");
+                this.bus.emit("agent:tool-started", {
+                    title: update.title,
+                    toolCallId: toolId,
+                    kind: update.kind ?? undefined,
+                    locations: update.locations?.map((l) => ({ path: l.path, line: l.line })),
+                    rawInput: update.rawInput,
+                });
                 break;
             }
             case "tool_call_update": {
-                // Only show result when the tool completes, don't show tool call again
+                const toolId = update.toolCallId;
+                const toolTitle = toolId ? this.pendingToolCalls.get(toolId) : undefined;
                 if (update.status === "completed" || update.status === "failed") {
-                    const toolId = update.toolCallId;
+                    // Show content only on final status. Skip tools whose output the
+                    // user already sees (user_shell → PTY) or is agent-only (shell_recall).
+                    const skipOutput = toolTitle === "user_shell" || toolTitle === "shell_recall";
+                    if (!skipOutput && update.content && Array.isArray(update.content)) {
+                        for (const block of update.content) {
+                            if (block.type === "content" && block.content?.type === "text" && block.content.text) {
+                                this.bus.emit("agent:tool-output-chunk", { chunk: block.content.text });
+                            }
+                        }
+                    }
                     const exitCode = update.status === "completed" ? 0 : 1;
                     if (toolId && this.pendingToolCalls.has(toolId)) {
                         this.pendingToolCalls.delete(toolId);
-                        this.bus.emit("agent:tool-completed", { toolCallId: toolId, exitCode });
+                        this.bus.emit("agent:tool-completed", {
+                            toolCallId: toolId,
+                            exitCode,
+                            rawOutput: update.rawOutput,
+                        });
                     }
                     else if (!toolId) {
-                        this.bus.emit("agent:tool-completed", { exitCode });
+                        this.bus.emit("agent:tool-completed", { exitCode, rawOutput: update.rawOutput });
+                    }
+                    // Auto-cancel after shell tools complete — the command already
+                    // ran in the user's PTY, no need for a second LLM round trip.
+                    // The result is captured in shell context / shell_recall.
+                    if (toolTitle === "user_shell" && update.status === "completed") {
+                        this.autoCancel();
                     }
                 }
                 break;
             }
+            case "current_mode_update": {
+                const modeId = update.currentModeId;
+                if (modeId) {
+                    this.currentModeId = modeId;
+                    this.bus.emit("config:changed", {});
+                }
+                break;
+            }
             default:
-                // Ignore other update types for now
                 break;
         }
     }
@@ -363,6 +495,7 @@ export class AcpClient {
         const { session, done } = executeCommand({
             command: fullCommand,
             cwd,
+            env: this.config.shellEnv,
             timeout: 60_000,
             maxOutputBytes: 256 * 1024,
             onOutput: (chunk) => {

package/dist/context-manager.d.ts

@@ -5,6 +5,8 @@ export declare class ContextManager {
     private currentCwd;
     private sessionStart;
     private pendingToolCalls;
+    private firstPrompt;
+    private agentShellActive;
     constructor(bus: EventBus);
     getCwd(): string;
     /**
@@ -17,15 +19,16 @@ export declare class ContextManager {
      */
     search(query: string): string;
     /**
-     * Return full untruncated content for specific exchange IDs.
+     * Return content for specific exchange IDs.
+     * Optional start/end restrict to a line range (1-indexed).
      */
-    expand(ids: number[]): string;
+    expand(ids: number[], start?: number, end?: number): string;
     /**
      * One-line summaries of last N exchanges.
      */
     getRecentSummary(n?: number): string;
     /**
-     * Parse and handle __shell_recall commands.
+     * Parse and handle shell_recall commands.
      */
     handleRecallCommand(command: string): string;
     /**
@@ -37,7 +40,6 @@ export declare class ContextManager {
     private formatContext;
     private addExchange;
     private formatExchangeTruncated;
-    private truncateForRecall;
     private formatExchangeFull;
     private exchangeOneLiner;
     private exchangeSearchText;

package/dist/context-manager.js

@@ -1,21 +1,18 @@
-const DEFAULT_WINDOW_SIZE = 20;
-const DEFAULT_BUDGET = 16384; // ~4K tokens at ~4 chars/token
-// Truncation thresholds (in lines)
-const SHELL_TRUNCATE_THRESHOLD = 30;
-const SHELL_HEAD_LINES = 10;
-const SHELL_TAIL_LINES = 10;
+import { getSettings } from "./settings.js";
+// Non-configurable thresholds (agent response and tool output follow shell settings)
 const AGENT_RESPONSE_TRUNCATE_THRESHOLD = 20;
 const AGENT_RESPONSE_HEAD_LINES = 15;
 const TOOL_TRUNCATE_THRESHOLD = 20;
 const TOOL_HEAD_LINES = 5;
 const TOOL_TAIL_LINES = 5;
-const RECALL_EXPAND_MAX_LINES = 500;
 export class ContextManager {
     exchanges = [];
     nextId = 1;
     currentCwd;
     sessionStart;
     pendingToolCalls = [];
+    firstPrompt = true;
+    agentShellActive = false; // true while user_shell command is executing
     constructor(bus) {
         this.currentCwd = process.cwd();
         this.sessionStart = Date.now();
@@ -30,11 +27,15 @@ export class ContextManager {
                 exitCode: e.exitCode,
                 outputLines: lines.length,
                 outputBytes: e.output.length,
+                source: this.agentShellActive ? "agent" : "user",
             });
         });
         bus.on("shell:cwd-change", (e) => {
             this.currentCwd = e.cwd;
         });
+        // Track agent-initiated shell commands (user_shell tool)
+        bus.on("shell:agent-exec-start", () => { this.agentShellActive = true; });
+        bus.on("shell:agent-exec-done", () => { this.agentShellActive = false; });
         // ── Subscribe to agent events ──
         bus.on("agent:query", (e) => {
             this.pendingToolCalls = [];
@@ -85,7 +86,8 @@ export class ContextManager {
      * Build the <shell_context> block for the agent prompt.
      * Pipeline: window → truncate → format
      */
-    getContext(budget = DEFAULT_BUDGET) {
+    getContext(budget) {
+        budget ??= getSettings().contextBudget;
         let exchanges = this.applyWindow(this.exchanges);
         exchanges = this.applyTruncation(exchanges, budget);
         return this.formatContext(exchanges);
@@ -141,9 +143,10 @@ export class ContextManager {
         return parts.join("\n");
     }
     /**
-     * Return full untruncated content for specific exchange IDs.
+     * Return content for specific exchange IDs.
+     * Optional start/end restrict to a line range (1-indexed).
      */
-    expand(ids) {
+    expand(ids, start, end) {
         const results = [];
         for (const id of ids) {
             const ex = this.exchanges.find((e) => e.id === id);
@@ -151,7 +154,25 @@ export class ContextManager {
                 results.push(`#${id}: not found`);
                 continue;
             }
-            results.push(this.formatExchangeFull(ex));
+            const text = this.formatExchangeFull(ex);
+            const lines = text.split("\n");
+            const total = lines.length;
+            if (start != null || end != null) {
+                // Line range requested
+                const s = Math.max(0, (start ?? 1) - 1);
+                const e = end ?? total;
+                results.push(lines.slice(s, e).join("\n") +
+                    `\n[showing lines ${s + 1}-${Math.min(e, total)} of ${total}]`);
+            }
+            else if (total > getSettings().recallExpandMaxLines) {
+                // Too large — tell the agent to narrow down
+                results.push(`#${ex.id}: output is ${total} lines, too large to expand fully. ` +
+                    `Use start/end params to select a line range (e.g. start=1, end=50), ` +
+                    `or use search with a regex to find specific content.`);
+            }
+            else {
+                results.push(text);
+            }
         }
         return results.join("\n\n");
     }
@@ -165,21 +186,21 @@ export class ContextManager {
         return recent.map((ex) => this.exchangeOneLiner(ex)).join("\n");
     }
     /**
-     * Parse and handle __shell_recall commands.
+     * Parse and handle shell_recall commands.
      */
     handleRecallCommand(command) {
-        const args = command.replace(/^__shell_recall\s*/, "").trim();
+        const args = command.replace(/^_*shell_recall\s*/, "").trim();
         if (!args || args === "--help") {
             return [
                 "Usage:",
-                "  __shell_recall                    Browse recent exchanges",
-                "  __shell_recall --search <query>   Search all exchanges",
-                "  __shell_recall --expand <id,...>   Show full content of exchanges",
+                "  shell_recall                    Browse recent exchanges",
+                "  shell_recall --search <query>   Search all exchanges",
+                "  shell_recall --expand <id,...>   Show full content of exchanges",
                 "",
                 "Examples:",
-                '  __shell_recall --search "test fail"',
-                "  __shell_recall --expand 41",
-                "  __shell_recall --expand 41,42,43",
+                '  shell_recall --search "test fail"',
+                "  shell_recall --expand 41",
+                "  shell_recall --expand 41,42,43",
             ].join("\n");
         }
         const searchMatch = args.match(/^--search\s+(?:"([^"]+)"|(\S+))/);
@@ -205,10 +226,12 @@ export class ContextManager {
     clear() {
         this.exchanges = [];
         this.pendingToolCalls = [];
+        this.firstPrompt = true;
         // Don't reset nextId — IDs should be globally unique within a session
     }
     // ── Pipeline stages ───────────────────────────────────────────
-    applyWindow(exchanges, windowSize = DEFAULT_WINDOW_SIZE) {
+    applyWindow(exchanges, windowSize) {
+        windowSize ??= getSettings().contextWindowSize;
         return exchanges.slice(-windowSize);
     }
     applyTruncation(exchanges, budget) {
@@ -217,7 +240,8 @@ export class ContextManager {
         // Pass 1: per-type truncation
         for (const ex of result) {
             if (ex.type === "shell_command") {
-                ex.output = truncateOutput(ex.output, SHELL_TRUNCATE_THRESHOLD, SHELL_HEAD_LINES, SHELL_TAIL_LINES, ex.id);
+                const s = getSettings();
+                ex.output = truncateOutput(ex.output, s.shellTruncateThreshold, s.shellHeadLines, s.shellTailLines, ex.id);
             }
             else if (ex.type === "agent_response") {
                 ex.response = truncateHead(ex.response, AGENT_RESPONSE_TRUNCATE_THRESHOLD, AGENT_RESPONSE_HEAD_LINES, ex.id);
@@ -232,13 +256,13 @@ export class ContextManager {
             const ex = result[i];
             const before = this.exchangeSize(ex);
             if (ex.type === "shell_command") {
-                ex.output = `[output omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             else if (ex.type === "tool_execution") {
-                ex.output = `[output omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.output = `[output omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             else if (ex.type === "agent_response") {
-                ex.response = `[response omitted, use __shell_recall --expand ${ex.id}]`;
+                ex.response = `[response omitted, use shell_recall tool to expand id ${ex.id}]`;
             }
             totalSize -= before - this.exchangeSize(ex);
         }
@@ -248,9 +272,22 @@ export class ContextManager {
         const elapsed = Math.round((Date.now() - this.sessionStart) / 60000);
         const totalCount = this.exchanges.length;
         let out = "<shell_context>\n";
+        if (this.firstPrompt) {
+            out += `You are an AI assistant living inside agent-sh, a shell-first terminal.\n`;
+            out += `The user interacts with a real shell (PTY) and sends you queries inline. You are there to help them with their tasks.\n`;
+            out += `\n`;
+            out += `IMPORTANT tool usage rules:\n`;
+            out += `- user_shell runs commands in the user's live shell (PTY). The user sees output directly — no summary needed.\n`;
+            out += `- Your internal tools (bash, read, write, ls, etc.) run in an isolated subprocess. The user CANNOT see their output.\n`;
+            out += `- When the user asks to see, list, view, or display anything, ALWAYS use user_shell. NEVER use internal tools like ls/read/bash for display — the user won't see it.\n`;
+            out += `- Only use internal tools when YOU need to reason about content silently (e.g. reading a file to answer a question about it).\n`;
+            out += `- After a user_shell command, the user already saw the output. Do NOT repeat or summarize it.\n`;
+            out += `- You can browse or search session history with shell_recall.\n`;
+            out += `\n`;
+            this.firstPrompt = false;
+        }
         out += `cwd: ${this.currentCwd}\n`;
         out += `session: ${totalCount} exchanges, ${elapsed}m elapsed\n`;
-        out += `[hint: run \`__shell_recall --search "query"\` or \`__shell_recall --expand ID\` to retrieve truncated content]\n`;
         for (const ex of exchanges) {
             out += "\n" + this.formatExchangeTruncated(ex);
         }
@@ -269,7 +306,8 @@ export class ContextManager {
     formatExchangeTruncated(ex) {
         switch (ex.type) {
             case "shell_command": {
-                let s = `#${ex.id} [shell] $ ${ex.command}\n`;
+                const label = ex.source === "agent" ? "agent → shell" : "shell";
+                let s = `#${ex.id} [${label} cwd:${ex.cwd}] $ ${ex.command}\n`;
                 if (ex.output)
                     s += indent(ex.output, "  ") + "\n";
                 if (ex.exitCode !== null)
@@ -299,20 +337,12 @@ export class ContextManager {
             }
         }
     }
-    truncateForRecall(text) {
-        const lines = text.split("\n");
-        if (lines.length <= RECALL_EXPAND_MAX_LINES)
-            return text;
-        const half = RECALL_EXPAND_MAX_LINES / 2;
-        return (lines.slice(0, half).join("\n") +
-            `\n[... ${lines.length - RECALL_EXPAND_MAX_LINES} more lines ...]\n` +
-            lines.slice(-half).join("\n"));
-    }
     formatExchangeFull(ex) {
         switch (ex.type) {
             case "shell_command": {
-                const output = this.truncateForRecall(ex.output);
-                let s = `#${ex.id} [shell] $ ${ex.command} (${ex.outputLines} lines, ${ex.outputBytes} bytes)\n`;
+                const label = ex.source === "agent" ? "agent → shell" : "shell";
+                const output = ex.output;
+                let s = `#${ex.id} [${label}] $ ${ex.command} (${ex.outputLines} lines, ${ex.outputBytes} bytes)\n`;
                 if (output)
                     s += output + "\n";
                 if (ex.exitCode !== null)
@@ -324,10 +354,9 @@ export class ContextManager {
             case "agent_response":
                 return `#${ex.id} [agent]\n${ex.response}`;
             case "tool_execution": {
-                const output = this.truncateForRecall(ex.output);
                 let s = `#${ex.id} [tool] ${ex.tool} (${ex.outputLines} lines, ${ex.outputBytes} bytes)\n`;
-                if (output)
-                    s += output + "\n";
+                if (ex.output)
+                    s += ex.output + "\n";
                 if (ex.exitCode !== null)
                     s += `exit ${ex.exitCode}\n`;
                 return s;
@@ -336,8 +365,10 @@ export class ContextManager {
     }
     exchangeOneLiner(ex) {
         switch (ex.type) {
-            case "shell_command":
-                return `#${ex.id} shell: ${ex.command} (${ex.outputLines} lines, exit ${ex.exitCode ?? "?"})`;
+            case "shell_command": {
+                const label = ex.source === "agent" ? "agent → shell" : "shell";
+                return `#${ex.id} ${label} [cwd:${ex.cwd}]: ${ex.command} (${ex.outputLines} total lines, exit ${ex.exitCode ?? "?"})`;
+            }
             case "agent_query":
                 return `#${ex.id} query: ${ex.query}`;
             case "agent_response": {
@@ -381,7 +412,7 @@ function truncateOutput(text, threshold, headLines, tailLines, id) {
     const omitted = lines.length - headLines - tailLines;
     return [
         ...lines.slice(0, headLines),
-        `[... ${omitted} lines truncated, use __shell_recall --expand ${id} to see full output ...]`,
+        `[... ${omitted} lines truncated, use shell_recall tool with expand and id ${id} to see full output ...]`,
         ...lines.slice(-tailLines),
     ].join("\n");
 }
@@ -391,7 +422,7 @@ function truncateHead(text, threshold, headLines, id) {
         return text;
     return [
         ...lines.slice(0, headLines),
-        `[... truncated, use __shell_recall --expand ${id} for full response ...]`,
+        `[... truncated, use shell_recall tool with expand and id ${id} for full response ...]`,
     ].join("\n");
 }
 function indent(text, prefix) {