feat(agent): streamline prompts, merge skill search, and replace shell_collect

- Rephrase primary chat prompt as a structured card (~140 words covering
  Role, Route, Rules, and Spawn) and compact worker contract to ~150 words.
- Rewrite neckbeard and bruckheimer director bodies to under 600 words;
  drop verbose harness guidelines, duplicates, and redundant recovery text.
- Remove shell_collect tool in favor of bash stop=<shell_id> cancellation
  and later-turn completion delivery.
- Merge skill search into tool_search as a dedicated Skills block, removing
  the separate skill_search tool from primary sessions.

Author: TheGreatAxios

src/agent/agent-search.ts

@@ -112,19 +112,17 @@ export function formatAgentSearchResults(
 export const searchAgentsDefinition: ToolDefinition = {
   name: "search_agents",
   description:
-    "Find spawnable agent profiles by capability, role, or team name (e.g. 'review', 'review team', 'architect', 'security'). Returns profile ids, descriptions, and spawn metadata (orchestrator flag, source). Pass include_body=true to include the loaded system prompt / body for each match (truncated). Use the id in spawn_agent(agent=...). Call this when the user asks to spin up specialists or a team without naming exact ids.",
+    "Find spawnable agent profiles by role or capability. Returns ids for spawn_agent(agent=...).",
   inputSchema: {
     type: "object",
     properties: {
       query: {
         type: "string",
-        description:
-          "What kind of agent or team you need — keywords from the user's request (e.g. 'review team', 'code quality', 'explore codebase').",
+        description: "Role or capability.",
       },
       include_body: {
         type: "boolean",
-        description:
-          "When true, include each match's loaded system prompt / body (truncated). Default false: id, description, and spawn metadata only.",
+        description: "Include profile body.",
       },
     },
     required: ["query"],

src/agent/background-shell-tool.test.ts

@@ -51,37 +51,10 @@ describe("background shell through the agent toolset", () => {
       const parsed = JSON.parse(String(started.content)) as {
         shell_id: string;
       };
-      const snapshotNow = await toolset.dynamicRunner.run(
-        {
-          id: "bg-collect",
-          name: "shell_collect",
-          arguments: { shell_id: parsed.shell_id, action: "collect" },
-        },
-        new AbortController().signal,
-      );
-      expect(JSON.parse(String(snapshotNow.content))).toMatchObject({
-        status: "running",
-      });
-      const final = await toolset.dynamicRunner.run(
-        {
-          id: "bg-collect2",
-          name: "shell_collect",
-          arguments: {
-            shell_id: parsed.shell_id,
-            action: "collect",
-            wait_ms: 5_000,
-          },
-        },
-        new AbortController().signal,
-      );
-      const result = JSON.parse(String(final.content)) as {
-        status: string;
-        exit_code: number;
-        output: string;
-      };
-      expect(result).toMatchObject({ status: "completed", exit_code: 0 });
-      expect(result.output).toContain("bg-done");
-      await new Promise((r) => setTimeout(r, 50));
+      const deadline = Date.now() + 5_000;
+      while (exits.length === 0 && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 25));
+      }
       expect(exits).toHaveLength(1);
       expect(defined(exits[0]).id).toBe(parsed.shell_id);
       const message = buildShellBackgroundMessage(defined(exits[0]));
@@ -97,7 +70,7 @@ describe("background shell through the agent toolset", () => {
     }
   });
 
-  test("shell_collect cancel kills the session's own child process group", async () => {
+  test("run_shell stop kills the session's own child process group", async () => {
     const token = `ic_toolset_cancel_${randomUUID()}`;
     const toolset = await createAgentToolset({
       cwd: process.cwd(),
@@ -119,15 +92,11 @@ describe("background shell through the agent toolset", () => {
       const { shell_id } = JSON.parse(String(started.content)) as {
         shell_id: string;
       };
-      const cancelled = await toolset.dynamicRunner.run(
-        {
-          id: "c-cancel",
-          name: "shell_collect",
-          arguments: { shell_id, action: "cancel" },
-        },
+      const stopped = await toolset.dynamicRunner.run(
+        { id: "c-stop", name: "run_shell", arguments: { stop: shell_id } },
         new AbortController().signal,
       );
-      expect(JSON.parse(String(cancelled.content))).toMatchObject({
+      expect(JSON.parse(String(stopped.content))).toMatchObject({
         status: "cancelling",
       });
       await waitUntilGone(token);
@@ -136,76 +105,18 @@ describe("background shell through the agent toolset", () => {
     }
   });
 
-  test("shell_collect with an aborted signal releases as running without killing the child", async () => {
+  test("run_shell stop on an unknown id is an error", async () => {
     const toolset = await createAgentToolset({
       cwd: process.cwd(),
       permissionGate: gate(process.cwd()),
+      onOperatorGate: async () => ({ kind: "cancel" as const }),
     });
     try {
-      const started = await toolset.dynamicRunner.run(
-        {
-          id: "a-start",
-          name: "run_shell",
-          arguments: {
-            command: "sleep 60",
-            background: true,
-          },
-        },
-        new AbortController().signal,
-      );
-      const { shell_id } = JSON.parse(String(started.content)) as {
-        shell_id: string;
-      };
-      const aborted = new AbortController();
-      aborted.abort(new Error("interrupted by interrupt_agent"));
       const out = await toolset.dynamicRunner.run(
-        {
-          id: "a-collect",
-          name: "shell_collect",
-          arguments: { shell_id, action: "collect", wait_ms: 60_000 },
-        },
-        aborted.signal,
-      );
-      expect(JSON.parse(String(out.content))).toMatchObject({
-        status: "running",
-      });
-      // A live-signal collect still sees the child running: the abort above
-      // released the waiter instead of killing the process. Had the abort
-      // killed it, this would already report completed.
-      const stillThere = await toolset.dynamicRunner.run(
-        {
-          id: "a-collect2",
-          name: "shell_collect",
-          arguments: { shell_id, action: "collect" },
-        },
-        new AbortController().signal,
-      );
-      expect(JSON.parse(String(stillThere.content))).toMatchObject({
-        status: "running",
-      });
-      // And the child is still killable: cancel settles it as completed.
-      const cancelled = await toolset.dynamicRunner.run(
-        {
-          id: "a-cancel",
-          name: "shell_collect",
-          arguments: { shell_id, action: "cancel" },
-        },
+        { id: "u-stop", name: "run_shell", arguments: { stop: "nope" } },
         new AbortController().signal,
       );
-      expect(JSON.parse(String(cancelled.content))).toMatchObject({
-        status: "cancelling",
-      });
-      const final = await toolset.dynamicRunner.run(
-        {
-          id: "a-collect3",
-          name: "shell_collect",
-          arguments: { shell_id, action: "collect", wait_ms: 5_000 },
-        },
-        new AbortController().signal,
-      );
-      expect(JSON.parse(String(final.content))).toMatchObject({
-        status: "completed",
-      });
+      expect(out.isError).toBe(true);
     } finally {
       await toolset.dispose();
     }

src/agent/background-shell-tool.ts

@@ -1,55 +1,6 @@
-import { type } from "arktype";
-import type { ToolDefinition } from "@intx/types/runtime";
-import {
-  createBackgroundShellRegistry,
-  MAX_SHELL_COLLECT_WAIT_MS,
-  type BackgroundShellExit,
-  type BackgroundShellRegistry,
-} from "../shell/background-shell.js";
+import { type BackgroundShellExit } from "../shell/background-shell.js";
 import type { SpillBlobWriter } from "../plugins/result-truncation-plugin.js";
 
-const ShellCollectArgs = type({
-  shell_id: "string>0",
-  action: "'collect' | 'cancel'",
-  "wait_ms?": "number",
-});
-type ShellCollectArgs = typeof ShellCollectArgs.infer;
-
-export const shellCollectDefinition: ToolDefinition = {
-  name: "shell_collect",
-  description:
-    "Collect or cancel a background run_shell (started with background: true). " +
-    'action="collect" returns the result once finished (or status running); ' +
-    'action="cancel" kills the process group. Completion also arrives as a ' +
-    "system message on a later turn — collect is for polling or retrieving " +
-    'output again after eviction risk. A "running" result is liveness, not a ' +
-    "stall or a crash: repeated identical collects of a still-running shell " +
-    "are exempt from the run's doom-loop guard, so keep polling rather than " +
-    "treating it as a failure.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      shell_id: {
-        type: "string",
-        description: "shell_id from the background run_shell start.",
-      },
-      action: {
-        type: "string",
-        enum: ["collect", "cancel"],
-        description:
-          '"collect" retrieves status/output; "cancel" kills the process group.',
-      },
-      wait_ms: {
-        type: "number",
-        description:
-          'For action="collect": milliseconds to wait for completion before returning "running" (default 0, non-blocking, capped at ' +
-          `${MAX_SHELL_COLLECT_WAIT_MS}).`,
-      },
-    },
-    required: ["shell_id", "action"],
-  },
-};
-
 export function createSpillingBackgroundShellExitNotifier(args: {
   getBlobWriter?: () => SpillBlobWriter | undefined;
   notify: (exit: BackgroundShellExit) => void;
@@ -75,51 +26,3 @@ export function createSpillingBackgroundShellExitNotifier(args: {
     })();
   };
 }
-
-export function createShellCollectTool(
-  registry: BackgroundShellRegistry = createBackgroundShellRegistry(),
-) {
-  return {
-    definition: shellCollectDefinition,
-    handler: async (
-      rawArgs: Record<string, unknown>,
-      signal?: AbortSignal,
-    ): Promise<string> => {
-      const parsed = ShellCollectArgs(rawArgs);
-      if (parsed instanceof type.errors) {
-        return "Error: shell_collect requires shell_id (string) and action ('collect' | 'cancel').";
-      }
-      const { shell_id, action } = parsed;
-      if (action === "cancel") {
-        if (!registry.cancel(shell_id)) {
-          return `No running background shell with id ${shell_id}; it may have already finished or been collected.`;
-        }
-        return JSON.stringify({ shell_id, status: "cancelling" });
-      }
-      const snapshot = await registry.collect(
-        shell_id,
-        parsed.wait_ms ?? 0,
-        signal,
-      );
-      if (snapshot.state === "running") {
-        return JSON.stringify({ shell_id, status: "running" });
-      }
-      if (snapshot.state === "not-found") {
-        return (
-          `No background shell with id ${shell_id}. It may have been evicted from the ` +
-          "completed ring; if its output was truncated, the completion message carried " +
-          "a tool-output:/// URI for the full output."
-        );
-      }
-      const { exit } = snapshot;
-      return JSON.stringify({
-        shell_id,
-        status: "completed",
-        exit_code: exit.exitCode,
-        timed_out: exit.timedOut,
-        ...(exit.spillUri !== undefined ? { output_uri: exit.spillUri } : {}),
-        output: exit.output,
-      });
-    },
-  };
-}

src/agent/codex-tool-mount.test.ts

@@ -2,14 +2,19 @@
  * Mount coverage for Codex: no advertised apply_patch/shell/update_plan,
  * engines stay posix-named, hidden aliases dispatch without dual-publish.
  */
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, test, spyOn } from "bun:test";
 import * as posixModule from "@intx/tools-posix";
 
 import { BUILD_TOOLS, DOCS_TOOLS } from "./directors/tool-sets.js";
-import { advertisedTools, CORE_TOOL_NAMES } from "./tool-search.js";
+import { foldFileToolNames } from "./tool-aliases.js";
+import {
+  ADVERTISED_TOOL_NAMES,
+  advertisedTools,
+  CORE_TOOL_NAMES,
+} from "./tool-search.js";
 
 afterEach(() => {
   spyOn(posixModule, "createPosixTools").mockRestore();
@@ -42,7 +47,7 @@ describe("Codex tool proxy mount", () => {
     await toolset.dispose();
   });
 
-  test("Codex createAgentToolset does not advertise apply_patch/shell/update_plan", async () => {
+  test("Codex createAgentToolset keeps engines posix-named and projects wire names by profile", async () => {
     // Unstubbed createPosixTools: write_file / edit_file / delete_file come from
     // the real posix + delete-file plugin mount. An empty stub would hide them
     // and make the DIY-remains assertion meaningless.
@@ -74,6 +79,17 @@ describe("Codex tool proxy mount", () => {
     expect(advertised).not.toContain("shell");
     expect(advertised).not.toContain("apply_patch");
     expect(advertised).not.toContain("update_plan");
+    const gptAdvertised = advertisedTools(
+      toolset.dynamicRunner.currentDefinitions(),
+      [],
+      foldFileToolNames(ADVERTISED_TOOL_NAMES, "gpt"),
+      "gpt",
+    ).map((d) => d.name);
+    expect(gptAdvertised).toContain("shell");
+    expect(gptAdvertised).toContain("apply_patch");
+    expect(gptAdvertised).toContain("update_plan");
+    expect(gptAdvertised).not.toContain("write");
+    expect(gptAdvertised).not.toContain("bash");
     await toolset.dispose();
   });
 
@@ -111,6 +127,36 @@ describe("Codex tool proxy mount", () => {
     await toolset.dispose();
   });
 
+  test("wire names from every profile dispatch onto the mounted engines", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "corbits-codex-mount-"));
+    const { createAgentToolset } = await import("./tools.js");
+    const toolset = await createAgentToolset({
+      cwd,
+      permissionGate: {
+        check: async () => ({ allowed: true }),
+        getSkipPermissions: () => false,
+      } as never,
+      onOperatorGate: async () => ({ kind: "option", index: 0 }),
+      isCodex: true,
+    });
+    const call = (name: string, args: Record<string, unknown>) =>
+      toolset.dynamicRunner.run(
+        { id: name, name, arguments: args },
+        new AbortController().signal,
+      );
+    const patched = await call("apply_patch", {
+      input: "*** Begin Patch\n*** Add File: made.txt\n+hi\n*** End Patch",
+    });
+    expect(patched.isError).toBeFalsy();
+    expect(readFileSync(join(cwd, "made.txt"), "utf8")).toBe("hi\n");
+    const todo = await call("todowrite", {
+      action: "create",
+      tasks: [{ id: "t1", title: "x", status: "todo" }],
+    });
+    expect(todo.isError).toBeFalsy();
+    await toolset.dispose();
+  });
+
   test("BUILD_TOOLS and DOCS_TOOLS omit apply_patch; CORE_TOOL_NAMES does not list it", () => {
     expect(BUILD_TOOLS).not.toContain("apply_patch");
     expect(DOCS_TOOLS).not.toContain("apply_patch");