fix(delete): coerce recursive at the boundary so a stringified "true" is honored

aft_delete rejected a directory ("is a directory. Pass recursive: true.") even
when the agent passed recursive: true, reproduced across multiple agents. Root
cause: the plugin read the flag with a strict `args.recursive === true`, but
hosts deliver a boolean-typed arg as the model's raw emitted value despite the
declared schema — and models non-deterministically emit `true` as the string
"true" (the same host behavior `coerceStringArray` already absorbs for `files`,
documented in coerce.ts). A stringified "true" then read as false and the flag
was silently dropped, so Rust correctly refused the directory.

Adds a shared `coerceBoolean` to @cortexkit/aft-bridge (true/"true"/1/"1" → true;
everything else → false, a deliberately tight truthy set so a destructive gate
can't be flipped by an arbitrary truthy value) and uses it for `recursive` in
both the OpenCode and Pi delete paths. Real booleans pass through unchanged
(hoisted-tools 62/0, fs 4/0). A follow-up sweeps the same strict-=== true class
on the other agent-facing boolean args (dryRun, replaceAll, background/pty,
files, callgraph).

Co-authored-by: Alfonso <289616620+alfonso-aft@users.noreply.github.com>

Author: ualtinok

packages/aft-bridge/src/__tests__/coerce.test.ts

@@ -1,5 +1,33 @@
 import { describe, expect, test } from "bun:test";
-import { coerceStringArray } from "../coerce.js";
+import { coerceBoolean, coerceStringArray } from "../coerce.js";
+
+describe("coerceBoolean", () => {
+  test("passes real booleans through", () => {
+    expect(coerceBoolean(true)).toBe(true);
+    expect(coerceBoolean(false)).toBe(false);
+  });
+
+  test("coerces the stringified booleans models emit (the recursive bug)", () => {
+    expect(coerceBoolean("true")).toBe(true);
+    expect(coerceBoolean("TRUE")).toBe(true);
+    expect(coerceBoolean("  true  ")).toBe(true);
+    expect(coerceBoolean("1")).toBe(true);
+    expect(coerceBoolean(1)).toBe(true);
+  });
+
+  test("treats everything else as false (tight truthy set for safety gates)", () => {
+    expect(coerceBoolean("false")).toBe(false);
+    expect(coerceBoolean("0")).toBe(false);
+    expect(coerceBoolean(0)).toBe(false);
+    expect(coerceBoolean(2)).toBe(false);
+    expect(coerceBoolean("yes")).toBe(false);
+    expect(coerceBoolean("")).toBe(false);
+    expect(coerceBoolean(undefined)).toBe(false);
+    expect(coerceBoolean(null)).toBe(false);
+    expect(coerceBoolean({})).toBe(false);
+    expect(coerceBoolean([])).toBe(false);
+  });
+});
 
 describe("coerceStringArray", () => {
   test("passes a real string array through, dropping empties + non-strings", () => {

packages/aft-bridge/src/coerce.ts

@@ -43,6 +43,35 @@ export function coerceStringArray(value: unknown): string[] {
   return [];
 }
 
+/**
+ * Coerce a tool argument that is contractually a boolean into a real boolean,
+ * tolerating the shapes models send in practice.
+ *
+ * Like array and integer params (see `coerceStringArray` / `coerceOptionalInt`),
+ * hosts deliver a boolean-typed param as the model's raw emitted value WITHOUT
+ * coercing it to the declared schema type — and models non-deterministically
+ * emit `true` as the string `"true"` (or `1` / `"1"`). A strict `args.x === true`
+ * check then reads a stringified `"true"` as false, silently dropping the flag.
+ * This bit `aft_delete`'s `recursive`: an agent passing `recursive: true` got
+ * "is a directory, pass recursive: true" because the wire value was `"true"`.
+ *
+ * Conservative by design: only values that UNAMBIGUOUSLY mean true coerce to
+ * true (`true`, case-insensitive `"true"`, `1`, `"1"`). Everything else —
+ * `false`, `"false"`, `0`, `""`, `null`, `undefined`, objects — is `false`. A
+ * false-negative just re-surfaces the original "pass the flag" error (safe); a
+ * false-positive on a destructive gate like `recursive` would not be, so the
+ * truthy set is kept tight rather than accepting arbitrary truthy values.
+ */
+export function coerceBoolean(value: unknown): boolean {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value === 1;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "1";
+  }
+  return false;
+}
+
 /**
  * Runtime coercion for agent-friendly sentinel handling.
  *

packages/aft-bridge/src/index.ts

@@ -44,7 +44,7 @@ export {
 // --- aft_callgraph flat formatter (shared by both plugin hosts) ---
 export type { CallgraphTheme } from "./callgraph-format.js";
 export { formatCallgraphSections, PLAIN_CALLGRAPH_THEME } from "./callgraph-format.js";
-export { coerceOptionalInt, coerceStringArray, isEmptyParam } from "./coerce.js";
+export { coerceBoolean, coerceOptionalInt, coerceStringArray, isEmptyParam } from "./coerce.js";
 export { LONG_RUNNING_COMMAND_TIMEOUT_MS, timeoutForCommand } from "./command-timeouts.js";
 // --- config tiers ---
 export type { ConfigTier } from "./config-tiers.js";

packages/opencode-plugin/src/tools/hoisted.ts

@@ -12,6 +12,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {
+  coerceBoolean,
   coerceStringArray,
   formatEditSummary,
   formatReadFooter as formatSharedReadFooter,
@@ -1683,7 +1684,11 @@ function createDeleteTool(ctx: PluginContext): ToolDefinition {
       if (inputs.length === 0) {
         throw new Error("delete: `files` must be a non-empty array of paths");
       }
-      const recursive = args.recursive === true;
+      // Coerce at the boundary: hosts deliver this boolean as the model's raw
+      // emitted value (e.g. the string "true") despite the declared schema, same
+      // as `files` above. A strict `=== true` then drops a stringified flag and
+      // an agent's `recursive: true` is silently lost (see coerceBoolean).
+      const recursive = coerceBoolean(args.recursive);
       const projectRoot = await resolveProjectRoot(ctx, context);
       const absolutePaths = inputs.map((f) => resolvePathFromProjectRoot(projectRoot, f));
 

packages/pi-plugin/src/tools/fs.ts

@@ -3,7 +3,7 @@
  * Both go through Rust so backups and checkpoint rollback work the same way.
  */
 
-import { coerceStringArray } from "@cortexkit/aft-bridge";
+import { coerceBoolean, coerceStringArray } from "@cortexkit/aft-bridge";
 import type { AgentToolResult, ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import type { PluginContext } from "../types.js";
@@ -158,7 +158,9 @@ export function registerFsTools(pi: ExtensionAPI, ctx: PluginContext, surface: F
           "delete_file",
           {
             files,
-            recursive: params.recursive === true,
+            // Coerce at the boundary, like `files`: a stringified "true" from the
+            // model must not silently drop the flag (see coerceBoolean).
+            recursive: coerceBoolean(params.recursive),
           },
           extCtx,
         );