pi-tool-repair 0.1.11 → 0.2.0

package/README.md

@@ -21,16 +21,19 @@ Reverse-engineered from [Command Code](https://commandcode.ai/)'s tool parsing p
 
 ## What it fixes
 
-| Problem                       | Model sends                        | After repair                |
-| ----------------------------- | ---------------------------------- | --------------------------- |
-| `null` for optional fields    | `{"path": "/foo", "offset": null}` | `{"path": "/foo"}`          |
-| Arrays as JSON strings        | `"[\"a\",\"b\"]"`                  | `["a","b"]`                 |
-| `{}` where array expected     | `{"include": {}}`                  | _(dropped)_                 |
-| Bare string → array           | `"foo"`                            | `["foo"]`                   |
-| Wrong field names             | `{"file_path": "/foo"}`            | `{"path": "/foo"}`          |
-| Bare string as root input     | `"/path/to/file"`                  | `{"path": "/path/to/file"}` |
-| Schema anchor bleed (Kimi K2) | `"^pattern$"` in values            | `"pattern"`                 |
-| Leaked tool grammar (opt-in)  | `<｜DSML｜tool_calls>...`          | pi `toolCall` block         |
+| Problem | Model sends | After repair |
+| ------- | ----------- | ------------ |
+| `null` for optional fields | `{"path":"/foo","offset":null}` | `{"path":"/foo"}` |
+| Arrays as JSON strings | `{"edits":"[{...}]"}` | `{"edits":[{...}]}` |
+| `{}` where an optional array is expected | `{"include":{}}` | _(dropped)_ |
+| Bare string where an array is expected | `{"include":"foo"}` | `{"include":["foo"]}` |
+| Wrong field names | `{"file_path":"/foo"}` | `{"path":"/foo"}` |
+| Numeric strings | `{"limit":"20"}` | `{"limit":20}` |
+| Bare string as root input | `"/path/to/file"` | `{"path":"/path/to/file"}` |
+| `fabric_exec` code arrays | `{"code":["const x=1;","return x;"]}` | newline-joined `code` |
+| Schema anchor bleed (Kimi K2) | `"^pattern$"` in values | `"pattern"` |
+| Leaked tool grammar (opt-in) | `<｜DSML｜tool_calls>...` | pi `toolCall` block |
+| Phantom tool use | `stopReason:"toolUse"` with no call | retryable error |
 
 ## Install
 
@@ -72,62 +75,40 @@ Reload with `/reload` after any install method.
 
 ## How it works
 
-```
-┌────────────────────────────────────────────────────────────┐
-│ Phase 0: Schema poisoning (before_provider_request)        │
-│                                                            │
-│ Strip regex anchors from JSON Schema patterns for models   │
-│ where they leak into generated values (Kimi K2, MiniMax)   │
-│                                                            │
-│ Fixes what YOU send the model — not what the model sends   │
-└──────────────────────────┬─────────────────────────────────┘
-                           │
-                           ▼
-               Model generates tool call
-                           │
-                           ▼
-┌────────────────────────────────────────────────────────────┐
-│ Phase 1: Grammar leak repair (message_end, opt-in)         │
-│                                                            │
-│ Detect raw XML/sentinel tool grammars emitted as text or   │
-│ thinking, strip them from visible output, and recover them │
-│ as pi toolCall blocks when complete and safe.              │
-└──────────────────────────┬─────────────────────────────────┘
-                           │
-                           ▼
-┌────────────────────────────────────────────────────────────┐
-│ Phase 2: Validate-then-repair (tool_call)                  │
-│                                                            │
-│  1. Validate input against schema (if known tool)          │
-│   ↳ Valid? Ship it untouched.                              │
-│  2. Walk the validator's issue list                        │
-│   ↳ Apply targeted repairs only at the exact failed paths  │
-│  3. Re-validate the repaired input                         │
-│   ↳ Still invalid? Let the tool handle it.                 │
-│  4. Log outcome (debug mode)                               │
-└────────────────────────────────────────────────────────────┘
-```
+```text
+before_provider_request
+  └─ model-gated schema anchor sanitization
 
-### Repair rules (in order)
+model response → message_end
+  ├─ strip leaked grammar tokens from native toolCall blocks
+  ├─ recover complete leaked grammar calls when enabled
+  ├─ validate raw arguments against each active tool's live schema
+  ├─ apply only known aliases and schema-directed repairs
+  ├─ commit a candidate only when it re-validates
+  └─ turn phantom toolUse responses into retryable errors
 
-Order matters — `parseJsonStringifiedArray` must run before `wrapBareStringAsArray` or you get double-wrapping.
+Pi then runs its normal prepare → validate → execute pipeline
+```
 
-| #   | Rule                         | What it catches                                 |
-| --- | ---------------------------- | ----------------------------------------------- |
-| 1   | `renameAliasedField`         | `file_path` → `path`, `query` → `pattern`, etc. |
-| 2   | `dropNullOrUndefined`        | `null`/`undefined` for optional fields          |
-| 3   | `dropEmptyObjectPlaceholder` | `{}` where array expected                       |
-| 4   | `parseJsonStringifiedArray`  | `"[\"a\",\"b\"]"` → `["a","b"]`                 |
-| 5   | `wrapBareStringAsArray`      | `"foo"` → `["foo"]`                             |
-| 6   | `wrapRootStringAsObject`     | `"/path"` → `{"path": "/path"}`                 |
+Pi 0.84 validates tool arguments before emitting `tool_call`. Repair therefore runs on the finalized assistant message, while the provider's raw arguments are still available and before Pi's validation can reject or coerce them.
 
-### Why validate-then-repair (not preprocess-then-validate)
+### Repair rules
 
-Preprocessing inputs before validation silently corrupts valid data — rewriting file content that happened to look like JSON, for example. The better design:
+| Rule | What it catches |
+| ---- | --------------- |
+| `renameAliasedField` | `file_path` → `path`, `query` → `pattern`, option aliases, etc. |
+| `dropNullOrUndefined` | `null`/`undefined` for schema-optional fields |
+| `dropEmptyObjectPlaceholder` | `{}` where an optional array is expected |
+| `parseJsonStringifiedArray` | `"[\"a\",\"b\"]"` → `["a","b"]` |
+| `wrapBareStringAsArray` | `"foo"` → `["foo"]` when the schema expects an array |
+| `wrapRootStringAsObject` | `"/path"` → `{"path":"/path"}` for known string-primary tools |
+| `coerceNumericString` | `"20"` → `20` when the live schema expects a number |
+| `convertTimeoutMilliseconds` | `timeoutMs` → `timeout` seconds for `bash` |
+| `joinStringArray` | all-string `fabric_exec.code` arrays → one newline-joined string |
 
-1. **Parse the input as-is.** If valid, ship it untouched.
-2. **On failure, walk the validator's issue list** and apply repairs only at the exact paths that failed.
-3. **Re-validate.** The schema localizes the bug for you — you only spend repair effort where it's actually needed.
+### Why validate-then-repair
+
+The extension reads the schemas from `pi.getAllTools()` instead of maintaining a parallel copy. Schema-valid input with no known compatibility aliases is returned unchanged. Invalid input is cloned, repaired only at schema-declared fields, and revalidated; an unrepairable candidate is discarded so Pi reports the original error. Canonical fields win when both canonical and alias spellings are present.
 
 ## Configuration
 
@@ -164,6 +145,24 @@ Modes:
 | `recover` | Strip leaked markup and append recovered pi `toolCall` blocks. |
 | `strip`   | Strip leaked markup only; do not execute recovered calls.      |
 
+#### Per-model enablement
+
+If only some of your models leak grammar — common with local servers such as llama.cpp, vLLM, or Ollama — auto-enable recovery per model id with `leakModels`. Entries are case-insensitive regex fragments matched against the active model id:
+
+```json
+{
+  "grammarRepair": {
+    "leakModels": ["kimi", "qwen3", "gguf"]
+  }
+}
+```
+
+Recovery turns on whenever the session's model id matches a pattern. Global `enabled: true` takes precedence over `leakModels`, so models with reliable native tool calling stay untouched. Regex entries that fail to compile are ignored.
+
+#### What the model sees on the next request
+
+Every repair runs on pi's `message_end` hook, where the repaired message is replaced in place — the corrected call, not the model's original output, is what pi writes to the session file and resends on later requests. With `mode: "recover"`, leaked tool-call text is likewise converted into real `toolCall` blocks before persistence, so subsequent requests show the model a properly formed call plus its tool results: an in-context correction loop instead of a silent execute-time patch. Local models benefit the most since there is no prompt-cache penalty for the rewritten history; providers that cache by prefix may treat the first turn after a repair as a cache miss.
+
 Safety gates:
 
 - `requireKnownTool: true` only recovers calls whose name is in pi's active tool registry.
@@ -186,7 +185,11 @@ Set `PI_TOOL_REPAIR_DEBUG=1` or `grammarRepair.debug: true` to log repair diagno
 
 ### Covered tools
 
-Repair rules apply to pi's built-in tools: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`.
+Schema-directed null, array, and numeric repairs apply to every active tool whose live schema Pi exposes. The curated alias table covers Pi's built-in `read`, `write`, `edit`, `bash`, `grep`, `find`, and `ls` tools. `fabric_exec` root strings and all-string `code` arrays are also supported.
+
+### Pi Fabric compatibility
+
+With Pi Fabric full code mode, `pi-tool-repair` sees `fabric_exec` as the active model-facing tool. It repairs the outer call, leaked provider grammars, anchor bleed, and phantom tool-use responses before Pi validation. Nested `pi.*` calls are created later by Fabric's TypeScript guest, so Fabric owns their alias and optional-null normalization before its registry validation. No duplicate tool registration or wrapper is required.
 
 ### Anchor bleed models
 
@@ -205,32 +208,33 @@ To add more models, edit `anchorBleedModels` in [`src/index.ts`](./src/index.ts)
 The extension maps common model mistakes (wrong field names) to the canonical field name. For example, when calling `read`, the model can send `file_path`, `absolutePath`, `filepath`, `target_file`, etc. — all map to `path`.
 
 <details>
-<summary><strong>Full alias table</strong></summary>
-
-| Tool    | Canonical | Aliases                                                                                                                                   |
-| ------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
-| `read`  | `path`    | `absolutePath`, `file_path`, `filePath`, `filepath`, `pathname`, `target_file`, `targetFile`, `file`, `absolute_path`, `fileAbsolutePath` |
-| `grep`  | `pattern` | `query`, `regex`, `search`, `q`, `expression`, `text`                                                                                     |
-| `write` | `path`    | `absolutePath`, `file_path`, `filePath`, `filepath`, `pathname`, `target_file`, `targetFile`                                              |
-| `write` | `content` | `text`, `body`, `data`, `contents`, `fileContent`                                                                                         |
-| `edit`  | `path`    | `absolutePath`, `file_path`, `filePath`, `filepath`, `pathname`, `target_file`, `targetFile`                                              |
-| `edit`  | `oldText` | `old_string`, `oldString`, `old`, `old_str`, `oldStr`, `from`, `old_value`, `oldText`, `old_text`, `oldContent`, `old_content`            |
-| `edit`  | `newText` | `new_string`, `newString`, `new`, `new_str`, `newStr`, `to`, `new_value`, `newText`, `new_text`, `newContent`, `new_content`              |
-| `ls`    | `path`    | `absolutePath`, `directory`, `dir`, `folder`, `directoryPath`                                                                             |
-| `find`  | `pattern` | `query`, `glob`, `expression`, `search`, `include`                                                                                        |
-| `bash`  | `command` | `cmd`, `shell`, `script`, `commandLine`                                                                                                   |
+<summary><strong>Alias summary</strong></summary>
+
+| Tool | Canonical | Aliases |
+| ---- | --------- | ------- |
+| `read` | `path` | `absolutePath`, `file_path`, `filePath`, `filepath`, `pathname`, `target_file`, `targetFile`, `file`, `absolute_path`, `fileAbsolutePath` |
+| `read` | `offset`, `limit` | `start`, `max` |
+| `grep` | `pattern` | `query`, `regex`, `search`, `q`, `expression`, `text` |
+| `grep` | `glob`, `ignoreCase`, `context`, `limit` | `globPattern`, `ic`, `caseInsensitive`, `ctx`, `max` |
+| `write` | `path`, `content` | path aliases above; `text`, `body`, `data`, `contents`, `fileContent` |
+| `edit` | `path` | path aliases above |
+| `edit` | `oldText` | `old_string`, `oldString`, `old`, `old_str`, `oldStr`, `from`, `old_value`, `old_text`, `oldContent`, `old_content` |
+| `edit` | `newText` | `new_string`, `newString`, `new`, `replacement`, `new_str`, `newStr`, `to`, `new_value`, `new_text`, `newContent`, `new_content` |
+| `ls` | `path`, `limit` | path aliases plus `directory`, `dir`, `folder`, `directoryPath`; `max` |
+| `find` | `pattern`, `limit` | `query`, `regex`, `glob`, `expression`, `search`, `include`, `name`, `filename`; `max` |
+| `bash` | `command` | `cmd`, `shell`, `cmdline`, `script`, `commandLine` |
 
 </details>
 
 ## Development
 
 ```bash
-npm install
-npm test              # run tests
-npm run test:watch    # watch mode
-npm run test:coverage # coverage report
-npm run typecheck     # type checking
-npm run lint:dead     # dead code detection
+pnpm install
+pnpm test              # run tests
+pnpm run test:watch    # watch mode
+pnpm run test:coverage # coverage report
+pnpm run typecheck     # type checking
+pnpm run lint:dead     # dead code detection
 ```
 
 ## Related projects

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-repair",
-  "version": "0.1.11",
+  "version": "0.2.0",
   "description": "Validate-then-repair extension for pi — fixes common LLM tool-call mistakes (null fields, stringified arrays, wrong field names, anchor bleed) before tools execute",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -38,9 +38,14 @@
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",
+    "typebox": "1.3.7",
     "typescript": "6.0.3",
     "vitest": "4.1.7"
   },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
   "pi": {
     "extensions": [
       "./tool-repair.ts"

package/src/grammar-repair.ts

@@ -24,6 +24,9 @@ export interface GrammarRepairConfig {
   mode: GrammarRepairMode;
   requireKnownTool: boolean;
   debug: boolean;
+  // Case-insensitive regex fragments that auto-enable grammar repair when the
+  // active model id matches one of them. Ignored while `enabled` is true.
+  leakModels?: string[];
 }
 
 export interface ExtensionFileConfig {
@@ -119,15 +122,52 @@ export function normalizeGrammarRepairConfig(raw: Partial<GrammarRepairConfig> =
     ? raw.grammars.filter((name): name is GrammarName => grammarSet.has(name as GrammarName))
     : ALL_GRAMMARS;
 
+  const leakModels = normalizeLeakModels(raw.leakModels);
+
   return {
     enabled: raw.enabled ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.enabled,
     grammars: grammars.length > 0 ? grammars : ALL_GRAMMARS,
     mode: raw.mode === "strip" ? "strip" : "recover",
     requireKnownTool: raw.requireKnownTool ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.requireKnownTool,
     debug: raw.debug ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.debug,
+    ...(leakModels ? { leakModels } : {}),
   };
 }
 
+const compileLeakModelPattern = (pattern: string): RegExp | undefined => {
+  try {
+    return new RegExp(pattern, "i");
+  } catch {
+    return undefined;
+  }
+};
+
+function normalizeLeakModels(raw: unknown): string[] | undefined {
+  if (!Array.isArray(raw)) return undefined;
+  const valid = raw.filter(
+    (pattern): pattern is string =>
+      typeof pattern === "string" && compileLeakModelPattern(pattern) !== undefined,
+  );
+  return valid.length > 0 ? valid : undefined;
+}
+
+// Enables grammar repair for the current message when the active model id
+// matches a configured leakModels pattern. Global `enabled: true` always wins,
+// so models with native tool calling keep the recovery path off unless listed.
+export function resolveGrammarRepairForModel(
+  config: GrammarRepairConfig,
+  model: { id?: string } | null | undefined,
+): GrammarRepairConfig {
+  if (config.enabled) return config;
+  const patterns = config.leakModels;
+  if (!patterns || patterns.length === 0) return config;
+  const modelId = model?.id;
+  if (typeof modelId !== "string" || modelId.length === 0) return config;
+  return patterns.some((pattern) => compileLeakModelPattern(pattern)?.test(modelId))
+    ? { ...config, enabled: true }
+    : config;
+}
+
 export function repairAssistantMessageGrammarLeaks(
   message: MinimalAssistantMessage,
   config: GrammarRepairConfig,

package/src/index.ts

@@ -8,6 +8,10 @@
 // ─── Configuration ────────────────────────────────────────────────────────────
 
 import type { MinimalAssistantMessage } from "./grammar-repair.js";
+import { Value } from "typebox/value";
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
 
 export interface RepairConfig {
   debug: boolean;
@@ -33,39 +37,51 @@ export const DEFAULT_CONFIG: RepairConfig = {
         "absolutePath", "file_path", "filePath", "filepath", "pathname",
         "target_file", "targetFile", "file", "absolute_path", "fileAbsolutePath",
       ],
+      offset: ["start"],
+      limit: ["max"],
     },
     grep: {
       pattern: ["query", "regex", "search", "q", "expression", "text"],
+      glob: ["globPattern"],
+      ignoreCase: ["ic", "caseInsensitive"],
+      context: ["ctx"],
+      limit: ["max"],
     },
     write: {
       path: [
         "absolutePath", "file_path", "filePath", "filepath", "pathname",
-        "target_file", "targetFile",
+        "target_file", "targetFile", "file", "absolute_path", "fileAbsolutePath",
       ],
       content: ["text", "body", "data", "contents", "fileContent"],
     },
     edit: {
       path: [
         "absolutePath", "file_path", "filePath", "filepath", "pathname",
-        "target_file", "targetFile",
+        "target_file", "targetFile", "file", "absolute_path", "fileAbsolutePath",
       ],
       oldText: [
         "old_string", "oldString", "old", "old_str", "oldStr", "from",
-        "old_value", "oldText", "old_text", "oldContent", "old_content",
+        "old_value", "old_text", "oldContent", "old_content",
       ],
       newText: [
-        "new_string", "newString", "new", "new_str", "newStr", "to",
-        "new_value", "newText", "new_text", "newContent", "new_content",
+        "new_string", "newString", "new", "replacement", "new_str", "newStr", "to",
+        "new_value", "new_text", "newContent", "new_content",
       ],
     },
     ls: {
-      path: ["absolutePath", "directory", "dir", "folder", "directoryPath"],
+      path: [
+        "absolutePath", "file_path", "filePath", "filepath", "pathname",
+        "target_file", "targetFile", "file", "absolute_path", "fileAbsolutePath",
+        "directory", "dir", "folder", "directoryPath",
+      ],
+      limit: ["max"],
     },
     find: {
-      pattern: ["query", "glob", "expression", "search", "include"],
+      pattern: ["query", "regex", "glob", "expression", "search", "include", "name", "filename"],
+      limit: ["max"],
     },
     bash: {
-      command: ["cmd", "shell", "script", "commandLine"],
+      command: ["cmd", "shell", "cmdline", "script", "commandLine"],
     },
   },
   stringArgTools: {
@@ -74,6 +90,7 @@ export const DEFAULT_CONFIG: RepairConfig = {
     bash: { field: "command", shape: "string" },
     read: { field: "path", shape: "string" },
     ls: { field: "path", shape: "string" },
+    fabric_exec: { field: "code", shape: "string" },
   },
 };
 
@@ -114,14 +131,18 @@ export function sanitizeSchemaAnchors(schema: unknown): unknown {
   return result;
 }
 
-export function stripAnchorBleedInPlace(obj: Record<string, unknown>): void {
+export function stripAnchorBleedInPlace(obj: Record<string, unknown>): boolean {
+  let changed = false;
   for (const key of Object.keys(obj)) {
     const value = obj[key];
     if (typeof value === "string") {
       let s = value;
       while (s.startsWith("^")) s = s.slice(1);
       while (s.endsWith("$")) s = s.slice(0, -1);
-      obj[key] = s;
+      if (s !== value) {
+        obj[key] = s;
+        changed = true;
+      }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
         const item = value[i];
@@ -129,15 +150,19 @@ export function stripAnchorBleedInPlace(obj: Record<string, unknown>): void {
           let s = item;
           while (s.startsWith("^")) s = s.slice(1);
           while (s.endsWith("$")) s = s.slice(0, -1);
-          value[i] = s;
+          if (s !== item) {
+            value[i] = s;
+            changed = true;
+          }
         } else if (item && typeof item === "object") {
-          stripAnchorBleedInPlace(item as Record<string, unknown>);
+          if (stripAnchorBleedInPlace(item as Record<string, unknown>)) changed = true;
         }
       }
     } else if (value && typeof value === "object") {
-      stripAnchorBleedInPlace(value as Record<string, unknown>);
+      if (stripAnchorBleedInPlace(value as Record<string, unknown>)) changed = true;
     }
   }
+  return changed;
 }
 
 // Leaked grammar markers from GLM/ChatGLM style tool-call grammars.
@@ -150,19 +175,26 @@ const GRAMMAR_TOKEN_LEAKS = [
   { tag: "</arg_value>", at: "end" as const },
 ];
 
+const stripBoundaryGrammarTokens = (value: string): string | undefined => {
+  let stripped = value;
+  let changed = false;
+  for (const { tag, at } of GRAMMAR_TOKEN_LEAKS) {
+    if (at === "start" && stripped.startsWith(tag)) {
+      stripped = stripped.slice(tag.length);
+      changed = true;
+    } else if (at === "end" && stripped.endsWith(tag)) {
+      stripped = stripped.slice(0, -tag.length);
+      changed = true;
+    }
+  }
+  return changed ? stripped.trim() : undefined;
+};
+
 export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): boolean {
   let changed = false;
   for (const key of Object.keys(obj)) {
     const value = obj[key];
-    let newKey = key;
-    for (const { tag, at } of GRAMMAR_TOKEN_LEAKS) {
-      if (at === "start" && newKey.startsWith(tag)) {
-        newKey = newKey.slice(tag.length);
-      } else if (at === "end" && newKey.endsWith(tag)) {
-        newKey = newKey.slice(0, -tag.length);
-      }
-    }
-    newKey = newKey.trim();
+    const newKey = stripBoundaryGrammarTokens(key) ?? key;
 
     if (newKey !== key) {
       obj[newKey] = value;
@@ -171,44 +203,26 @@ export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): boo
     }
 
     if (typeof value === "string") {
-      let s = value;
-      for (const { tag, at } of GRAMMAR_TOKEN_LEAKS) {
-        if (at === "start" && s.startsWith(tag)) {
-          s = s.slice(tag.length);
-        } else if (at === "end" && s.endsWith(tag)) {
-          s = s.slice(0, -tag.length);
-        }
-      }
-      const trimmed = s.trim();
-      if (trimmed !== value) {
-        obj[newKey] = trimmed;
+      const stripped = stripBoundaryGrammarTokens(value);
+      if (stripped !== undefined) {
+        obj[newKey] = stripped;
         changed = true;
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
         const item = value[i];
         if (typeof item === "string") {
-          let s = item;
-          for (const { tag, at } of GRAMMAR_TOKEN_LEAKS) {
-            if (at === "start" && s.startsWith(tag)) {
-              s = s.slice(tag.length);
-            } else if (at === "end" && s.endsWith(tag)) {
-              s = s.slice(0, -tag.length);
-            }
-          }
-          const trimmed = s.trim();
-          if (trimmed !== item) {
-            value[i] = trimmed;
+          const stripped = stripBoundaryGrammarTokens(item);
+          if (stripped !== undefined) {
+            value[i] = stripped;
             changed = true;
           }
         } else if (item && typeof item === "object") {
-          const nestedChanged = stripGrammarTokenLeaksInPlace(item as Record<string, unknown>);
-          if (nestedChanged) changed = true;
+          if (stripGrammarTokenLeaksInPlace(item as Record<string, unknown>)) changed = true;
         }
       }
     } else if (value && typeof value === "object") {
-      const nestedChanged = stripGrammarTokenLeaksInPlace(value as Record<string, unknown>);
-      if (nestedChanged) changed = true;
+      if (stripGrammarTokenLeaksInPlace(value as Record<string, unknown>)) changed = true;
     }
   }
   return changed;
@@ -536,9 +550,7 @@ export const BUILTIN_SCHEMAS: Record<string, ToolSchema> = {
   },
   edit: {
     path: { type: "string", required: true },
-    oldText: { type: "string", required: true },
-    newText: { type: "string", required: true },
-    replaceAll: { type: "boolean" },
+    edits: { type: "array", required: true, items: { type: "object" } },
   },
   bash: {
     command: { type: "string", required: true },
@@ -546,13 +558,21 @@ export const BUILTIN_SCHEMAS: Record<string, ToolSchema> = {
   },
   grep: {
     pattern: { type: "string", required: true },
-    include: { type: "array", items: { type: "string" } },
+    path: { type: "string" },
+    glob: { type: "string" },
+    ignoreCase: { type: "boolean" },
+    literal: { type: "boolean" },
+    context: { type: "number" },
+    limit: { type: "number" },
   },
   find: {
     pattern: { type: "string", required: true },
+    path: { type: "string" },
+    limit: { type: "number" },
   },
   ls: {
     path: { type: "string" },
+    limit: { type: "number" },
   },
 };
 
@@ -609,7 +629,318 @@ export function validateAgainstSchema(
   return issues;
 }
 
-// ─── Logging ──────────────────────────────────────────────────────────────────
+
+export type LiveToolSchema = {
+  name: string;
+  parameters: import("typebox").TSchema;
+};
+
+export type LiveRepairStatus = "unchanged" | "recovered" | "unrepairable";
+
+export interface LiveToolRepairOutcome {
+  toolName: string;
+  status: LiveRepairStatus;
+  input: unknown;
+  repaired?: unknown;
+  rulesFired: string[];
+  hints: string[];
+}
+
+export interface AssistantToolCallRepairResult {
+  changed: boolean;
+  message: MinimalAssistantMessage;
+  repairs: LiveToolRepairOutcome[];
+}
+
+const schemaRecord = (schema: unknown): Record<string, unknown> | undefined =>
+  isObject(schema) ? schema : undefined;
+
+const schemaProperties = (schema: unknown): Record<string, Record<string, unknown>> => {
+  const properties = schemaRecord(schema)?.properties;
+  if (!isObject(properties)) return {};
+  return Object.fromEntries(
+    Object.entries(properties)
+      .filter((entry): entry is [string, Record<string, unknown>] => isObject(entry[1])),
+  );
+};
+
+const schemaRequired = (schema: unknown): Set<string> => {
+  const required = schemaRecord(schema)?.required;
+  return new Set(Array.isArray(required) ? required.filter((key): key is string => typeof key === "string") : []);
+};
+
+const schemaCheck = (schema: import("typebox").TSchema, input: unknown): boolean | undefined => {
+  try {
+    return Value.Check(schema, input);
+  } catch {
+    return undefined;
+  }
+};
+
+const addRule = (
+  rulesFired: string[],
+  hints: string[],
+  ruleName: string,
+  hint: string,
+): void => {
+  if (!rulesFired.includes(ruleName)) rulesFired.push(ruleName);
+  hints.push(hint);
+};
+
+const firstUsableField = (
+  input: Record<string, unknown>,
+  names: string[],
+): { key: string; value: unknown } | undefined => {
+  for (const key of names) {
+    if (!Object.hasOwn(input, key)) continue;
+    const value = input[key];
+    if (value === null || value === undefined || value === "") continue;
+    return { key, value };
+  }
+  return undefined;
+};
+
+const deleteFields = (input: Record<string, unknown>, names: string[]): void => {
+  for (const name of names) delete input[name];
+};
+
+const repairObjectFromSchema = (
+  toolName: string,
+  schema: Record<string, unknown>,
+  input: Record<string, unknown>,
+  rulesFired: string[],
+  hints: string[],
+  path: string[] = [],
+): void => {
+  const properties = schemaProperties(schema);
+  const required = schemaRequired(schema);
+  const aliases = DEFAULT_CONFIG.fieldAliases[toolName] ?? {};
+
+  for (const [canonical, aliasNames] of Object.entries(aliases)) {
+    if (!Object.hasOwn(properties, canonical) || Object.hasOwn(input, canonical)) continue;
+    const alias = firstUsableField(input, aliasNames.filter((name) => name !== canonical));
+    if (!alias) continue;
+    input[canonical] = alias.value;
+    delete input[alias.key];
+    addRule(
+      rulesFired,
+      hints,
+      "renameAliasedField",
+      `Renamed \`${[...path, alias.key].join(".")}\` to \`${[...path, canonical].join(".")}\` for tool "${toolName}".`,
+    );
+  }
+
+  if (toolName === "edit" && path.length === 0 && Object.hasOwn(properties, "edits") && !Object.hasOwn(input, "edits")) {
+    const oldNames = ["oldText", ...(aliases.oldText ?? []).filter((name) => name !== "oldText")];
+    const newNames = ["newText", ...(aliases.newText ?? []).filter((name) => name !== "newText")];
+    const oldField = firstUsableField(input, oldNames);
+    const newField = firstUsableField(input, newNames);
+    if (typeof oldField?.value === "string" && typeof newField?.value === "string") {
+      deleteFields(input, oldNames);
+      deleteFields(input, newNames);
+      input.edits = [{ oldText: oldField.value, newText: newField.value }];
+      addRule(
+        rulesFired,
+        hints,
+        "wrapLegacyEditFields",
+        "Moved legacy edit text fields into the current `edits` array.",
+      );
+    }
+  }
+
+  if (
+    toolName === "bash" &&
+    path.length === 0 &&
+    !Object.hasOwn(input, "timeout") &&
+    Object.hasOwn(input, "timeoutMs")
+  ) {
+    const timeoutMs = input.timeoutMs;
+    if (timeoutMs !== null && timeoutMs !== undefined && Number.isFinite(Number(timeoutMs))) {
+      input.timeout = Number(timeoutMs) / 1000;
+      delete input.timeoutMs;
+      addRule(
+        rulesFired,
+        hints,
+        "convertTimeoutMilliseconds",
+        "Converted `bash.timeoutMs` from milliseconds to `timeout` seconds.",
+      );
+    }
+  }
+
+  if (
+    toolName === "fabric_exec" &&
+    path.length === 0 &&
+    schemaRecord(properties.code)?.type === "string" &&
+    Array.isArray(input.code) &&
+    input.code.every((line) => typeof line === "string")
+  ) {
+    input.code = input.code.join("\n");
+    addRule(
+      rulesFired,
+      hints,
+      "joinStringArray",
+      "Joined the `fabric_exec.code` string array with newlines.",
+    );
+  }
+
+  for (const [key, propertySchema] of Object.entries(properties)) {
+    if (!Object.hasOwn(input, key)) continue;
+    const value = input[key];
+    const fieldPath = [...path, key].join(".");
+
+    if ((value === null || value === undefined) && !required.has(key)) {
+      delete input[key];
+      addRule(
+        rulesFired,
+        hints,
+        "dropNullOrUndefined",
+        `Dropped optional ${value === null ? "null" : "undefined"} \`${fieldPath}\` from tool "${toolName}".`,
+      );
+      continue;
+    }
+
+    if (
+      propertySchema.type === "number" &&
+      typeof value === "string" &&
+      value.trim() !== "" &&
+      Number.isFinite(Number(value))
+    ) {
+      input[key] = Number(value);
+      addRule(
+        rulesFired,
+        hints,
+        "coerceNumericString",
+        `Converted numeric string in ${fieldPath} for tool "${toolName}".`,
+      );
+      continue;
+    }
+
+    if (propertySchema.type === "array") {
+      if (isObject(value) && Object.keys(value).length === 0) {
+        delete input[key];
+        addRule(
+          rulesFired,
+          hints,
+          "dropEmptyObjectPlaceholder",
+          `Dropped empty object placeholder from array field \`${fieldPath}\` for tool "${toolName}".`,
+        );
+        continue;
+      }
+      if (typeof value === "string") {
+        const parsed = tryParseJsonArray(value);
+        input[key] = parsed ?? [value];
+        addRule(
+          rulesFired,
+          hints,
+          parsed ? "parseJsonStringifiedArray" : "wrapBareStringAsArray",
+          parsed
+            ? `Parsed JSON-stringified array in \`${fieldPath}\` for tool "${toolName}".`
+            : `Wrapped bare string in an array for \`${fieldPath}\` in tool "${toolName}".`,
+        );
+      }
+      const arrayValue = input[key];
+      const itemSchema = schemaRecord(propertySchema.items);
+      if (Array.isArray(arrayValue) && itemSchema) {
+        for (let index = 0; index < arrayValue.length; index++) {
+          const item = arrayValue[index];
+          if (isObject(item)) {
+            repairObjectFromSchema(
+              toolName,
+              itemSchema,
+              item,
+              rulesFired,
+              hints,
+              [...path, key, String(index)],
+            );
+          }
+        }
+      }
+      continue;
+    }
+
+    if (propertySchema.type === "object" && isObject(value)) {
+      repairObjectFromSchema(toolName, propertySchema, value, rulesFired, hints, [...path, key]);
+    }
+  }
+};
+
+export function repairInputAgainstLiveSchema(
+  toolName: string,
+  rawInput: unknown,
+  schema: import("typebox").TSchema,
+): LiveToolRepairOutcome {
+  const initial = schemaCheck(schema, rawInput);
+  if (initial === undefined) {
+    return { toolName, status: "unchanged", input: rawInput, rulesFired: [], hints: [] };
+  }
+
+  const wrapped = initial ? undefined : wrapRootStringAsObject(rawInput, toolName);
+  const candidate = wrapped ? wrapped.wrapped : deepClone(rawInput);
+  const rulesFired = wrapped ? ["wrapRootStringAsObject"] : [];
+  const hints = wrapped ? [wrapped.hint] : [];
+
+  const objectSchema = schemaRecord(schema);
+  if (isObject(candidate) && objectSchema) {
+    repairObjectFromSchema(toolName, objectSchema, candidate, rulesFired, hints);
+  }
+
+  if (rulesFired.length === 0) {
+    return {
+      toolName,
+      status: initial ? "unchanged" : "unrepairable",
+      input: rawInput,
+      rulesFired,
+      hints,
+    };
+  }
+
+  return schemaCheck(schema, candidate) === true
+    ? {
+        toolName,
+        status: "recovered",
+        input: rawInput,
+        repaired: candidate,
+        rulesFired,
+        hints,
+      }
+    : {
+        toolName,
+        status: "unrepairable",
+        input: rawInput,
+        repaired: candidate,
+        rulesFired,
+        hints,
+      };
+}
+
+export function repairAssistantToolCallInputs(
+  message: MinimalAssistantMessage,
+  tools: readonly LiveToolSchema[],
+): AssistantToolCallRepairResult {
+  if (message.role !== "assistant" || !Array.isArray(message.content)) {
+    return { changed: false, message, repairs: [] };
+  }
+
+  const schemas = new Map(tools.map((tool) => [tool.name, tool.parameters]));
+  const repairs: LiveToolRepairOutcome[] = [];
+  let changed = false;
+  const content = message.content.map((part) => {
+    if (!isObject(part) || part.type !== "toolCall" || typeof part.name !== "string") return part;
+    const schema = schemas.get(part.name);
+    if (!schema) return part;
+    const outcome = repairInputAgainstLiveSchema(part.name, part.arguments, schema);
+    if (outcome.status !== "unchanged") repairs.push(outcome);
+    if (outcome.status !== "recovered") return part;
+    changed = true;
+    return { ...part, arguments: outcome.repaired };
+  });
+
+  return changed
+    ? { changed: true, message: { ...message, content }, repairs }
+    : { changed: false, message, repairs };
+}
+
+// Logging
 
 export * from "./grammar-repair.js";
 

package/tool-repair.ts

@@ -1,42 +1,9 @@
 /**
  * Tool Input Repair Extension
  *
- * Validates and repairs common LLM tool-call mistakes before tools execute.
- * Handles the finite set of errors that open models make when calling tools,
- * as documented in the tool-parsing-insight.md analysis of Command Code.
- *
- * Repair pipeline:
- *   Phase 0: Schema poisoning (pre-request, model-specific)
- *     - Strip regex anchors from JSON Schema patterns for models where they
- *       leak into generated values (e.g., Kimi K2 anchor bleed)
- *
- *   Phase 1: Grammar leak repair (message_end hook, opt-in)
- *     - Strip leaked XML/sentinel tool-call grammars from assistant text/thinking
- *     - Recover complete, known-tool calls into pi toolCall blocks
- *
- *   Phase 1.5: Phantom toolUse normalization (message_end hook, always-on)
- *     - Detect stopReason: "toolUse" with zero toolCall blocks
- *     - Convert to a retryable error to trigger pi's auto-retry mechanism
- *     - Guards against vLLM streaming bugs where finish_reason: "tool_calls"
- *       is emitted without any delta.tool_calls chunks
- *
- *   Phase 2: Validate-then-repair (tool_call hook)
- *     - Validate input against the tool's schema
- *     - On failure, walk the validator's issue list and apply targeted repairs
- *     - Re-validate. Surface repair notes to the model.
- *
- * Repair rules (order matters!):
- *   1. wrapRootStringAsObject  — bare string where object expected
- *   2. renameAliasedField       — wrong field name → canonical name
- *   3. dropNullOrUndefined     — null/undefined for optional fields
- *   4. dropEmptyObjectPlaceholder — {} where array expected
- *   5. parseJsonStringifiedArray — '"[\"a\"]"' → ["a"]
- *   6. wrapBareStringAsArray    — "foo" → ["foo"]
- *
- * See tool-parsing-extraction.md for the full reverse-engineered analysis.
- *
- * Usage:
- *   pi -e /path/to/pi-tool-repair
+ * Repairs provider-level schema poisoning and malformed assistant tool calls
+ * before Pi validates them. Valid inputs pass through unchanged; attempted
+ * argument repairs are committed only when they satisfy the live tool schema.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -47,21 +14,15 @@ import {
   sanitizeSchemaAnchors,
   stripAnchorBleedInPlace,
   stripGrammarTokenLeaksInPlace,
-  wrapRootStringAsObject,
-  repairToolInput,
-  validateAgainstSchema,
   logRepair,
-  BUILTIN_SCHEMAS,
   loadGrammarRepairConfig,
   repairAssistantMessageGrammarLeaks,
+  resolveGrammarRepairForModel,
+  repairAssistantToolCallInputs,
   normalizePhantomToolUse,
   type MinimalAssistantMessage,
 } from "./src/index.js";
 
-// Safely access ctx.model without throwing on stale contexts.
-// After session replacement (newSession/fork/switchSession/reload), the
-// extension runner invalidates stale contexts and ctx.model throws.
-// When that happens, the request belongs to a dead session — bail out.
 function safeGetModel(ctx: { model?: any }): any | undefined {
   try {
     return ctx.model;
@@ -70,7 +31,6 @@ function safeGetModel(ctx: { model?: any }): any | undefined {
   }
 }
 
-// Safely call pi.getActiveTools() without throwing on stale contexts.
 function safeGetActiveTools(pi: ExtensionAPI): string[] {
   try {
     return pi.getActiveTools();
@@ -79,11 +39,37 @@ function safeGetActiveTools(pi: ExtensionAPI): string[] {
   }
 }
 
+function safeGetActiveToolSchemas(pi: ExtensionAPI) {
+  try {
+    const active = new Set(pi.getActiveTools());
+    return pi.getAllTools()
+      .filter((tool) => active.has(tool.name))
+      .map((tool) => ({ name: tool.name, parameters: tool.parameters }));
+  } catch {
+    return [];
+  }
+}
+
+const toolCallArguments = (message: MinimalAssistantMessage): Record<string, unknown>[] => {
+  if (!Array.isArray(message.content)) return [];
+  const argumentsList: Record<string, unknown>[] = [];
+  for (const part of message.content) {
+    if (
+      part && typeof part === "object" && !Array.isArray(part) &&
+      (part as Record<string, unknown>).type === "toolCall"
+    ) {
+      const args = (part as Record<string, unknown>).arguments;
+      if (args && typeof args === "object" && !Array.isArray(args)) {
+        argumentsList.push(args as Record<string, unknown>);
+      }
+    }
+  }
+  return argumentsList;
+};
+
 export default function (pi: ExtensionAPI) {
   const grammarRepairConfig = loadGrammarRepairConfig();
 
-  // Phase 0: Schema poisoning defense (before_provider_request)
-  // Strip regex anchors from JSON Schema patterns for models where they leak
   pi.on("before_provider_request", (event, ctx) => {
     const model = safeGetModel(ctx);
     if (!model || !hasAnchorBleedBug(model)) return;
@@ -92,7 +78,6 @@ export default function (pi: ExtensionAPI) {
     if (!payload || typeof payload !== "object") return;
 
     let modified = false;
-
     const tools = payload.tools;
     if (Array.isArray(tools)) {
       payload.tools = tools.map((tool: any) => {
@@ -116,192 +101,74 @@ export default function (pi: ExtensionAPI) {
       modified = true;
     }
 
-    if (modified) {
-      return payload;
-    }
+    if (modified) return payload;
   });
 
-  // Phase 1 + 1.5: Grammar leak repair + phantom toolUse normalization (message_end)
-  //
-  // Phase 1.5 (always-on): Detect stopReason: "toolUse" with zero toolCall blocks
-  // and convert to a retryable error (stopReason: "error"). This triggers pi's
-  // built-in auto-retry mechanism so the agent re-prompts automatically. This
-  // guards against vLLM streaming bugs where finish_reason: "tool_calls" is emitted
-  // without any delta.tool_calls chunks.
-  //
-  // Phase 1 (opt-in): Promote leaked XML/sentinel tool-call grammars from
-  // assistant text/thinking into pi toolCall blocks. Configured via
-  // ~/.pi/agent/extensions/pi-tool-repair.json.
-  pi.on("message_end", (event) => {
+  // Pi 0.84 prepares and validates tool arguments before `tool_call`, so raw
+  // argument recovery must happen on the finalized assistant message instead.
+  pi.on("message_end", (event, ctx) => {
     if (event.message.role !== "assistant") return;
 
-    const currentMessage = event.message as unknown as MinimalAssistantMessage;
+    let message = event.message as unknown as MinimalAssistantMessage;
+    let changed = false;
+    const model = safeGetModel(ctx);
 
-    // Phase 1.4: Strip leaked grammar tokens from existing pi toolCall blocks.
-    // These can leak from GLM-style grammars straight into the parsed argument
-    // keys (e.g. "<arg_key>command" instead of "command"). We have to repair
-    // them here, before pi preflights and validates the tool calls.
-    let toolCallArgsChanged = false;
-    if (Array.isArray(currentMessage.content)) {
-      for (const part of currentMessage.content) {
-        if (
-          part && typeof part === "object" && !Array.isArray(part) &&
-          (part as Record<string, unknown>).type === "toolCall"
-        ) {
-          const args = (part as Record<string, unknown>).arguments;
-          if (
-            args && typeof args === "object" && !Array.isArray(args) &&
-            stripGrammarTokenLeaksInPlace(args as Record<string, unknown>)
-          ) {
-            toolCallArgsChanged = true;
-          }
-        }
-      }
+    for (const args of toolCallArguments(message)) {
+      if (model && hasGrammarLeakBug(model) && stripGrammarTokenLeaksInPlace(args)) changed = true;
+      if (model && hasAnchorBleedBug(model) && stripAnchorBleedInPlace(args)) changed = true;
     }
 
-    // Phase 1.5: Phantom toolUse normalization (always-on)
-    const phantomResult = normalizePhantomToolUse(currentMessage);
-
-    if (phantomResult.changed) {
-      if (DEFAULT_CONFIG.debug) {
-        process.stderr.write(
-          `[pi-tool-repair] phantom-tooluse: converted stopReason from "toolUse" to retryable error (no toolCall blocks)\n`,
-        );
-      }
-
-      // If grammar repair is also enabled, run it on the normalized message so
-      // it can still recover leaked tool calls from the text content. If grammar
-      // repair recovers calls, it will set stopReason back to "toolUse".
-      if (grammarRepairConfig.enabled) {
-        const knownTools = new Set(
-          safeGetActiveTools(pi)
-            .filter((name): name is string => typeof name === "string" && name.length > 0),
-        );
-        const grammarResult = repairAssistantMessageGrammarLeaks(
-          phantomResult.message,
-          grammarRepairConfig,
-          knownTools,
-        );
-        if (grammarResult.changed) {
-          if (grammarRepairConfig.debug) {
-            const calls = grammarResult.recoveredCalls.map((call) => `${call.grammar}:${call.name}`).join(",") || "none";
-            process.stderr.write(
-              `[pi-tool-repair] grammar-repair mode=${grammarRepairConfig.mode} ` +
-              `stripped=${grammarResult.strippedRanges} recovered=${calls}\n`,
-            );
-          }
-          return { message: grammarResult.message as any };
+    const effectiveGrammarRepairConfig = resolveGrammarRepairForModel(grammarRepairConfig, model);
+    if (effectiveGrammarRepairConfig.enabled) {
+      const knownTools = new Set(
+        safeGetActiveTools(pi)
+          .filter((name): name is string => typeof name === "string" && name.length > 0),
+      );
+      const grammarResult = repairAssistantMessageGrammarLeaks(
+        message,
+        effectiveGrammarRepairConfig,
+        knownTools,
+      );
+      if (grammarResult.changed) {
+        message = grammarResult.message;
+        changed = true;
+        if (effectiveGrammarRepairConfig.debug) {
+          const calls = grammarResult.recoveredCalls
+            .map((call) => `${call.grammar}:${call.name}`)
+            .join(",") || "none";
+          process.stderr.write(
+            `[pi-tool-repair] grammar-repair mode=${effectiveGrammarRepairConfig.mode} ` +
+            `stripped=${grammarResult.strippedRanges} recovered=${calls}\n`,
+          );
         }
       }
-
-      return { message: phantomResult.message as any };
-    }
-
-    // Phase 1: Grammar leak repair (opt-in)
-    if (!grammarRepairConfig.enabled) {
-      if (toolCallArgsChanged) return { message: currentMessage as any };
-      return;
-    }
-
-    const knownTools = new Set(
-      safeGetActiveTools(pi)
-        .filter((name): name is string => typeof name === "string" && name.length > 0),
-    );
-
-    const result = repairAssistantMessageGrammarLeaks(
-      event.message as unknown as MinimalAssistantMessage,
-      grammarRepairConfig,
-      knownTools,
-    );
-
-    if (!result.changed && !toolCallArgsChanged) return;
-
-    if (grammarRepairConfig.debug && result.changed) {
-      const calls = result.recoveredCalls.map((call) => `${call.grammar}:${call.name}`).join(",") || "none";
-      process.stderr.write(
-        `[pi-tool-repair] grammar-repair mode=${grammarRepairConfig.mode} ` +
-        `stripped=${result.strippedRanges} recovered=${calls}\n`,
-      );
     }
 
-    return { message: result.message as any };
-  });
-
-  // Phase 2: Validate-then-repair (tool_call)
-  pi.on("tool_call", (event, ctx) => {
-    const toolName = event.toolName;
-    const input = (event as any).input;
-
-    const model = safeGetModel(ctx);
-
-    // Defense-in-depth: strip anchor-bleed from generated values
-    if (model && hasAnchorBleedBug(model)) {
-      if (input && typeof input === "object") {
-        stripAnchorBleedInPlace(input);
-      }
+    const inputResult = repairAssistantToolCallInputs(message, safeGetActiveToolSchemas(pi));
+    for (const repair of inputResult.repairs) {
+      logRepair(repair.toolName, repair.status === "recovered" ? "recovered" : "unrepairable", {
+        rulesFired: repair.rulesFired,
+        hints: repair.hints,
+        input: repair.input,
+        ...(repair.repaired !== undefined ? { repaired: repair.repaired } : {}),
+      });
     }
-
-    // Strip leaked grammar tokens (e.g. GLM <arg_key>) from parsed tool-call
-    // keys/values before the schema sees them. Only for models known to produce
-    // grammar token leaks.
-    if (input && typeof input === "object" && model && hasGrammarLeakBug(model)) {
-      stripGrammarTokenLeaksInPlace(input as Record<string, unknown>);
+    if (inputResult.changed) {
+      message = inputResult.message;
+      changed = true;
     }
 
-    // Only repair built-in tools we have schemas for
-    const schema = BUILTIN_SCHEMAS[toolName];
-    if (!schema) return;
-
-    if (!input || typeof input !== "object") {
-      // Root-level: might be a bare string
-      if (typeof input === "string") {
-        const wrapResult = wrapRootStringAsObject(input, toolName);
-        if (wrapResult !== undefined) {
-          (event as any).input = wrapResult.wrapped;
-          logRepair(toolName, "recovered", {
-            rulesFired: ["wrapRootStringAsObject"],
-            hints: [wrapResult.hint],
-            input,
-            repaired: wrapResult.wrapped,
-          });
-        }
+    const phantomResult = normalizePhantomToolUse(message);
+    if (phantomResult.changed) {
+      message = phantomResult.message;
+      changed = true;
+      if (DEFAULT_CONFIG.debug) {
+        process.stderr.write(
+          '[pi-tool-repair] phantom-tooluse: converted stopReason from "toolUse" to retryable error (no toolCall blocks)\n',
+        );
       }
-      return;
     }
 
-    // Validate as-is
-    const issues = validateAgainstSchema(input, schema);
-    if (issues.length === 0) return;
-
-    // Try repairs
-    const repairResult = repairToolInput(input, issues, toolName);
-    if (repairResult.rulesFired.length === 0) {
-      logRepair(toolName, "unrepairable", {
-        rulesFired: [],
-        hints: [],
-        input,
-      });
-      return;
-    }
-
-    // Re-validate repaired input
-    const repairedInput = repairResult.input as Record<string, unknown>;
-    const postRepairIssues = validateAgainstSchema(repairedInput, schema);
-    if (postRepairIssues.length === 0) {
-      (event as any).input = repairedInput;
-      logRepair(toolName, "recovered", {
-        rulesFired: repairResult.rulesFired,
-        hints: repairResult.hints,
-        input,
-        repaired: repairedInput,
-      });
-    } else {
-      logRepair(toolName, "unrepairable", {
-        rulesFired: repairResult.rulesFired,
-        hints: repairResult.hints,
-        input,
-        repaired: repairedInput,
-      });
-    }
+    return changed ? { message: message as any } : undefined;
   });
 }