Proxy Codex apply_patch onto Corbits file tools

Why: Codex-trained models call apply_patch from pinned instructions, but
Corbits only advertised write_file/edit_file/delete_file. That dialect
mismatch hurts Codex evals versus Codex-native harnesses.

What changed: Codex-only apply_patch proxy (parse envelope, forward through
posix write/edit/delete), shared product-mutation ownership, primary deny
unchanged, IMPLEMENT/DOCS allowlists, docs leaves refuse Delete/Move via
allowDelete. Bridge text left for the next stacked change.

Test plan: bun test on codex-apply-patch, codex-tool-proxies,
codex-tool-mount, product-mutation-tools, tool-sets; bun run typecheck.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -159,6 +159,8 @@ Sixteen packages under `src/agent/directors/<id>/` register in `DIRECTOR_REGISTR
 3. Nested spawn: packages with `spawn.allowlist` forward that list into nested `task` (`spawnAllowlist` on nestedDispatch). Off-list `agent` is refused. `task(agent=skywalker)` is refused (primary is not a spawned worker). Primary omits the list so plugin profiles stay reachable.
 4. `directorProfiles()` is the spawn catalog (`default-agents.ts`) — closed set minus skywalker; plugin agent profiles still load and can override by id.
 5. Primary chat role is Skywalker: `buildChatRole()` → `createSkywalkerSystemPrompt()`. Product mutation tools are stripped from the primary toolset and from CORE/CATALOG ads (`PRIMARY_DENIED_PRODUCT_TOOLS`) — never-implement is structural for path tools. Residual: `run_shell` stays on primary; MCP tools loaded later are not re-stripped by that deny list; optional `writePaths` (when a profile sets it) only gate path-keyed product tools.
+
+   **Codex `apply_patch` proxy.** When the active provider is Codex (`isCodexProviderName`), `createAgentToolset` and `runSubAgent` mount an `apply_patch` stringTool from `createCodexToolProxies` that parses the Codex envelope and forwards each op through the posix `ToolRunner` (`write_file` / `delete_file` / `read_file`) so permission plugins still apply. Primary still denies `apply_patch` via `PRIMARY_DENIED_PRODUCT_TOOLS`; implement and docs leaf allowlists (`IMPLEMENT_TOOLS` / `DOCS_TOOLS`) include it so Codex workers keep the proxy after the capability filter. `CORE_TOOL_NAMES` does not list it.
 6. Shipped directors omit `writePaths`. The optional field is still enforced in the permission gate via ALS identity (`identity-context.ts` + `write-path-policy.ts`) when a plugin/custom profile sets it.
 7. Spawn effort: pin > package `modelRole` default (`defaultEffortForDirector`; intern=low; plan/review/orchestrator=high; implement/explore/docs/test=medium) > orchestrator/worker binary > parent inheritance. Optional skills are listed in the identity header for awareness; workers do not mount `use_skill` (guidance is baked into package system prompts). Primary mounts `use_skill` for its own skill list.
 

src/agent/codex-apply-patch.test.ts

@@ -0,0 +1,306 @@
+import { describe, expect, test } from "bun:test";
+import {
+  CodexApplyPatchError,
+  applyUpdateHunks,
+  extractAffectedPaths,
+  parseCodexApplyPatch,
+} from "./codex-apply-patch.js";
+
+describe("parseCodexApplyPatch", () => {
+  test("parses Add File with Codex trailing newlines", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Add File: hello.txt
++Hello world
++second line
+*** End Patch
+`);
+    expect(patch.ops).toEqual([
+      {
+        type: "add",
+        path: "hello.txt",
+        content: "Hello world\nsecond line\n",
+      },
+    ]);
+  });
+
+  test("Add File with no + lines yields empty content", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Add File: empty.txt
+*** End Patch
+`);
+    expect(patch.ops).toEqual([{ type: "add", path: "empty.txt", content: "" }]);
+  });
+
+  test("parses Delete File", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Delete File: obsolete.txt
+*** End Patch
+`);
+    expect(patch.ops).toEqual([{ type: "delete", path: "obsolete.txt" }]);
+  });
+
+  test("parses Update File with Move to", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** End Patch
+`);
+    expect(patch.ops).toHaveLength(1);
+    const op = patch.ops[0]!;
+    expect(op.type).toBe("update");
+    if (op.type !== "update") throw new Error("unreachable");
+    expect(op.path).toBe("src/app.py");
+    expect(op.moveTo).toBe("src/main.py");
+    expect(op.hunks).toHaveLength(1);
+    expect(op.hunks[0]!.header).toBe("def greet():");
+    expect(op.hunks[0]!.lines).toEqual([
+      { kind: "-", text: 'print("Hi")' },
+      { kind: "+", text: 'print("Hello, world!")' },
+    ]);
+  });
+
+  test("parses stacked multi-@@ context anchors as header-only then change hunk", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+@@ class BaseClass
+@@     def method():
+-old_line
++new_line
+*** End Patch
+`);
+    const op = patch.ops[0]!;
+    expect(op.type).toBe("update");
+    if (op.type !== "update") throw new Error("unreachable");
+    expect(op.hunks).toHaveLength(2);
+    expect(op.hunks[0]).toEqual({ header: "class BaseClass", lines: [] });
+    expect(op.hunks[1]!.header).toBe("    def method():");
+    expect(op.hunks[1]!.lines).toEqual([
+      { kind: "-", text: "old_line" },
+      { kind: "+", text: "new_line" },
+    ]);
+  });
+
+  test("rejects bare empty @@ without lines", () => {
+    expect(() =>
+      parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+@@
+*** End Patch
+`),
+    ).toThrow(/empty hunk/);
+  });
+
+  test("rejects malformed envelope (missing Begin)", () => {
+    expect(() =>
+      parseCodexApplyPatch(`*** Add File: a.txt
++hi
+*** End Patch
+`),
+    ).toThrow(CodexApplyPatchError);
+    expect(() =>
+      parseCodexApplyPatch(`*** Add File: a.txt
++hi
+*** End Patch
+`),
+    ).toThrow(/Begin Patch/);
+  });
+
+  test("rejects malformed envelope (missing End)", () => {
+    expect(() =>
+      parseCodexApplyPatch(`*** Begin Patch
+*** Add File: a.txt
++hi
+`),
+    ).toThrow(/End Patch/);
+  });
+
+  test("rejects absolute paths", () => {
+    expect(() =>
+      parseCodexApplyPatch(`*** Begin Patch
+*** Add File: /etc/passwd
++x
+*** End Patch
+`),
+    ).toThrow(/relative/);
+
+    expect(() =>
+      parseCodexApplyPatch(`*** Begin Patch
+*** Delete File: /tmp/x
+*** End Patch
+`),
+    ).toThrow(/absolute/);
+
+    expect(() =>
+      parseCodexApplyPatch(`*** Begin Patch
+*** Update File: C:\\Windows\\system32\\x
+@@
+-a
++b
+*** End Patch
+`),
+    ).toThrow(/absolute/);
+  });
+});
+
+describe("extractAffectedPaths", () => {
+  test("multi-file path extraction", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Add File: hello.txt
++Hello
+*** Update File: src/app.py
+@@
+-old
++new
+*** Delete File: obsolete.txt
+*** End Patch
+`);
+    expect(extractAffectedPaths(patch)).toEqual([
+      "hello.txt",
+      "src/app.py",
+      "obsolete.txt",
+    ]);
+  });
+
+  test("move path extraction includes source and destination", () => {
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@
+-a
++b
+*** End Patch
+`);
+    expect(extractAffectedPaths(patch)).toEqual(["src/app.py", "src/main.py"]);
+  });
+});
+
+describe("applyUpdateHunks", () => {
+  test("applies a simple replacement hunk", () => {
+    const original = `def greet():
+print("Hi")
+print("bye")
+`;
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** End Patch
+`);
+    const op = patch.ops[0]!;
+    expect(op.type).toBe("update");
+    if (op.type !== "update") throw new Error("unreachable");
+    const updated = applyUpdateHunks(original, op.hunks);
+    expect(updated).toBe(`def greet():
+print("Hello, world!")
+print("bye")
+`);
+  });
+
+  test("applies stacked multi-@@ anchors then replacement", () => {
+    const original = `class BaseClass
+    def method():
+        old_line
+        keep
+`;
+    const patch = parseCodexApplyPatch(`*** Begin Patch
+*** Update File: src/app.py
+@@ class BaseClass
+@@     def method():
+-        old_line
++        new_line
+*** End Patch
+`);
+    const op = patch.ops[0]!;
+    expect(op.type).toBe("update");
+    if (op.type !== "update") throw new Error("unreachable");
+    expect(applyUpdateHunks(original, op.hunks)).toBe(`class BaseClass
+    def method():
+        new_line
+        keep
+`);
+  });
+
+  test("applies context-aware multi-line hunk", () => {
+    const original = `line1
+line2
+target
+line4
+`;
+    const hunks = [
+      {
+        lines: [
+          { kind: " " as const, text: "line2" },
+          { kind: "-" as const, text: "target" },
+          { kind: "+" as const, text: "replaced" },
+          { kind: " " as const, text: "line4" },
+        ],
+      },
+    ];
+    expect(applyUpdateHunks(original, hunks)).toBe(`line1
+line2
+replaced
+line4
+`);
+  });
+
+  test("fuzzy match: rstrip then trim after exact fail", () => {
+    const original = `foo
+bar  
+baz
+`;
+    const updated = applyUpdateHunks(original, [
+      {
+        lines: [
+          { kind: "-", text: "bar" },
+          { kind: "+", text: "qux" },
+        ],
+      },
+    ]);
+    expect(updated).toBe(`foo
+qux
+baz
+`);
+
+    const padded = applyUpdateHunks(`  foo  \nbar\n`, [
+      {
+        lines: [
+          { kind: "-", text: "foo" },
+          { kind: "+", text: "FOO" },
+        ],
+      },
+    ]);
+    expect(padded).toBe(`FOO
+bar
+`);
+  });
+
+  test("NormalizeToLf: non-empty update result ends with newline", () => {
+    const updated = applyUpdateHunks("a\nb", [
+      {
+        lines: [
+          { kind: "-", text: "b" },
+          { kind: "+", text: "c" },
+        ],
+      },
+    ]);
+    expect(updated).toBe("a\nc\n");
+    expect(updated.endsWith("\n")).toBe(true);
+  });
+
+  test("throws when context cannot be found", () => {
+    expect(() =>
+      applyUpdateHunks("a\nb\n", [
+        {
+          lines: [
+            { kind: "-", text: "missing" },
+            { kind: "+", text: "x" },
+          ],
+        },
+      ]),
+    ).toThrow(/failed to find expected lines/);
+  });
+});