@@ -42,40 +42,114 @@ const ENGINE_TO_WIRE_BY_PROFILE: Record<
   gpt: { ...DEFAULT_ENGINE_TO_WIRE, ...GPT_OVERRIDES },
 };
 
-/** Registry engines the gpt profile folds into apply_patch, in advertise order. */
-export const GPT_PATCH_ENGINES = [
-  "write_file",
-  "edit_file",
-  "delete_file",
-] as const;
+/**
+ * Engines one advertised wire replaces. A profile without an entry keeps
+ * the 1:1 wire table. Adding a family is a new ToolProfile plus a row here
+ * and in ENGINE_TO_WIRE_BY_PROFILE — not a new director package.
+ */
+const PROFILE_FOLDS: Record<
+  ToolProfile,
+  { wire: string; engines: readonly string[] } | undefined
+> = {
+  default: undefined,
+  gpt: {
+    wire: "apply_patch",
+    engines: ["write_file", "edit_file", "delete_file"],
+  },
+};
+
+function buildAdvertisedWireEngines(
+  profile: ToolProfile,
+): ReadonlyMap<string, readonly string[]> {
+  const fold = PROFILE_FOLDS[profile];
+  const folded = new Set(fold?.engines ?? []);
+  const map = new Map<string, string[]>();
+  for (const [engine, wire] of Object.entries(
+    ENGINE_TO_WIRE_BY_PROFILE[profile],
+  )) {
+    if (folded.has(engine)) continue;
+    const existing = map.get(wire);
+    if (existing === undefined) map.set(wire, [engine]);
+    else existing.push(engine);
+  }
+  if (fold !== undefined) map.set(fold.wire, [...fold.engines]);
+  return map;
+}
+
+const ADVERTISED_WIRE_ENGINES = Object.fromEntries(
+  (Object.keys(ENGINE_TO_WIRE_BY_PROFILE) as ToolProfile[]).map((profile) => [
+    profile,
+    buildAdvertisedWireEngines(profile),
+  ]),
+) as Record<ToolProfile, ReadonlyMap<string, readonly string[]>>;
+
+export function toolProfiles(): readonly ToolProfile[] {
+  return Object.keys(ENGINE_TO_WIRE_BY_PROFILE) as ToolProfile[];
+}
+
+/** Wire name → engine ids this profile advertises. Folded wires map to every engine they replace. */
+export function advertisedWireEngines(
+  profile: ToolProfile,
+): ReadonlyMap<string, readonly string[]> {
+  return ADVERTISED_WIRE_ENGINES[profile];
+}
+
+/**
+ * Engines `wire` stands for on `profile`. Undefined when this profile does
+ * not advertise that name (a later family follows the same table).
+ */
+export function enginesForAdvertisedWire(
+  wire: string,
+  profile: ToolProfile,
+): readonly string[] | undefined {
+  const table = ADVERTISED_WIRE_ENGINES[profile];
+  return table.get(wire) ?? table.get(wire.toLowerCase());
+}
 
