@agntn/harnesses 0.0.1

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@agntn/harnesses",
+  "version": "0.0.1",
+  "description": "Metadata registry for AI coding harnesses: binaries, configs, sessions, and capabilities.",
+  "homepage": "https://github.com/agntn/harnesses#readme",
+  "bugs": "https://github.com/agntn/harnesses/issues",
+  "license": "MIT",
+  "author": "oritwoen (https://github.com/oritwoen)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agntn/harnesses.git"
+  },
+  "bin": {
+    "harnesses": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "packages/omp/extensions",
+    "packages/pi/extensions",
+    "packages/shared"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.mts",
+      "import": "./dist/mcp.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@toon-format/toon": "^4.1.1",
+    "citty": "^0.2.2",
+    "consola": "^3.4.2",
+    "smol-toml": "^1.8.0",
+    "typebox": "^1.3.19"
+  },
+  "devDependencies": {
+    "@agntn/ox": "^0.1.0",
+    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@earendil-works/pi-tui": "0.84.3",
+    "@oh-my-pi/omptype": "18.0.4",
+    "@oh-my-pi/pi-ai": "18.0.4",
+    "@oh-my-pi/pi-coding-agent": "18.0.4",
+    "@types/node": "latest",
+    "@typescript/native-preview": "latest",
+    "changelogen": "^0.6.2",
+    "obuild": "^0.4.38",
+    "oxfmt": "^0.65.0",
+    "oxlint": "^1.80.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "vitest": "^4.1.11"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.84.2 <1",
+    "@earendil-works/pi-tui": ">=0.84.2 <1",
+    "@oh-my-pi/pi-coding-agent": ">=18.0.0 <19"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "@oh-my-pi/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "omp": {
+    "extensions": [
+      "./packages/omp/extensions/harnesses.ts"
+    ]
+  },
+  "pi": {
+    "extensions": [
+      "./packages/pi/extensions/harnesses.ts"
+    ]
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "obuild --stub",
+    "lint": "pnpm build && oxlint . && oxfmt --check .",
+    "lint:fix": "pnpm build && oxlint . --fix && oxfmt . && pnpm build",
+    "typecheck": "tsgo --noEmit --skipLibCheck && pnpm build && tsgo --noEmit --skipLibCheck -p tsconfig.extensions.json",
+    "test": "vitest",
+    "test:run": "vitest --run",
+    "release": "pnpm test:run && pnpm build && changelogen --release --push"
+  }
+}

package/packages/omp/extensions/AGENTS.md

@@ -0,0 +1,7 @@
+# OMP extension
+
+Scope: the distributable OMP extension adapter and its TUI renderers.
+
+- Reuse shared schemas and executors; this file owns only OMP registration, approval level, and rendering.
+- Treat spawned harness commands as `exec`, even when their logical result is read-only.
+- Sanitize every external value before rendering it in the terminal.

package/packages/omp/extensions/harnesses.ts

