decorated-pi 0.7.2 → 0.7.3

package/README.md

@@ -18,7 +18,7 @@ Multiple layers of token savings that compound across every session.
 
 **RTK** — integrates [RTK](https://github.com/rtk-ai/rtk) to compress bash output into structured summaries, so the LLM never sees raw noise. **Just install the CLI, zero config**.
 
-**Codegraph** — integrates [codegraph](https://github.com/colbymchenry/codegraph) to offer a code map of your project, so the LLM can navigate symbols and call graphs without chaining `ls` → `grep` → `read`. **You should manage the code source index yourself, see[codegraph doc](https://github.com/colbymchenry/codegraph/blob/main/README.md)**.
+**Codegraph** — integrates [codegraph](https://github.com/colbymchenry/codegraph) to offer a code map of your project, so the LLM can navigate symbols and call graphs without chaining `ls` → `grep` → `read`. **You should manage the code source index yourself, see [codegraph doc](https://github.com/colbymchenry/codegraph/blob/main/README.md)**.
 
 **Auxiliary Models** — offloads heavy-but-dumb tasks to cheaper models so your primary model only pays for the hard work:
 
@@ -38,6 +38,10 @@ Multiple layers of token savings that compound across every session.
 - move the default Pi documentation block out of the system prompt and into a builtin `pi-docs` skill, so the docs reference loads on demand instead of sitting in every turn's prompt
 - unregister the native `write` tool, since `bash` can handle it
 
+**Large Result Externalization**
+
+- a `tool_result` hook that catches ANY tool output (bash, read, MCP, etc.) exceeding 30 KB and saves the full content to `/tmp/decorated-pi-results/<tool>-<callId>.txt`. Pi's native truncation still keeps a chunk of the original content in the prompt; this replaces it entirely with a one‑line pointer (`[Output too long, saved to /tmp/…]`) so the LLM knows where the result is and reads it on demand — strictly fewer tokens per turn
+
 ### 2. Smarter Tools
 
 Drop‑in replacements for Pi's built‑in tools, with better UX and fewer wasted turns.
@@ -150,7 +154,7 @@ Example redaction on a `read` / `bash` output:
 
 ## Configuration
 
-Runtime settings in `~/.pi/agent/decorated-pi.json`. Modules can be toggled via `/dp-settings` (changes take effect after `/reload`).
+Runtime settings in `~/.pi/agent/decorated-pi.json`. run `/dp-settings` to configure it.
 
 ```json
 {
@@ -171,10 +175,22 @@ Runtime settings in `~/.pi/agent/decorated-pi.json`. Modules can be toggled via
       "retry": true,
       "usage": true
     }
+  },
+  "dependencies": {
+    "rtk": {
+      "path": "/custom/bin/rtk",
+      "dontBother": false
+    },
+    "wakatime-cli": {
+      "dontBother": true
+    }
   }
 }
 ```
 
+- `modules` can be toggled on/off to enable/disable features. All are enabled by default.
+- `dependencies[binaryName].path` overrides the lookup location for a binary (file or directory). `dependencies[binaryName].dontBother` silences missing-dependency notifications for that binary. Both are optional
+
 ## License
 
 MIT

package/commands/dp-settings.ts

@@ -1,5 +1,5 @@
 /**
- * /dp-settings — toggle module on/off.
+ * /dp-settings — settings for decorated-pi.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -8,12 +8,12 @@ import { ModuleSettingsComponent } from "../ui/module-settings.js";
 
 export function registerDpSettingsCommand(pi: ExtensionAPI): void {
   pi.registerCommand("dp-settings", {
-    description: "Toggle decorated-pi modules on/off",
+    description: "Settings for decorated-pi",
     handler: async (_args, ctx) => {
       if (ctx.hasUI) {
         await ctx.ui.custom<void>(
           (tui, theme, _kb, done) =>
-            new ModuleSettingsComponent(tui, theme, () => done(undefined))
+            new ModuleSettingsComponent(tui, theme, ctx.ui, () => done(undefined))
         );
         // Only prompt for reload when the effective settings differ from
         // the snapshot taken when pi loaded the extension.

package/hooks/compaction.ts

@@ -1,13 +1,18 @@
 /**
  * compaction — custom compaction model + auto-resume.
  *
- * Uses the configured compact model (from settings.ts) to summarize messages
- * on session_before_compact. After auto-compaction, sends a "continue" message
- * to resume the agent loop.
+ * On `session_before_compact`, runs pi-coding-agent's `compact()` against
+ * the model configured in settings (rather than the agent's current model)
+ * and returns the result so pi uses our summary instead of running its
+ * default. If the configured model is missing, auth fails, or the call
+ * throws, we fall through (return undefined) and pi runs its own compaction.
+ *
+ * On `session_compact`, if the compaction was auto-triggered, sends a
+ * "continue" message to resume the agent loop.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { generateSummary, convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+import { compact } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
 import { isContextOverflow } from "@earendil-works/pi-ai";
 import * as fs from "node:fs";
@@ -19,7 +24,6 @@ import type { Module, Skeleton } from "./skeleton.js";
 
 interface PiCompactionSettings {
   enabled: boolean;
-  reserveTokens: number;
 }
 
 interface AutoCompactionCandidate {
@@ -29,7 +33,6 @@ interface AutoCompactionCandidate {
 
 const DEFAULT_PI_COMPACTION_SETTINGS: PiCompactionSettings = {
   enabled: true,
-  reserveTokens: 16_384,
 };
 
 function readJsonObject(filePath: string): any | undefined {
@@ -52,7 +55,6 @@ function loadPiCompactionSettings(cwd: string): PiCompactionSettings {
   };
   return {
     enabled: merged.enabled !== false,
-    reserveTokens: typeof merged.reserveTokens === "number" ? merged.reserveTokens : DEFAULT_PI_COMPACTION_SETTINGS.reserveTokens,
   };
 }
 
@@ -63,30 +65,24 @@ function getLastAssistantMessage(messages: any[]): any | undefined {
   return undefined;
 }
 
-function shouldExpectAutoCompaction(
-  messages: any[],
-  usage: { tokens: number | null; contextWindow: number } | undefined,
-  settings: PiCompactionSettings,
-): boolean {
-  if (!settings.enabled) return false;
-  const lastAssistant = getLastAssistantMessage(messages);
-  if (!lastAssistant) return false;
-  const contextWindow = usage?.contextWindow ?? 0;
-  if (contextWindow > 0 && isContextOverflow(lastAssistant, contextWindow)) return true;
-  if (!usage || usage.tokens === null) return false;
-  return usage.tokens > usage.contextWindow - settings.reserveTokens;
-}
-
+/** Mirror pi's _runAutoCompaction(reason, willRetry) decision:
+ *   - overflow → willRetry=true → auto-resume the agent
+ *   - threshold → willRetry=false → no auto-resume (user continues manually)
+ *   - manual /compact → no resume
+ * Detected from the post-agent-end candidate: overflow shows up as a
+ * context-overflow error on the last assistant message; threshold is a
+ * pre-emptive compaction and we intentionally skip auto-resume for it. */
 function shouldAutoResumeCompaction(
-  prePromptCompactionPending: boolean,
-  postAgentEndCandidate: AutoCompactionCandidate | null,
+  candidate: AutoCompactionCandidate | null,
   settings: PiCompactionSettings,
   customInstructions?: string,
 ): boolean {
   if (customInstructions !== undefined) return false;
-  if (prePromptCompactionPending) return true;
-  if (!postAgentEndCandidate) return false;
-  return shouldExpectAutoCompaction(postAgentEndCandidate.messages, postAgentEndCandidate.usage, settings);
+  if (!candidate || !settings.enabled) return false;
+  const lastAssistant = getLastAssistantMessage(candidate.messages);
+  if (!lastAssistant) return false;
+  const contextWindow = candidate.usage?.contextWindow ?? 0;
+  return contextWindow > 0 && isContextOverflow(lastAssistant, contextWindow);
 }
 
 function getConfiguredCompactModel(registry: any): Model<any> | null {
@@ -97,92 +93,127 @@ function getConfiguredCompactModel(registry: any): Model<any> | null {
   return registry.find(parsed.provider, parsed.modelId) ?? null;
 }
 
-const TURN_PREFIX_PROMPT = `Summarize this turn prefix to provide context for the retained suffix. Be concise. Focus on what's needed to understand the kept suffix.`;
-
-async function generateTurnPrefixSummary(
-  messages: any[], model: Model<any>, reserveTokens: number,
-  apiKey: string, headers: Record<string, string> | undefined, signal: AbortSignal,
-): Promise<string> {
-  const { complete } = await import("@earendil-works/pi-ai");
-  const ct = serializeConversation(convertToLlm(messages));
-  const resp = await complete(model, {
-    systemPrompt: "You are a context summarization assistant. Produce a structured summary only.",
-    messages: [{ role: "user" as const, content: [{ type: "text" as const, text: `<conversation>\n${ct}\n</conversation>\n\n${TURN_PREFIX_PROMPT}` }], timestamp: Date.now() }],
-  }, { maxTokens: Math.floor(0.5 * reserveTokens), signal, apiKey, headers });
-  if (resp.stopReason === "error") throw new Error(resp.errorMessage ?? "Turn prefix summarization failed");
-  return resp.content.filter((c): c is { type: "text"; text: string } => c.type === "text").map(c => c.text).join("\n");
+/** Per-session state. Indexed by sessionId (from ctx.sessionManager) so
+ *  two concurrent pi sessions don't trample each other's flags. */
+interface SessionState {
+  postAgentEndCandidate: AutoCompactionCandidate | null;
+  currentCompactionIsAuto: boolean;
 }
 
-let prePromptCompactionPending = false;
-let postAgentEndCandidate: AutoCompactionCandidate | null = null;
-let currentCompactionIsAuto = false;
+const sessionStates = new Map<string, SessionState>();
+
+function getSessionState(sessionId: string): SessionState {
+  let s = sessionStates.get(sessionId);
+  if (!s) {
+    s = { postAgentEndCandidate: null, currentCompactionIsAuto: false };
+    sessionStates.set(sessionId, s);
+  }
+  return s;
+}
 
 export const compactionModule: Module = {
   name: "compaction",
   hooks: {
-    input: [() => { prePromptCompactionPending = true; postAgentEndCandidate = null; }],
-    before_agent_start: [() => { prePromptCompactionPending = false; postAgentEndCandidate = null; }],
-    agent_start: [() => { prePromptCompactionPending = false; postAgentEndCandidate = null; }],
+    session_shutdown: [
+      (_event, ctx) => {
+        // Clean up state when the session ends so the Map doesn't grow.
+        sessionStates.delete(ctx.sessionManager.getSessionId());
+      },
+    ],
+    input: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
+    before_agent_start: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
+    agent_start: [
+      (_event, ctx) => {
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = null;
+      },
+    ],
     agent_end: [
       (event, ctx) => {
-        prePromptCompactionPending = false;
-        postAgentEndCandidate = { messages: event.messages, usage: ctx.getContextUsage() };
+        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = {
+          messages: event.messages,
+          usage: ctx.getContextUsage(),
+        };
       },
     ],
     session_before_compact: [
-      async (event, ctx) => {
+      async (event, ctx, pi) => {
+        const sessionState = getSessionState(ctx.sessionManager.getSessionId());
         const compactionSettings = loadPiCompactionSettings(ctx.cwd);
-        const { isContextOverflow } = await import("@earendil-works/pi-ai");
-        const isAuto = shouldExpectAutoCompaction(
-          postAgentEndCandidate?.messages ?? [],
-          postAgentEndCandidate?.usage,
+        // Pi only auto-compacts after agent_end (see _checkCompaction in
+        // agent-session.js), so we detect "auto" via the post-agent-end
+        // overflow heuristic. Manual /compact carries customInstructions
+        // and skips auto-resume.
+        const isAutoResume = shouldAutoResumeCompaction(
+          sessionState.postAgentEndCandidate,
           compactionSettings,
+          event.customInstructions,
         );
-        // For simplicity, treat session_before_compact as auto if recent agent_end was likely-overflow
-        // and no custom instructions given.
-        const isAutoResume = isAuto && !event.customInstructions;
-        currentCompactionIsAuto = isAutoResume;
-        prePromptCompactionPending = false;
-        postAgentEndCandidate = null;
+        sessionState.postAgentEndCandidate = null;
 
         const model = getConfiguredCompactModel(ctx.modelRegistry);
-        if (!model) return;
+        if (!model) return; // No custom compact model configured → let pi run its default compaction.
         const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
         if (!auth.ok) {
           if (ctx.hasUI) ctx.ui.notify(`Compact model auth failed: ${auth.error}`, "warning");
-          return;
+          return; // Auth failed → fall through to default compaction; pi handles its own resume.
         }
         const { preparation, customInstructions, signal } = event;
-        const { messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, firstKeptEntryId, previousSummary, settings } = preparation;
-        if (ctx.hasUI) ctx.ui.notify(`🗜️ Compacting with ${model.id} (${tokensBefore.toLocaleString()} tokens)...`, "info");
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `🗜️ Compacting with ${model.id} (${preparation.tokensBefore.toLocaleString()} tokens)...`,
+            "info",
+          );
+        }
+        // Mirror pi's native behavior: compact() uses the agent session's
+        // current thinking level (agent-session.js passes this.thinkingLevel
+        // to compact() in both manual and auto compaction paths).
+        const thinkingLevel = pi.getThinkingLevel();
         try {
-          let summary: string;
-          if (isSplitTurn && turnPrefixMessages.length > 0) {
-            const [hs, ps] = await Promise.all([
-              messagesToSummarize.length > 0
-                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal, customInstructions, previousSummary)
-                : Promise.resolve("No prior history."),
-              generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal),
-            ]);
-            summary = `${hs}\n\n---\n\n**Turn Context (split turn):**\n\n${ps}`;
-          } else {
-            summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, auth.apiKey ?? "", auth.headers, signal, customInstructions, previousSummary);
-          }
-          // session_before_compact is a parallel event — handlers may not
-          // return a value (skeleton discards compose returns for
-          // non-compose events). The summary is intentionally lost; the
-          // session_compact handler below only reads the
-          // currentCompactionIsAuto flag and does not consume the summary.
+          // Delegate to pi-coding-agent's compact() — it does both
+          // summarization (using our model) and file-op extraction, and
+          // returns the exact CompactionResult shape pi's runner expects.
+          const result = await compact(
+            preparation,
+            model,
+            auth.apiKey ?? "",
+            auth.headers,
+            customInstructions,
+            signal,
+            thinkingLevel,
+          );
+          // Only mark as auto-resumed if OUR hook did the compaction. If we
+          // had fallen through to pi's default path above, pi's own
+          // _runAutoCompaction would call agent.continue() on overflow;
+          // marking here would cause a duplicate resume message on top.
+          sessionState.currentCompactionIsAuto = isAutoResume;
+          return { compaction: result };
         } catch (err) {
           if (signal.aborted) return;
-          if (ctx.hasUI) ctx.ui.notify(`Compact failed: ${err instanceof Error ? err.message : err}`, "error");
+          // Returning undefined lets pi run its default compaction with the
+          // active agent model. Surface the failure so the user knows their
+          // custom model didn't take effect.
+          if (ctx.hasUI) {
+            ctx.ui.notify(
+              `Custom compact failed (${err instanceof Error ? err.message : err}); using default model.`,
+              "warning",
+            );
+          }
         }
       },
     ],
     session_compact: [
-      (_event, _ctx, pi) => {
-        const shouldResume = currentCompactionIsAuto;
-        currentCompactionIsAuto = false;
+      (_event, ctx, pi) => {
+        const sessionState = getSessionState(ctx.sessionManager.getSessionId());
+        const shouldResume = sessionState.currentCompactionIsAuto;
+        sessionState.currentCompactionIsAuto = false;
         if (!shouldResume) return;
         pi.sendMessage({
           customType: "auto_compact_resume",
@@ -199,6 +230,5 @@ export function setupCompaction(sk: Skeleton): void {
 }
 
 export const __modelIntegrationTest = {
-  shouldExpectAutoCompaction,
   shouldAutoResumeCompaction,
 };

package/hooks/externalize.ts

@@ -14,7 +14,10 @@ import * as path from "node:path";
 import { randomBytes } from "node:crypto";
 import type { Module } from "./skeleton.js";
 
-export const TOOL_OUTPUT_TEMP_DIR = path.join(os.tmpdir(), "decorated-pi-results");
+export const TOOL_OUTPUT_TEMP_DIR = path.join(
+    os.tmpdir(),
+    "decorated-pi-results",
+);
 export const OUTPUT_EXTERNALIZE_THRESHOLD = 30_000;
 
 /** Write content to a temp file under TOOL_OUTPUT_TEMP_DIR.
@@ -22,49 +25,59 @@ export const OUTPUT_EXTERNALIZE_THRESHOLD = 30_000;
  *  Exported so other modules (e.g. tools/mcp/externalize.ts) can
  *  write to the same location. */
 export function writeOutputToTemp(
-  toolName: string,
-  toolCallId: string,
-  content: string,
+    toolName: string,
+    toolCallId: string,
+    content: string,
 ): string | undefined {
-  try {
-    if (!fs.existsSync(TOOL_OUTPUT_TEMP_DIR)) fs.mkdirSync(TOOL_OUTPUT_TEMP_DIR, { recursive: true });
-    const id = toolCallId ? toolCallId.slice(0, 12) : randomBytes(8).toString("hex");
-    const filePath = path.join(TOOL_OUTPUT_TEMP_DIR, `${toolName}-${id}.txt`);
-    fs.writeFileSync(filePath, content, "utf-8");
-    return filePath;
-  } catch {
-    return undefined;
-  }
+    try {
+        if (!fs.existsSync(TOOL_OUTPUT_TEMP_DIR))
+            fs.mkdirSync(TOOL_OUTPUT_TEMP_DIR, { recursive: true });
+        const id = toolCallId
+            ? toolCallId.slice(0, 12)
+            : randomBytes(8).toString("hex");
+        const filePath = path.join(
+            TOOL_OUTPUT_TEMP_DIR,
+            `${toolName}-${id}.txt`,
+        );
+        fs.writeFileSync(filePath, content, "utf-8");
+        return filePath;
+    } catch {
+        return undefined;
+    }
 }
 
 /** Externalize a tool_result event if content is above the threshold.
  *  Returns the modified event, or undefined to leave the original untouched. */
 export function maybeExternalizeToolResult(event: any): any | undefined {
-  if (!Array.isArray(event.content) || event.content.length === 0) return undefined;
-  const first = event.content[0];
-  if (!first || first.type !== "text" || typeof first.text !== "string") return undefined;
-  const text = first.text;
-  if (text.length <= OUTPUT_EXTERNALIZE_THRESHOLD) return undefined;
+    if (!Array.isArray(event.content) || event.content.length === 0)
+        return undefined;
+    const first = event.content[0];
+    if (!first || first.type !== "text" || typeof first.text !== "string")
+        return undefined;
+    const text = first.text;
+    if (text.length <= OUTPUT_EXTERNALIZE_THRESHOLD) return undefined;
 
-  const filePath = writeOutputToTemp(event.toolName, event.toolCallId, text);
-  if (!filePath) return undefined;
+    const filePath = writeOutputToTemp(event.toolName, event.toolCallId, text);
+    if (!filePath) return undefined;
 
-  return {
-    ...event,
-    content: [{
-      type: "text" as const,
-      text: `[Output truncated: ${text.length.toLocaleString()} chars. Full output: ${filePath}]`,
-    }],
-  };
+    return {
+        ...event,
+        content: [
+            {
+                type: "text" as const,
+                text: `[Output too long, saved to ${filePath}.]`,
+            },
+        ],
+    };
 }
 
 export const externalizeModule: Module = {
-  name: "externalize",
-  hooks: {
-    tool_result: [
-      (event) => {
-        return maybeExternalizeToolResult(event);
-      },
-    ],
-  },
+    name: "externalize",
+    hooks: {
+        tool_result: [
+            (event) => {
+                return maybeExternalizeToolResult(event);
+            },
+        ],
+    },
 };

package/hooks/rtk.ts

@@ -1,32 +1,26 @@
 /**
  * rtk — rewrite bash commands through system-installed RTK.
  *
- * Uses `rtk rewrite` as a preflight. If RTK is not installed, this module is inactive.
- * When a rewritten RTK command fails, the original command is executed once as fallback.
+ * Uses `rtk rewrite` as a preflight against pi's built-in bash tool. If RTK is
+ * not installed, this module is inactive. When a rewritten RTK command fails,
+ * the original command is executed once as fallback.
+ *
+ * We do NOT register our own bash tool. We hook the existing one via
+ * `tool_call` (rewrite the command before it runs) and `tool_result` (fall
+ * back to the original on error). Overriding bash via `pi.registerTool` would
+ * conflict with other extensions (e.g. pi-sandbox) that also override bash.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createBashToolDefinition, createLocalBashOperations } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { execFileSync, spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
+import { createLocalBashOperations } from "@earendil-works/pi-coding-agent";
+import { spawnSync } from "node:child_process";
 import * as path from "node:path";
 import type { Module, Skeleton } from "./skeleton.js";
+import { resolveDependency } from "../settings.js";
 
 // ─── Locating RTK ─────────────────────────────────────────────────────────
 
 export function findSystemRtk(): string | null {
-  try {
-    if (process.platform === "win32") {
-      const output = execFileSync("where", ["rtk"], { encoding: "utf-8" }).trim();
-      return output.split(/\r?\n/)[0] || null;
-    }
-    const shell = process.env.SHELL || "sh";
-    return execFileSync(shell, ["-lc", "command -v rtk"], { encoding: "utf-8" }).trim() || null;
-  } catch {
-    return null;
-  }
+  return resolveDependency("rtk");
 }
 
 export function shellQuote(value: string): string {
@@ -45,49 +39,12 @@ export function rewriteWithRtk(command: string, rtkPath: string): string | null
   return buildRtkCommand(raw, rtkPath);
 }
 
-// ─── Bash tool registration ──────────────────────────────────────────────
-
-interface PiShellSettings {
-  shellPath?: string;
-  shellCommandPrefix?: string;
-}
-
-function readJsonObject(filePath: string): Record<string, unknown> {
-  try {
-    if (!fs.existsSync(filePath)) return {};
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
-function loadPiShellSettings(cwd: string): PiShellSettings {
-  const agentDir = process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
-  const globalSettings = readJsonObject(path.join(agentDir, "settings.json"));
-  const projectSettings = readJsonObject(path.join(cwd, ".pi", "settings.json"));
-  const merged = { ...globalSettings, ...projectSettings } as Record<string, unknown>;
-  const result: PiShellSettings = {};
-  if (typeof merged.shellPath === "string" && merged.shellPath.trim()) result.shellPath = merged.shellPath;
-  if (typeof merged.shellCommandPrefix === "string" && merged.shellCommandPrefix.trim()) {
-    result.shellCommandPrefix = merged.shellCommandPrefix;
-  }
-  return result;
-}
+// ─── Fallback execution ──────────────────────────────────────────────────
 
 export function appendStatus(text: string, status: string): string {
   return text ? `${text}\n\n${status}` : status;
 }
 
-export function formatBashCallWithTag(args: { command?: unknown; timeout?: unknown }, theme: any, showTag: boolean): string {
-  const command = typeof args?.command === "string" ? args.command : null;
-  const timeout = typeof args?.timeout === "number" ? args.timeout : undefined;
-  const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
-  const commandDisplay = command === null ? theme.fg("error", "<invalid command>") : command || theme.fg("toolOutput", "...");
-  const tag = showTag ? theme.fg("borderAccent", " [RTK]") : "";
-  return theme.fg("toolTitle", theme.bold(`$ ${commandDisplay}`)) + timeoutSuffix + tag;
-}
-
 export async function executeOriginalBash(command: string, cwd: string, timeout: number | undefined, signal?: AbortSignal) {
   const ops = createLocalBashOperations();
   const chunks: Buffer[] = [];
@@ -158,49 +115,19 @@ export const rtkModule: Module = {
   },
 };
 
-export function setupRtk(sk: Skeleton, pi: ExtensionAPI): void {
+export function setupRtk(sk: Skeleton): void {
   rtkBinary = findSystemRtk();
-  const ready = sk.declareDependency({
-    label: "rtk",
-    module: "rtk",
-    check: () => findSystemRtk() !== null,
-    hint: "Install RTK so bash rewrite/tagging can activate.",
-  });
-  if (!ready) return;
-
-  // Register a wrapped bash tool that shows [RTK] tag in TUI.
-  const shellSettings = loadPiShellSettings(process.cwd());
-  const bashTool = createBashToolDefinition(process.cwd(), {
-    shellPath: shellSettings.shellPath,
-    commandPrefix: shellSettings.shellCommandPrefix,
-  });
-  const baseRenderCall = bashTool.renderCall?.bind(bashTool);
-
-  if (baseRenderCall) {
-    bashTool.renderCall = (args: any, theme: any, context: any) => {
-      const command = typeof args?.command === "string" ? args.command : "";
-      if (!command) {
-        const text = context.lastComponent ?? new Text("", 0, 0);
-        const placeholder = theme.fg("toolOutput", "...");
-        text.setText(theme.fg("toolTitle", theme.bold(`$ ${placeholder}`)));
-        return text;
-      }
-      const component = baseRenderCall(args, theme, context);
-      const predicted = command
-        ? (rewriteabilityCache.get(command) ?? (() => {
-            const value = rewriteWithRtk(command, rtkBinary!) !== null;
-            rewriteabilityCache.set(command, value);
-            return value;
-          })())
-        : false;
-      const rewritten = rewrittenCommands.has(context.toolCallId) || predicted;
-      if (component instanceof Text) {
-        component.setText(formatBashCallWithTag(args, theme, rewritten));
-      }
-      return component;
-    };
+  if (!rtkBinary) {
+    sk.declareMissing({
+      name: "rtk",
+      module: "rtk",
+      hint: "Install RTK so bash rewrite can activate.",
+    });
+    return;
   }
 
-  pi.registerTool(bashTool);
+  // Hook pi's built-in bash tool via tool_call/tool_result. We deliberately do
+  // not call pi.registerTool — that would shadow pi's bash and conflict with
+  // any other extension that also overrides bash (e.g. pi-sandbox).
   sk.register(rtkModule);
 }