-/** Tools the gpt profile folds into the single apply_patch envelope tool. */
-const PATCH_FOLDED_ENGINES: ReadonlySet<string> = new Set(GPT_PATCH_ENGINES);
+/** Every wire any profile advertises for `engine`, including fold wires. */
+export function advertisedNamesForEngine(engine: string): readonly string[] {
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (const profile of toolProfiles()) {
+    const fold = PROFILE_FOLDS[profile];
+    const wire =
+      fold !== undefined && fold.engines.includes(engine)
+        ? fold.wire
+        : advertisedToolName(engine, profile);
+    if (seen.has(wire)) continue;
+    seen.add(wire);
+    names.push(wire);
+  }
+  return names;
+}
 
 /** gpt models are trained on apply_patch, not write/edit/delete. Other
- * profiles and lists without a file-mutation tool pass through unchanged. */
+ * profiles and lists without a folded tool pass through unchanged. */
 export function foldFileToolNames(
   names: readonly string[],
   profile: ToolProfile,
 ): readonly string[] {
-  if (profile !== "gpt") return names;
+  const fold = PROFILE_FOLDS[profile];
+  if (fold === undefined) return names;
   const folded = (name: string): boolean =>
-    PATCH_FOLDED_ENGINES.has(engineToolName(name));
+    fold.engines.includes(engineToolName(name));
   if (!names.some(folded)) return names;
   const first = names.findIndex(folded);
   return names.flatMap((name, i) =>
-    i === first ? ["apply_patch"] : folded(name) ? [] : [name],
+    i === first ? [fold.wire] : folded(name) ? [] : [name],
   );
 }
 
 export function foldFileToolDefinitions(
   defs: readonly ToolDefinition[],
   profile: ToolProfile,
 ): ToolDefinition[] {
-  if (profile !== "gpt" || !defs.some((d) => d.name === "apply_patch")) {
+  const fold = PROFILE_FOLDS[profile];
+  if (fold === undefined || !defs.some((d) => d.name === fold.wire)) {
     return [...defs];
   }
-  return defs.filter((d) => !PATCH_FOLDED_ENGINES.has(engineToolName(d.name)));
+  const folded = new Set(fold.engines);
+  return defs.filter((d) => !folded.has(engineToolName(d.name)));
 }
 
 export function toolProfileForFamily(family: ModelFamily): ToolProfile {
 
@@ -29,6 +29,7 @@ import {
   ORCHESTRATOR_TOOLS,
   READ_TOOLS,
 } from "./directors/tool-sets.js";
+import { advertisedWireEngines, toolProfiles } from "./tool-aliases.js";
 
 const FULL_AVAILABILITY: ToolAvailability = {
   languageServerAvailable: true,
@@ -1050,6 +1051,25 @@ describe("advertisedToolNamesForWorker", () => {
     expect(build).not.toContain("write_file");
   });
 
+  test("every non-default profile projects allowlisted engines through its wire table", () => {
+    const allow = BUILD_TOOLS as readonly string[];
+    for (const profile of toolProfiles()) {
+      const names = advertisedToolNamesForWorker({
+        allow: BUILD_TOOLS,
+        profile,
+      });
+      if (profile === "default") {
+        expect(names).toContain("write_file");
+        expect(names).not.toContain("apply_patch");
+        continue;
+      }
+      for (const [wire, engines] of advertisedWireEngines(profile)) {
+        if (!engines.some((engine) => allow.includes(engine))) continue;
+        expect(names, `${profile} ${wire}`).toContain(wire);
+      }
+    }
+  });
+
   test("nested orchestrator allowlist adds fleet verbs but not search_agents", () => {
     const orch = advertisedToolNamesForWorker({ allow: ORCHESTRATOR_TOOLS });
     expect(orch).toContain("spawn_agent");
 
@@ -12,9 +12,9 @@ import {
 import type { SessionMode } from "../config/session-mode.js";
 import { sessionModeEnablesSubAgents } from "../config/session-mode.js";
 import {
+  advertisedNamesForEngine,
   advertisedToolName,
   foldFileToolNames,
-  GPT_PATCH_ENGINES,
   projectToolDefinition,
   type ToolProfile,
 } from "./tool-aliases.js";
@@ -139,10 +139,10 @@ export function advertisedToolNamesForWorker(opts: {
     seen.add(name);
     out.push(name);
   }
-  if (opts.profile !== "gpt") return out;
+  if (opts.profile === undefined || opts.profile === "default") return out;
   return foldFileToolNames(
-    out.map((name) => advertisedToolName(name, "gpt")),
-    "gpt",
+    out.map((name) => advertisedToolName(name, opts.profile)),
+    opts.profile,
   );
 }
 
@@ -177,19 +177,11 @@ function isAlreadyAdvertised(
   advertisedNames: readonly string[],
 ): boolean {
   const engine = canonicalToolName(defName);
-  if (
-    advertisedNames.includes(defName) ||
-    advertisedNames.includes(engine) ||
-    advertisedNames.includes(advertisedToolName(engine)) ||
-    advertisedNames.includes(advertisedToolName(engine, "gpt"))
-  ) {
+  if (advertisedNames.includes(defName) || advertisedNames.includes(engine)) {
     return true;
   }
-  // apply_patch stands in for the file engines; a gpt prefix lists the wire
-  // name only, so search must not offer write/edit/delete beside it.
-  return (
-    advertisedNames.includes("apply_patch") &&
-    (GPT_PATCH_ENGINES as readonly string[]).includes(engine)
+  return advertisedNamesForEngine(engine).some((name) =>
+    advertisedNames.includes(name),
   );
 }
 
 
@@ -10,7 +10,12 @@ import {
   type CapabilityUnavailable,
 } from "./capability-preflight.js";
 import type { CapabilityFilter } from "../agent/profile-types.js";
-import { DOCS_TOOLS, READ_TOOLS } from "../agent/directors/tool-sets.js";
+import {
+  BUILD_TOOLS,
+  DOCS_TOOLS,
+  READ_TOOLS,
+} from "../agent/directors/tool-sets.js";
+import { advertisedWireEngines, toolProfiles } from "../agent/tool-aliases.js";
 
 const ALLOW_SHELL: CapabilityFilter = {
   mode: "allow",
@@ -255,6 +260,55 @@ describe("preflightCapabilities", () => {
     expect(result.unavailable.tool).toBe("apply_patch");
   });
 
+  test("gpt wire names pass when the worker has the underlying engines", () => {
+    const resolvedFilter: CapabilityFilter = {
+      mode: "allow",
+      tools: [...BUILD_TOOLS],
+    };
+    const cases = [
+      {
+        wire: "apply_patch",
+        canonical: ["write_file", "edit_file", "delete_file"],
+      },
+      { wire: "shell", canonical: ["run_shell"] },
+      { wire: "update_plan", canonical: ["manage_tasks"] },
+    ];
+    for (const entry of cases) {
+      expect(
+        preflightCapabilities({
+          required: [entry.wire],
+          resolvedFilter,
+          knownEngines: DEFAULT_KNOWN_ENGINES,
+          agentLabel: "coder",
+          toolProfile: "gpt",
+        }),
+        entry.wire,
+      ).toEqual({ ok: true, canonical: entry.canonical });
+    }
+  });
+
+  test("every profile accepts its advertised wires when those engines are allowed", () => {
+    const known = new Set(DEFAULT_KNOWN_ENGINES);
+    const tools = [...BUILD_TOOLS, "manage_tasks", "wait_agents"];
+    for (const profile of toolProfiles()) {
+      for (const [wire, mapped] of advertisedWireEngines(profile)) {
+        if (!mapped.every((engine) => known.has(engine))) continue;
+        const result = preflightCapabilities({
+          required: [wire],
+          resolvedFilter: { mode: "allow", tools },
+          knownEngines: DEFAULT_KNOWN_ENGINES,
+          agentLabel: "coder",
+          toolProfile: profile,
+        });
+        expect(result.ok, `${profile} ${wire}`).toBe(true);
+        if (!result.ok) continue;
+        for (const engine of result.canonical) {
+          expect(mapped, `${profile} ${wire}`).toContain(engine);
+        }
+      }
+    }
+  });
+
   test("gpt apply_patch maps onto only the file engines the allowlist has", () => {
     const result = preflightCapabilities({
       required: ["apply_patch"],