@@ -0,0 +1,253 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import type { AgentToolResult, ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { Text } from "@oh-my-pi/pi-coding-agent";
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { AnySchema } from "@oh-my-pi/omptype/typebox";
+
+import type * as HarnessTools from "../../../dist/tool-operations.d.mts";
+import {
+  HARNESS_TOOL_APPROVALS,
+  HARNESS_TOOL_LABELS,
+  type HarnessToolName,
+  type RenderedToolResult,
+  type RenderOptions,
+  renderToolCall,
+  renderToolResult,
+  type StatusTheme,
+} from "../../shared/tui.ts";
+// Schemas must exist synchronously at registration, so unlike the executors
+// below they load from dist; `pnpm build` keeps it current in the checkout.
+import { harnessToolSchemas } from "../../../dist/tool-schemas.mjs";
+import type * as HarnessSchemas from "../../../dist/tool-schemas.d.mts";
+
+const sourceModulePath = fileURLToPath(new URL("../../../src/tool-operations.ts", import.meta.url));
+let toolOperationsPromise: Promise<typeof HarnessTools> | undefined;
+
+/**
+ * Loads the tool executors shared with the Pi extension, so the tool answers
+ * stay identical across surfaces. Both specifiers stay literal on purpose:
+ * OMP's compiled loader rewrites bare dependencies only for imports it can
+ * see statically.
+ *
+ * @returns {Promise<typeof HarnessTools>} The shared executor module.
+ */
+function loadToolOperations(): Promise<typeof HarnessTools> {
+  toolOperationsPromise ??= (
+    existsSync(sourceModulePath)
+      ? import("../../../src/tool-operations.ts")
+      : import("../../../dist/tool-operations.mjs")
+  ) as Promise<typeof HarnessTools>;
+
+  return toolOperationsPromise;
+}
+
+function statusRenderers(tool: HarnessToolName) {
+  return {
+    renderCall(args: unknown, options: RenderOptions, theme: StatusTheme) {
+      return new Text(renderToolCall(tool, args, options, theme), 0, 0);
+    },
+    renderResult(result: RenderedToolResult, options: RenderOptions, theme: StatusTheme) {
+      return new Text(
+        renderToolResult(tool, result, result.isError === true, options, theme),
+        0,
+        0,
+      );
+    },
+  };
+}
+
+export default function harnessesExtension(pi: ExtensionAPI): void {
+  // OMP validates tool parameters with its own TypeBox build, so schemas must
+  // come from the host-injected facade rather than a standalone typebox import.
+  const schemas = harnessToolSchemas<AnySchema, TSchema>(pi.typebox.Type);
+  pi.setLabel("Harnesses");
+
+  pi.registerTool({
+    name: "harnesses_detect",
+    label: HARNESS_TOOL_LABELS.harnesses_detect,
+    description: "List every known AI coding harness with its install state and version",
+    parameters: schemas.detect,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_detect,
+    async execute(_toolCallId, _params): Promise<AgentToolResult<HarnessTools.HarnessListing>> {
+      const { detectHarnesses } = await loadToolOperations();
+      const { content, details } = detectHarnesses();
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_detect"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_info",
+    label: HARNESS_TOOL_LABELS.harnesses_info,
+    description:
+      "Full metadata for one or more AI coding harnesses, including supported invocation and model operations, configuration, sessions, instructions, skills, commands, hooks, and resolved paths",
+    parameters: schemas.info,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_info,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.InfoParams,
+    ): Promise<AgentToolResult<HarnessTools.HarnessInfoDetails>> {
+      const { harnessInfo } = await loadToolOperations();
+      const { content, details } = harnessInfo(params.id);
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_info"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_models",
+    label: HARNESS_TOOL_LABELS.harnesses_models,
+    description:
+      "List the models currently available to one AI coding harness through its native CLI",
+    parameters: schemas.models,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_models,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.ModelsParams,
+    ): Promise<AgentToolResult<HarnessTools.ModelsOutcome | HarnessTools.RunFailure>> {
+      const { listHarnessModels } = await loadToolOperations();
+      const { content, details, isError } = await listHarnessModels(params.id, {
+        search: params.search,
+        cwd: params.cwd,
+        timeoutSeconds: params.timeoutSeconds,
+      });
+      if (isError) {
+        const message =
+          "error" in details
+            ? details.error
+            : details.timedOut
+              ? `Harness ${details.id} model listing timed out`
+              : details.stderr || `Harness ${details.id} exited with code ${details.exitCode}`;
+        throw new Error(message);
+      }
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_models"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_run",
+    label: HARNESS_TOOL_LABELS.harnesses_run,
+    description:
+      "Run one prompt through a harness. Always choose tools explicitly. Add readOnly when tools is true to require native read-only enforcement, or use tools false for an advisor without tools.",
+    parameters: schemas.run,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_run,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.RunParams,
+    ): Promise<AgentToolResult<HarnessTools.RunOutcome | HarnessTools.RunFailure>> {
+      const { runHarness } = await loadToolOperations();
+      const { content, details, isError } = await runHarness(params.id, params.prompt, {
+        cwd: params.cwd,
+        model: params.model,
+        timeoutSeconds: params.timeoutSeconds,
+        structured: params.structured,
+        tools: params.tools,
+        readOnly: params.readOnly,
+      });
+      if (isError) {
+        const message =
+          "error" in details
+            ? details.error
+            : details.timedOut
+              ? `Harness ${details.id} timed out`
+              : details.stderr || `Harness ${details.id} exited with code ${details.exitCode}`;
+        throw new Error(message);
+      }
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_run"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_list",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_list,
+    description:
+      "List the MCP servers configured in each harness's config files, normalized across dialects",
+    parameters: schemas.mcpList,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_mcp_list,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpListParams,
+    ): Promise<AgentToolResult<HarnessTools.McpListing | HarnessTools.UnknownHarness>> {
+      const { mcpList } = await loadToolOperations();
+      const { content, details } = mcpList(params.id);
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_mcp_list"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_add",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_add,
+    description:
+      "Add or replace one MCP server in a harness config; TOML configs get a surgical, comment-preserving edit",
+    parameters: schemas.mcpAdd,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_mcp_add,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpAddParams,
+    ): Promise<AgentToolResult<HarnessTools.McpMutation | HarnessTools.RunFailure>> {
+      const { mcpAdd } = await loadToolOperations();
+      const { content, details } = mcpAdd(params.id, params, params.scope ?? "user");
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_mcp_add"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_sync",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_sync,
+    description:
+      "Reset every harness's user-scope MCP config to exactly the master list from ~/.config/agntn/mcp.jsonc; extras are removed and master-listed names are withdrawn from excluded harnesses",
+    parameters: schemas.mcpSync,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_mcp_sync,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpSyncParams,
+    ): Promise<AgentToolResult<HarnessTools.SyncReport | HarnessTools.RunFailure>> {
+      const { mcpSync } = await loadToolOperations();
+      const { content, details } = mcpSync(params.id);
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_mcp_sync"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_agents_sync",
+    label: HARNESS_TOOL_LABELS.harnesses_agents_sync,
+    description:
+      "Link every harness's global instructions file and declared companions to the master bundle; diverged copies are backed up and relinked. Pass check to only report",
+    parameters: schemas.agentsSync,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_agents_sync,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.AgentsSyncParams,
+    ): Promise<AgentToolResult<HarnessTools.AgentsSyncReport | HarnessTools.RunFailure>> {
+      const { agentsSync } = await loadToolOperations();
+      const { content, details } = agentsSync(params.id, params.check === true);
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_agents_sync"),
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_remove",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_remove,
+    description:
+      "Remove one MCP server from a harness config; TOML configs get a surgical, comment-preserving edit",
+    parameters: schemas.mcpRemove,
+    approval: HARNESS_TOOL_APPROVALS.harnesses_mcp_remove,
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpRemoveParams,
+    ): Promise<AgentToolResult<HarnessTools.McpMutation | HarnessTools.RunFailure>> {
+      const { mcpRemove } = await loadToolOperations();
+      const { content, details } = mcpRemove(params.id, params.name, params.scope ?? "user");
+      return { content, details };
+    },
+    ...statusRenderers("harnesses_mcp_remove"),
+  });
+}

package/packages/pi/extensions/AGENTS.md

@@ -0,0 +1,7 @@
+# Pi extension
+
+Scope: the distributable Pi extension adapter.
+
+- Reuse schemas and executors from `src/tool-schemas.ts` and `src/tool-operations.ts`; do not fork business logic here.
+- Register every shared read or execution capability exposed by the package tools.
+- Keep result types sourced from built declarations and preserve lazy executor loading.

package/packages/pi/extensions/harnesses.ts

@@ -0,0 +1,265 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import type { AgentToolResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type, type TSchema } from "typebox";
+
+import type * as HarnessTools from "../../../dist/tool-operations.d.mts";
+import {
+  HARNESS_TOOL_LABELS,
+  type HarnessToolName,
+  type RenderedToolResult,
+  type RenderOptions,
+  renderToolCall,
+  renderToolResult,
+  type StatusTheme,
+} from "../../shared/tui.ts";
+// Schemas must exist synchronously at registration, so unlike the executors
+// below they load from dist; `pnpm build` keeps it current in the checkout.
+import { harnessToolSchemas } from "../../../dist/tool-schemas.mjs";
+import type * as HarnessSchemas from "../../../dist/tool-schemas.d.mts";
+
+const sourceModuleUrl = new URL("../../../src/tool-operations.ts", import.meta.url);
+const distributionModuleUrl = new URL("../../../dist/tool-operations.mjs", import.meta.url);
+let toolOperationsPromise: Promise<typeof HarnessTools> | undefined;
+
+/**
+ * Loads the tool executors shared with the OMP extension, so the tool answers
+ * stay identical across surfaces.
+ *
+ * @returns {Promise<typeof HarnessTools>} The shared executor module.
+ */
+function loadToolOperations(): Promise<typeof HarnessTools> {
+  toolOperationsPromise ??= import(
+    existsSync(fileURLToPath(sourceModuleUrl)) ? sourceModuleUrl.href : distributionModuleUrl.href
+  ) as Promise<typeof HarnessTools>;
+
+  return toolOperationsPromise;
+}
+
+function statusRenderers(tool: HarnessToolName) {
+  return {
+    renderCall(args: unknown, theme: StatusTheme, context: RenderOptions) {
+      return new Text(renderToolCall(tool, args, context, theme), 0, 0);
+    },
+    renderResult(
+      result: RenderedToolResult,
+      options: RenderOptions,
+      theme: StatusTheme,
+      context?: Readonly<{ isError?: boolean }>,
+    ) {
+      return new Text(
+        renderToolResult(tool, result, context?.isError === true, options, theme),
+        0,
+        0,
+      );
+    },
+  };
+}
+
+export default function harnessesExtension(pi: ExtensionAPI): void {
+  const schemas = harnessToolSchemas<TSchema, TSchema>(Type);
+
+  pi.registerTool({
+    name: "harnesses_detect",
+    label: HARNESS_TOOL_LABELS.harnesses_detect,
+    description: "List every known AI coding harness with its install state and version",
+    promptSnippet: "Use harnesses_detect to see which AI coding harnesses are installed.",
+    promptGuidelines: ["The scan checks each harness's binaries on PATH and reads their versions."],
+    parameters: schemas.detect,
+    ...statusRenderers("harnesses_detect"),
+    async execute(_toolCallId, _params): Promise<AgentToolResult<HarnessTools.HarnessListing>> {
+      const { detectHarnesses } = await loadToolOperations();
+      const { content, details } = detectHarnesses();
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_info",
+    label: HARNESS_TOOL_LABELS.harnesses_info,
+    description:
+      "Full metadata for one or more AI coding harnesses, including supported invocation and model operations, configuration, sessions, instructions, skills, commands, hooks, and resolved paths",
+    promptSnippet: "Use harnesses_info to look up where coding harnesses store their data.",
+    promptGuidelines: [
+      "Pass one harness id from harnesses_detect, or batch several ids in one call.",
+      "Resolved paths are absolute for the current platform and home directory.",
+    ],
+    parameters: schemas.info,
+    ...statusRenderers("harnesses_info"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.InfoParams,
+    ): Promise<AgentToolResult<HarnessTools.HarnessInfoDetails>> {
+      const { harnessInfo } = await loadToolOperations();
+      const { content, details } = harnessInfo(params.id);
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_models",
+    label: HARNESS_TOOL_LABELS.harnesses_models,
+    description:
+      "List the models currently available to one AI coding harness through its native CLI",
+    promptSnippet:
+      "Use harnesses_models to inspect models available to an installed coding harness.",
+    promptGuidelines: [
+      "An optional search filter is passed only to harnesses that support native filtering.",
+      "The harness command may load configuration and extensions from cwd.",
+    ],
+    parameters: schemas.models,
+    ...statusRenderers("harnesses_models"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.ModelsParams,
+    ): Promise<AgentToolResult<HarnessTools.ModelsOutcome | HarnessTools.RunFailure>> {
+      const { listHarnessModels } = await loadToolOperations();
+      const { content, details, isError } = await listHarnessModels(params.id, {
+        search: params.search,
+        cwd: params.cwd,
+        timeoutSeconds: params.timeoutSeconds,
+      });
+      if (isError) {
+        const message =
+          "error" in details
+            ? details.error
+            : details.timedOut
+              ? `Harness ${details.id} model listing timed out`
+              : details.stderr || `Harness ${details.id} exited with code ${details.exitCode}`;
+        throw new Error(message);
+      }
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_run",
+    label: HARNESS_TOOL_LABELS.harnesses_run,
+    description:
+      "Run one prompt through an AI coding harness's normalized non-interactive invocation, optionally selecting a model, and return its output",
+    promptSnippet: "Use harnesses_run to delegate one prompt to another installed coding harness.",
+    promptGuidelines: [
+      "Always choose tools explicitly. Set true whenever the task needs harness tools, including Grok native X search.",
+      "Add readOnly when tools is true to require native read-only enforcement. Unsupported harnesses reject it instead of widening access.",
+      "Set tools false only for an advisor without tools. It never silently falls back to a full agent.",
+      "An unsupported mode returns an explicit retry when the alternate mode is available.",
+      "Output is capped for context; long runs stop at the timeout.",
+    ],
+    parameters: schemas.run,
+    ...statusRenderers("harnesses_run"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.RunParams,
+    ): Promise<AgentToolResult<HarnessTools.RunOutcome | HarnessTools.RunFailure>> {
+      const { runHarness } = await loadToolOperations();
+      const { content, details, isError } = await runHarness(params.id, params.prompt, {
+        cwd: params.cwd,
+        model: params.model,
+        timeoutSeconds: params.timeoutSeconds,
+        structured: params.structured,
+        tools: params.tools,
+        readOnly: params.readOnly,
+      });
+      if (isError) {
+        const message =
+          "error" in details
+            ? details.error
+            : details.timedOut
+              ? `Harness ${details.id} timed out`
+              : details.stderr || `Harness ${details.id} exited with code ${details.exitCode}`;
+        throw new Error(message);
+      }
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_list",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_list,
+    description:
+      "List the MCP servers configured in each harness's config files, normalized across dialects",
+    promptSnippet:
+      "Use harnesses_mcp_list to see which MCP servers each coding harness has configured.",
+    promptGuidelines: ["Omit id to scan every harness."],
+    parameters: schemas.mcpList,
+    ...statusRenderers("harnesses_mcp_list"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpListParams,
+    ): Promise<AgentToolResult<HarnessTools.McpListing | HarnessTools.UnknownHarness>> {
+      const { mcpList } = await loadToolOperations();
+      const { content, details } = mcpList(params.id);
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_add",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_add,
+    description:
+      "Add or replace one MCP server in a harness config; TOML configs get a surgical, comment-preserving edit",
+    parameters: schemas.mcpAdd,
+    ...statusRenderers("harnesses_mcp_add"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpAddParams,
+    ): Promise<AgentToolResult<HarnessTools.McpMutation | HarnessTools.RunFailure>> {
+      const { mcpAdd } = await loadToolOperations();
+      const { content, details } = mcpAdd(params.id, params, params.scope ?? "user");
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_sync",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_sync,
+    description:
+      "Reset every harness's user-scope MCP config to exactly the master list from ~/.config/agntn/mcp.jsonc; extras are removed and master-listed names are withdrawn from excluded harnesses",
+    parameters: schemas.mcpSync,
+    ...statusRenderers("harnesses_mcp_sync"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpSyncParams,
+    ): Promise<AgentToolResult<HarnessTools.SyncReport | HarnessTools.RunFailure>> {
+      const { mcpSync } = await loadToolOperations();
+      const { content, details } = mcpSync(params.id);
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_agents_sync",
+    label: HARNESS_TOOL_LABELS.harnesses_agents_sync,
+    description:
+      "Link every harness's global instructions file and declared companions to the master bundle; diverged copies are backed up and relinked. Pass check to only report",
+    parameters: schemas.agentsSync,
+    ...statusRenderers("harnesses_agents_sync"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.AgentsSyncParams,
+    ): Promise<AgentToolResult<HarnessTools.AgentsSyncReport | HarnessTools.RunFailure>> {
+      const { agentsSync } = await loadToolOperations();
+      const { content, details } = agentsSync(params.id, params.check === true);
+      return { content, details };
+    },
+  });
+
+  pi.registerTool({
+    name: "harnesses_mcp_remove",
+    label: HARNESS_TOOL_LABELS.harnesses_mcp_remove,
+    description:
+      "Remove one MCP server from a harness config; TOML configs get a surgical, comment-preserving edit",
+    parameters: schemas.mcpRemove,
+    ...statusRenderers("harnesses_mcp_remove"),
+    async execute(
+      _toolCallId,
+      params: HarnessSchemas.McpRemoveParams,
+    ): Promise<AgentToolResult<HarnessTools.McpMutation | HarnessTools.RunFailure>> {
+      const { mcpRemove } = await loadToolOperations();
+      const { content, details } = mcpRemove(params.id, params.name, params.scope ?? "user");
+      return { content, details };
+    },
+  });
+}

package/packages/shared/AGENTS.md

@@ -0,0 +1,7 @@
+# Shared extension UI
+
+Scope: framework-neutral rendering shared by the Pi and OMP extension adapters.
+
+- Keep terminal text sanitized before it reaches either harness component.
+- Return plain strings and structural data here. Pi and OMP own their component imports and renderer signatures.
+- Keep collapsed status lines bounded. Tool output still belongs to the model-facing result.