decorated-pi 0.7.3 → 0.8.1

package/README.md

@@ -14,7 +14,9 @@ pi install /path/to/decorated-pi
 
 ### 1. Token Efficiency
 
-Multiple layers of token savings that compound across every session. 
+Multiple layers of token savings that compound across every session.
+
+**Talk Normal Prompt** — injects a compact response-style prompt adapted from [talk-normal](https://github.com/hexiecs/talk-normal), trimming filler, summary stamps, conditional follow-up menus, and verbose framing. This reduces assistant output tokens and keeps visible reasoning / explanation blocks tighter.
 
 **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**.
 
@@ -30,13 +32,11 @@ Multiple layers of token savings that compound across every session.
 **Cache‑friendly Design** — stable system prompt prefix:
 
 - tool definitions, guidelines, and skills are sorted alphabetically so the system prompt is identical across sessions
-- volatile elements like `Current date: …` are stripped before prompt assembly
 - MCP tool schemas are persisted to a local cache, so the tool list stays stable regardless of network conditions or server availability
 
 **Pi Native Prompt Slimming**
 
 - 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**
 

package/commands/usage.ts

@@ -401,7 +401,11 @@ export function formatCost(c: number): string {
 
 export function formatHitRate(hitRate: number, turns: number): string {
   if (turns === 0) return "—";
-  return `${hitRate.toFixed(1)}%`;
+  // Truncate (not round) beyond 1 decimal place: 99.97 → "99.9%", not
+  // "100.0%". A true 100.0 (every input-side token served from cache) is
+  // the only way to reach "100.0%".
+  const truncated = Math.floor(hitRate * 10) / 10;
+  return `${truncated.toFixed(1)}%`;
 }
 
 export type ColumnId = "input" | "output" | "cacheRead" | "cacheWrite" | "hitRate" | "cost";

package/hooks/compaction.ts

@@ -1,5 +1,5 @@
 /**
- * compaction — custom compaction model + auto-resume.
+ * compaction — custom compaction model.
  *
  * On `session_before_compact`, runs pi-coding-agent's `compact()` against
  * the model configured in settings (rather than the agent's current model)
@@ -7,82 +7,25 @@
  * 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.
+ * Auto-retry/resume is handled by pi natively; `reason` and `willRetry`
+ * on compaction events describe manual, threshold, and overflow flows.
  */
 
-import type { ExtensionAPI } 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";
-import * as os from "node:os";
-import { resolve } from "node:path";
 import { getCompactModelKey } from "../settings.js";
 import { parseModelKey } from "../settings.js";
 import type { Module, Skeleton } from "./skeleton.js";
 
-interface PiCompactionSettings {
-  enabled: boolean;
-}
-
-interface AutoCompactionCandidate {
-  messages: any[];
-  usage: { tokens: number | null; contextWindow: number } | undefined;
-}
-
-const DEFAULT_PI_COMPACTION_SETTINGS: PiCompactionSettings = {
-  enabled: true,
-};
-
-function readJsonObject(filePath: string): any | undefined {
-  try {
-    if (!fs.existsSync(filePath)) return undefined;
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return parsed && typeof parsed === "object" ? parsed : undefined;
-  } catch {
-    return undefined;
-  }
-}
+type CompactionReason = "manual" | "threshold" | "overflow";
 
-function loadPiCompactionSettings(cwd: string): PiCompactionSettings {
-  const globalSettings = readJsonObject(resolve(os.homedir(), ".pi", "agent", "settings.json"));
-  const projectSettings = readJsonObject(resolve(cwd, ".pi", "settings.json"));
-  const merged = {
-    ...DEFAULT_PI_COMPACTION_SETTINGS,
-    ...(globalSettings?.compaction ?? {}),
-    ...(projectSettings?.compaction ?? {}),
-  };
-  return {
-    enabled: merged.enabled !== false,
-  };
+interface CompactionEventMetadata {
+  reason: CompactionReason;
+  willRetry: boolean;
 }
 
-function getLastAssistantMessage(messages: any[]): any | undefined {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") return messages[i];
-  }
-  return undefined;
-}
-
-/** 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(
-  candidate: AutoCompactionCandidate | null,
-  settings: PiCompactionSettings,
-  customInstructions?: string,
-): boolean {
-  if (customInstructions !== undefined) return false;
-  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 formatCompactionMode(event: CompactionEventMetadata): string {
+  return event.willRetry ? `${event.reason}, retrying` : event.reason;
 }
 
 function getConfiguredCompactModel(registry: any): Model<any> | null {
@@ -93,71 +36,11 @@ function getConfiguredCompactModel(registry: any): Model<any> | null {
   return registry.find(parsed.provider, parsed.modelId) ?? null;
 }
 
-/** 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;
-}
-
-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: {
-    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) => {
-        getSessionState(ctx.sessionManager.getSessionId()).postAgentEndCandidate = {
-          messages: event.messages,
-          usage: ctx.getContextUsage(),
-        };
-      },
-    ],
     session_before_compact: [
       async (event, ctx, pi) => {
-        const sessionState = getSessionState(ctx.sessionManager.getSessionId());
-        const compactionSettings = loadPiCompactionSettings(ctx.cwd);
-        // 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,
-        );
-        sessionState.postAgentEndCandidate = null;
-
         const model = getConfiguredCompactModel(ctx.modelRegistry);
         if (!model) return; // No custom compact model configured → let pi run its default compaction.
         const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
@@ -168,7 +51,7 @@ export const compactionModule: Module = {
         const { preparation, customInstructions, signal } = event;
         if (ctx.hasUI) {
           ctx.ui.notify(
-            `🗜️ Compacting with ${model.id} (${preparation.tokensBefore.toLocaleString()} tokens)...`,
+            `📦 Compacting with ${model.id} (${formatCompactionMode(event)}, ${preparation.tokensBefore.toLocaleString()} tokens)...`,
             "info",
           );
         }
@@ -189,11 +72,6 @@ export const compactionModule: Module = {
             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;
@@ -209,19 +87,6 @@ export const compactionModule: Module = {
         }
       },
     ],
-    session_compact: [
-      (_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",
-          content: "The context was just auto-compacted. Continue the current task based on the summary above. Do not repeat completed work. If unsure about progress, briefly summarize current state then continue.",
-          display: false,
-        }, { triggerTurn: true });
-      },
-    ],
   },
 };
 
@@ -230,5 +95,5 @@ export function setupCompaction(sk: Skeleton): void {
 }
 
 export const __modelIntegrationTest = {
-  shouldAutoResumeCompaction,
+  formatCompactionMode,
 };

package/hooks/image-vision.ts

@@ -4,7 +4,9 @@
  */
 
 import { fileTypeFromFile } from "file-type";
+import { Buffer } from "node:buffer";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { extname, resolve } from "node:path";
 import OpenAI from "openai";
 import type { Model } from "@earendil-works/pi-ai";
@@ -13,6 +15,12 @@ import type { Module, Skeleton } from "./skeleton.js";
 
 const SUPPORTED_IMAGE_TYPES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
 
+function expandHome(filePath: string): string {
+  if (filePath.startsWith("~/")) return resolve(os.homedir(), filePath.slice(2));
+  if (filePath === "~") return os.homedir();
+  return filePath;
+}
+
 async function detectImageMimeType(filePath: string): Promise<string | null> {
   try {
     const type = await fileTypeFromFile(filePath);
@@ -32,6 +40,9 @@ export async function analyzeImage(
   if (model.api === "anthropic-messages") {
     return analyzeAnthropic(model, imageBase64, mediaType, apiKey, extraHeaders);
   }
+  if (model.api === "openai-codex-responses") {
+    return analyzeCodex(model, imageBase64, mediaType, apiKey, extraHeaders);
+  }
   return analyzeOpenAI(model, imageBase64, mediaType, apiKey, extraHeaders);
 }
 
@@ -51,6 +62,99 @@ async function analyzeOpenAI(
   return resp.choices[0]?.message?.content ?? "No analysis returned.";
 }
 
+function codexResponsesUrl(baseUrl?: string): string {
+  const base = (baseUrl || "https://chatgpt.com/backend-api").replace(/\/+$/, "");
+  return base.endsWith("/codex/responses") ? base
+    : base.endsWith("/codex") ? `${base}/responses`
+    : `${base}/codex/responses`;
+}
+
+function extractCodexAccountId(apiKey: string): string {
+  try {
+    const parts = apiKey.split(".");
+    if (parts.length !== 3) return "";
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    return payload?.["https://api.openai.com/auth"]?.chatgpt_account_id ?? "";
+  } catch {
+    return "";
+  }
+}
+
+function appendCodexSseDelta(outputText: string, line: string): string {
+  if (!line.startsWith("data: ")) return outputText;
+  const data = line.slice(6).trim();
+  if (data === "[DONE]") return outputText;
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.type === "response.output_text.delta") {
+      return outputText + (parsed.delta ?? "");
+    }
+  } catch { /* skip malformed */ }
+  return outputText;
+}
+
+async function analyzeCodex(
+  model: Model<any>, imageBase64: string, mediaType: string,
+  apiKey: string, extraHeaders: Record<string, string>,
+): Promise<string> {
+  // Codex uses /codex/responses, not the standard /responses path.
+  const url = codexResponsesUrl(model.baseUrl);
+
+  // Codex auth: extract accountId from JWT, set special headers.
+  const accountId = extractCodexAccountId(apiKey);
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`,
+    "Originator": "pi",
+    "OpenAI-Beta": "responses=experimental",
+    "accept": "text/event-stream",
+    ...extraHeaders,
+  };
+  if (accountId) headers["chatgpt-account-id"] = accountId;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model: model.id,
+      store: false,
+      stream: true,
+      input: [{
+        role: "user",
+        content: [
+          { type: "input_text", text: DEFAULT_PROMPT },
+          { type: "input_image", image_url: `data:${mediaType};base64,${imageBase64}`, detail: "auto" },
+        ],
+      }],
+      text: { format: { type: "text" } },
+    }),
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`Codex API error ${resp.status}: ${text.slice(0, 300)}`);
+  }
+  // Codex only supports SSE streaming; read the event stream.
+  const reader = resp.body?.getReader();
+  if (!reader) throw new Error("No response body");
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let outputText = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) outputText = appendCodexSseDelta(outputText, line);
+  }
+  buffer += decoder.decode();
+  for (const line of buffer.split(/\r?\n/)) outputText = appendCodexSseDelta(outputText, line);
+  return outputText || "No analysis returned.";
+}
+
+
 async function analyzeAnthropic(
   model: Model<any>, imageBase64: string, mediaType: string,
   apiKey: string, extraHeaders: Record<string, string>,
@@ -83,10 +187,20 @@ export const imageVisionModule: Module = {
         if (event.toolName !== "read") return;
         const filePath: string | undefined = (event.input as any)?.file ?? (event.input as any)?.path;
         if (!filePath) return;
-        const mimeType = await detectImageMimeType(resolve(ctx.cwd, filePath));
+        const mimeType = await detectImageMimeType(resolve(ctx.cwd, expandHome(filePath)));
         if (!mimeType) return;
-        if (!getImageModelKey()) return;
+        const imageKey = getImageModelKey();
+        if (!imageKey) return;
         pendingImageFallbacks.add(event.toolCallId);
+        if (ctx.hasUI) {
+          const p = parseModelKey(imageKey);
+          if (p) {
+            ctx.ui.notify(
+              `🖼️ Analyzing image with ${p.provider}/${p.modelId}...`,
+              "info",
+            );
+          }
+        }
       },
     ],
     tool_result: [
@@ -101,7 +215,7 @@ export const imageVisionModule: Module = {
         const imageModel = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
         if (!imageModel) return;
         try {
-          const absPath = resolve(ctx.cwd, filePath);
+          const absPath = resolve(ctx.cwd, expandHome(filePath));
           const imageData = fs.readFileSync(absPath);
           const imageBase64 = imageData.toString("base64");
           const mimeType = (await detectImageMimeType(absPath)) ?? "image/png";
@@ -113,13 +227,19 @@ export const imageVisionModule: Module = {
           );
           return {
             ...event,
-            content: [{ type: "text", text: `[Image analysis via ${parsed.provider}/${parsed.modelId}]\n\n${analysis}` }],
+            content: [{ type: "text", text: analysis }],
             details: { imageModel: imageKey, originalPath: filePath },
           };
         } catch (error) {
+          if (ctx.hasUI) {
+            ctx.ui.notify(
+              `Image analysis failed: ${error instanceof Error ? error.message : error}`,
+              "warning",
+            );
+          }
           return {
             ...event,
-            content: [{ type: "text", text: `Image analysis failed: ${error instanceof Error ? error.message : error}` }],
+            content: [{ type: "text", text: `Image analysis failed` }],
           };
         }
       },
@@ -130,3 +250,5 @@ export const imageVisionModule: Module = {
 export function setupImageVision(sk: Skeleton): void {
   sk.register(imageVisionModule);
 }
+
+export const __imageVisionTest = { expandHome, analyzeCodex, appendCodexSseDelta, codexResponsesUrl, extractCodexAccountId };

package/hooks/mcp.ts

@@ -360,9 +360,17 @@ export const mcpModule: Module = {
 
         // connectAll runs in the background so the watchdog tests
         // that mock hung connections don't block session_start.
+        //
+        // Capture hasUI / notify synchronously: connectAll may resolve
+        // after the session is replaced or reloaded, at which point `ctx`
+        // is stale and its `hasUI` getter throws via assertActive.
+        // Using the captured plain values avoids touching the stale ctx
+        // in the .then callback.
+        const hasUI = ctx.hasUI;
+        const notify = ctx.ui?.notify?.bind(ctx.ui);
         void connectAll(toConnect, ctx.modelRegistry, ctx).then(({ schemaChanges }) => {
-          if (schemaChanges.length > 0 && ctx.hasUI) {
-            ctx.ui.notify(`mcp schema changed! please '/reload'`, "warning");
+          if (schemaChanges.length > 0 && hasUI && notify) {
+            notify(`mcp schema changed! please '/reload'`, "warning");
           }
         });
       },

package/hooks/pi-tool-filter.ts

@@ -1,16 +1,12 @@
 /**
  * pi-tool-filter — unregister pi native tools that are replaced by our extensions.
  *
- *   edit   → replaced by patch
- *   write  → replaced by patch
- *   grep   → replaced by bash
- *   find   → replaced by bash
- *   ls     → replaced by bash
+ *   edit  → replaced by patch
  */
 
 import type { Module, Skeleton } from "./skeleton.js";
 
-const TOOLS_TO_DROP = new Set(["edit", "write", "grep", "find", "ls"]);
+const TOOLS_TO_DROP = new Set(["edit"]);
 
 export const piToolFilterModule: Module = {
   name: "pi-tool-filter",

package/hooks/skeleton.ts

@@ -25,7 +25,8 @@ export type HookEvent =
   | "agent_end"
   | "input"
   | "tool_call"
-  | "tool_result";
+  | "tool_result"
+  | "message_end";
 
 // ─── Handler modes ─────────────────────────────────────────────────────────
 
@@ -67,6 +68,7 @@ export interface Module {
     input?: ParallelHandler<"input">[];
     tool_call?: ComposeHandler<"tool_call">[];
     tool_result?: ComposeHandler<"tool_result">[];
+    message_end?: ComposeHandler<"message_end">[];
   };
 }
 
@@ -99,6 +101,7 @@ const COMPOSE_EVENTS = new Set<HookEvent>([
   "before_agent_start",
   "tool_call",
   "tool_result",
+  "message_end",
 ]);
 
 /** Events whose handler return value is propagated to the extension runner

package/hooks/smart-at.ts

@@ -6,6 +6,10 @@
  * frecency + git status, and returns ranked results. We create one
  * FileFinder per session and query it directly for every @ prefix.
  *
+ * Result handling trusts FFF's native score: re-sort by score
+ * descending (shorter path breaks ties), no substring or git-ignore
+ * post-filtering.
+ *
  * KNOWN FFF LIMITATION (v0.9.4):
  * FFF only returns directories that directly contain files. Intermediate
  * folders that only hold subdirectories (e.g. product/module/apmanage/ where
@@ -24,7 +28,6 @@ import type { Module, Skeleton } from "./skeleton.js";
 const AT_BOUNDARY = new Set<string>([" ", "\t", "(", "["]);
 
 const AUTOCOMPLETE_LIMIT = 20;
-const FFF_SUPERSET = 100;
 const WIDGET_FOOTER = "\x1b[2mpowered by fff\x1b[0m";
 
 interface AutocompleteItem {
@@ -45,10 +48,6 @@ function atPrefix(text: string): string | null {
   return null;
 }
 
-function isGitIgnored(item: MixedItem): boolean {
-  return item.type === "file" && item.item.gitStatus === "ignored";
-}
-
 function toAutocompleteItem(item: MixedItem): AutocompleteItem {
   const path = item.item.relativePath;
   const label = item.type === "file"
@@ -65,23 +64,20 @@ interface BuiltResult {
   items: AutocompleteItem[];
 }
 
-/** Take FFF's ranked results, drop git-ignored files, and for non-empty
- *  queries keep only paths that contain the query as a substring. This
- *  stops FFF's loose fuzzy matching from ranking every file in a directory
- *  that happens to share a few letters (e.g. "mm/" for query "mmc"). */
-function buildResult(items: MixedItem[], lowerQuery: string): BuiltResult | null {
-  const filtered = items
-    .filter((it) => !isGitIgnored(it))
-    .filter(
-      (it) =>
-        !lowerQuery || it.item.relativePath.toLowerCase().includes(lowerQuery),
-    )
+/** Take FFF's mixed-search results and re-sort by native score descending
+ *  (score ties broken by shorter path first), then map to autocomplete
+ *  items. Trust FFF's fuzzy+frecency score; no substring or git-ignore
+ *  post-filtering. */
+function buildResult(items: MixedItem[], scores: { total: number }[]): BuiltResult | null {
+  const ranked = items
+    .map((item, index) => ({ item, score: scores[index]?.total ?? 0 }))
+    .sort((a, b) => b.score - a.score || a.item.item.relativePath.length - b.item.item.relativePath.length)
     .slice(0, AUTOCOMPLETE_LIMIT)
-    .map(toAutocompleteItem);
-  return filtered.length ? { items: filtered } : null;
+    .map((entry) => toAutocompleteItem(entry.item));
+  return ranked.length ? { items: ranked } : null;
 }
 
-export const __smartAtTest = { atPrefix };
+export const __smartAtTest = { atPrefix, buildResult };
 
 /** Active FileFinder for the current session; freed in session_shutdown
  *  to avoid leaking FFF's native handle + LMDB mmap regions. */
@@ -148,9 +144,8 @@ export const smartAtModule: Module = {
             }
 
             const query = prefix.slice(1);
-            const lowerQuery = query.toLowerCase();
-            const r = finder.mixedSearch(lowerQuery, {
-              pageSize: lowerQuery ? FFF_SUPERSET : AUTOCOMPLETE_LIMIT,
+            const r = finder.mixedSearch(query.toLowerCase(), {
+              pageSize: AUTOCOMPLETE_LIMIT,
             });
             if (!r.ok) {
               ctx.ui.setWidget("smart-at", undefined);
@@ -178,7 +173,7 @@ export const smartAtModule: Module = {
               return null;
             }
 
-            const result = buildResult(r.value.items, lowerQuery);
+            const result = buildResult(r.value.items, r.value.scores);
             if (!result) {
               ctx.ui.setWidget("smart-at", undefined);
               return null;

package/hooks/thinking-label-strip.ts

@@ -0,0 +1,79 @@
+/**
+ * thinking-label-strip — remove stray <thinking></thinking> tags from
+ * assistant thinking blocks.
+ *
+ * Some models wrap their own reasoning text in literal <thinking></thinking>
+ * tags inside the `thinking` field of a ThinkingContent block. The tag
+ * itself is noise — pi already marks the block as type "thinking", so the
+ * tag is redundant. When it leaks into the context it confuses downstream
+ * consumers (compaction, other models that echo it back) and pollutes the
+ * session transcript.
+ *
+ * This hook intercepts `message_end` for assistant messages and strips
+ * every <thinking></thinking> pair from each ThinkingContent block's text,
+ * preserving the reasoning between the tags. The edit is persistent: the
+ * stored message is replaced, so the context sent to subsequent LLM calls
+ * no longer contains the literal tag.
+ */
+
+import type { Module } from "./skeleton.js";
+
+const THINKING_OPEN = "<thinking>";
+const THINKING_CLOSE = "</thinking>";
+
+/** Strip a leading <thinking> and/or trailing </thinking> from `text`.
+ *  Models often emit these tags as delimiters inside the `thinking` field;
+ *  pi already marks the block type, so the tags are noise that leaks into
+ *  the context and the TUI. We only trim at the head/tail — tags buried in
+ *  the middle are part of the reasoning text and left alone, which avoids
+ *  corrupting the model's argument if it literally discusses the tag. */
+export function stripThinkingLabels(text: string): string {
+  if (!text.includes(THINKING_OPEN) && !text.includes(THINKING_CLOSE)) {
+    return text;
+  }
+  let out = text;
+  // trimStart would loop-strip repeating opens; we want a single leading
+  // open tag (optionally with whitespace before it) removed.
+  const leadingOpen = out.match(/^\s*<thinking>/);
+  if (leadingOpen) {
+    out = out.slice(leadingOpen[0].length);
+  }
+  const trailingClose = out.match(/<\/thinking>\s*$/);
+  if (trailingClose) {
+    out = out.slice(0, out.length - trailingClose[0].length);
+  }
+  return out;
+}
+
+/** Return a new content array with thinking blocks cleaned, or undefined
+ *  if nothing changed. */
+function cleanContent(content: any[]): any[] | undefined {
+  let changed = false;
+  const next = content.map((block) => {
+    if (block && block.type === "thinking" && typeof block.thinking === "string") {
+      const cleaned = stripThinkingLabels(block.thinking);
+      if (cleaned !== block.thinking) {
+        changed = true;
+        return { ...block, thinking: cleaned };
+      }
+    }
+    return block;
+  });
+  return changed ? next : undefined;
+}
+
+export const thinkingLabelStripModule: Module = {
+  name: "thinking-label-strip",
+  hooks: {
+    message_end: [
+      (event: any) => {
+        const message = event?.message;
+        if (!message || message.role !== "assistant") return undefined;
+        if (!Array.isArray(message.content)) return undefined;
+        const cleaned = cleanContent(message.content);
+        if (!cleaned) return undefined;
+        return { message: { ...message, content: cleaned } };
+      },
+    ],
+  },
+};