@assertrx/dino 1.0.0

package/README.md

@@ -0,0 +1,293 @@
+# Dino
+
+An Automated Verification agent based on Pi Harness
+
+## What's Inside
+
+| Type | Name | What it does |
+|------|------|-------------|
+| Extension | `dino` | Replaces the pi TUI header with a Dino-themed ASCII header and provides a `/dino-header` command to restore the built-in header |
+| Extension | `playwright-mcp` | Bridges Microsoft Playwright MCP tools into pi.dev so the agent can drive a browser for live page inspection, POM generation, and web verification |
+| Extension | `mabl-mcp` | Bridges the mabl MCP server into pi.dev so the agent can query tests, runs, plans, and workspaces via mabl's official CLI using OAuth authentication |
+| Skill | `acli` | Interact with Atlassian Cloud (Jira and Confluence) via the `acli` CLI — search work items, manage sprints/boards, create Confluence pages, and more |
+| Skill | `bdd-gherkin` | Generate domain-driven Gherkin/Cucumber BDD scenarios focused on business requirements with minimal technical details |
+| Skill | `playwright-cli` | Automates browser interactions via `playwright-cli` for terminal-first browser control, navigation, screenshots, tracing, and test generation |
+| Skill | `playwright-core` | Battle-tested Playwright patterns for writing and debugging reliable E2E, API, component, visual, accessibility, and security tests |
+| Skill | `playwright-pom` | Page Object Model patterns for Playwright — when to use POM, how to structure page objects, and when fixtures or helpers are a better fit |
+| Skill | `mabl-mcp` | Guidance for using the mabl MCP bridge — workspace context, running tests, retrieving results, and handling OAuth auth |
+| Prompt | `create-pr` | Create a GitHub pull request for changes in the current workspace, installing `gh` and setting up git if needed |
+| Prompt | `generate-bdd-from-url` | Generate exhaustive Gherkin BDD scenarios for a single page by inspecting it with `playwright-cli` or Playwright MCP |
+| Prompt | `generate-pom-from-url` | Generate Playwright Page Object Models from a live URL using the Playwright MCP bridge (`browser_*` tools) |
+| Prompt | `generate-pom-from-url-cli` | Generate Playwright Page Object Models from a live URL using `playwright-cli` commands |
+| Prompt | `generate-spec-from-feature` | Generate a Playwright test spec from a Gherkin feature file, reusing existing POMs |
+| Prompt | `heal-playwright-failures` | Detect, diagnose, and auto-heal failed Playwright tests by updating selectors, waits, and assertions, then re-run to verify |
+| Prompt | `setup-playwright` | Set up a vanilla Playwright project in the current workspace with TypeScript, config, and a starter test |
+
+## AI Evals Skills
+
+These skills help design, run, and validate evaluations for LLM-powered systems.
+
+| Skill | Description |
+|-------|-------------|
+| `build-review-interface` | Build a custom browser-based annotation interface for reviewing LLM traces and collecting structured human labels. |
+| `error-analysis` | Systematically identify and categorize failure modes in an LLM pipeline by reading traces. |
+| `eval-audit` | Audit an LLM eval pipeline for problems such as unvalidated judges, vanity metrics, and missing error analysis. |
+| `evaluate-rag` | Evaluate retrieval-augmented generation pipelines, including retrieval quality, generation faithfulness, and relevance. |
+| `generate-synthetic-data` | Create diverse synthetic test inputs for LLM evaluation using dimension-based tuple generation. |
+| `validate-evaluator` | Calibrate an LLM-as-judge against human labels using metrics like TPR/TNR and bias correction. |
+| `write-judge-prompt` | Design LLM-as-judge evaluators for subjective criteria that code-based checks cannot handle. |
+
+## Prompts
+
+Dino includes reusable slash-command prompts for common verification workflows.
+
+### Choosing a browser automation prompt
+
+For browser-based tasks, **prefer the `playwright-cli` prompts**. They are more token-efficient because the agent reads compact terminal output instead of full MCP tool-result payloads.
+
+**Use the Playwright MCP prompts only as a fallback** when the `playwright-cli` prompt fails, the page cannot be reached via the CLI, or you need richer live-browser introspection.
+
+| Prompt | What it does | Example usage |
+|--------|--------------|---------------|
+| `/create-pr` | Create a GitHub pull request for changes in the current workspace, installing `gh` if needed. | `/create-pr` |
+| `/generate-bdd-from-url` | Inspect a page and generate exhaustive Gherkin BDD scenarios for that page only. | `/generate-bdd-from-url https://example.com tests/features` |
+| `/generate-pom-from-url-cli` | Generate Playwright Page Object Models from a live URL using `playwright-cli` (**preferred**). | `/generate-pom-from-url-cli https://example.com tests/pom` |
+| `/generate-pom-from-url` | Generate Page Object Models from a live URL using the Playwright MCP bridge (**fallback only**). | `/generate-pom-from-url https://example.com tests/pom` |
+| `/generate-spec-from-feature` | Generate a Playwright test spec from a Gherkin feature file, reusing existing POMs. | `/generate-spec-from-feature https://example.com tests/features/login.feature tests/pom tests/specs` |
+| `/heal-playwright-failures` | Run the Playwright suite, detect failures, diagnose root causes, apply safe fixes, and re-run to verify. | `/heal-playwright-failures` or `/heal-playwright-failures tests/login.spec.ts 3` |
+| `/setup-playwright` | Set up a vanilla Playwright project in the current workspace with TypeScript, config, and a starter test. | `/setup-playwright` |
+
+## Prerequisite
+
+Dino requires the `pi` CLI to be installed. If `pi` is not present, install it globally via npm:
+
+```bash
+npm install -g @earendil-works/pi-coding-agent
+```
+
+Verify the installation:
+
+```bash
+pi --version
+```
+
+## Install
+
+Dino is installed **per-project** using the `-l` flag. This records the package entry in the project's `.pi/settings.json` instead of the global `~/.pi/agent/settings.json`, so Dino is only loaded when you start `pi` inside that project.
+
+### Why install locally instead of globally?
+
+We recommend installing Dino as a **local** pi package rather than a global one for two important reasons:
+
+1. **Avoid overwriting other pi agents.** Installing Dino globally would replace the active global `pi` agent, which can overwrite or conflict with existing pi packages. Installing locally keeps Dino scoped to the current project without affecting your global `pi` setup or other agents.
+
+2. **Allow postinstall scripts to run.** Dino relies on npm `postinstall` scripts to set up required runtime dependencies — for example, installing the Playwright browser binaries and writing extension/configuration files needed by the test verification agent. When Dino is installed locally in a project, its own `npm install` runs fully and these postinstall steps execute as intended. Global installation paths or shared package managers may suppress or skip these scripts, leaving browser tooling incomplete.
+
+In short, a local install keeps Dino isolated to the project that needs it, protects your other `pi` agents, and ensures the Playwright-based verification tooling is fully configured.
+
+### Example: install Dino into a `YourTesting` project
+
+Assume you are starting fresh with an empty project folder. The goal is to have this layout:
+
+```
+~/work/
+├── YourTesting/        # your project
+└── dino/                # Dino package clone
+```
+
+1. Create your project folder and navigate into it:
+
+   ```bash
+   mkdir -p ~/work/YourTesting
+   cd ~/work/YourTesting
+   ```
+
+2. Clone the Dino repository next to your project folder:
+
+   ```bash
+   git clone https://github.com/testdino-hq/dino.git ../dino
+   ```
+
+   Your folder structure should now look like:
+
+   ```
+   ~/work/
+   ├── YourTesting/
+   └── dino/
+   ```
+
+3. Install Dino's npm dependencies. Pi does **not** run `npm install` automatically for local-path packages, so you must do this once in the Dino directory:
+
+   ```bash
+   cd ../dino
+   npm install
+   cd -  # returns you to ~/work/YourTesting
+   ```
+
+   This installs Dino's dependencies (including `@playwright/mcp`, `@playwright/cli`, and the MCP SDK) and runs the package `postinstall` script.
+
+4. Install Dino into the current project only:
+
+   ```bash
+   pi install ../dino --approve -l
+   ```
+
+   The `-l` flag tells pi to write the package reference to `.pi/settings.json` inside `YourTesting`.
+
+5. Verify the install. You should now have a `.pi/settings.json` file in your project, and Dino will load automatically the next time you start pi from `~/work/YourTesting`:
+
+   ```bash
+   pi list
+   ```
+
+> **Note:** If you want to try Dino once without persisting it anywhere, use `--extension` (or `-e`) for a temporary install:
+> ```bash
+> pi -e ../dino
+> ```
+
+## Remove
+
+If Dino was installed with the `-l` flag, remove it from the current project's `.pi/settings.json`:
+
+```bash
+pi uninstall dino -l
+```
+
+Or remove the local path entry manually from `.pi/settings.json`.
+
+## Playwright MCP bridge
+
+Dino can expose the official Microsoft Playwright MCP server (`@playwright/mcp`) as pi.dev tools. This lets the agent navigate, snapshot, click, fill, and otherwise control a browser — useful for live page inspection when generating Page Object Models or verifying web behavior.
+
+### Setup
+
+1. In the Dino directory, install the package dependencies (this pulls in `@playwright/mcp` and the MCP SDK and also installs the Chromium browser via the `postinstall` script):
+
+   ```bash
+   cd /path/to/dino
+   npm install
+   ```
+
+2. If the Chromium binary was not installed by the `postinstall` script, install it manually:
+
+   ```bash
+   npx playwright install chromium
+   ```
+
+3. Make sure Dino is installed as a project-local pi package so the extension is loaded (run this from your project directory, e.g. `YourTesting`):
+
+   ```bash
+   pi install ../dino --approve -l
+   ```
+
+   If already installed, reload the package:
+
+   ```bash
+   pi update --extension ../dino
+   # or just reinstall
+   pi install ../dino --approve -l
+   ```
+
+4. Start pi in a project where you want to use the browser tools. On startup you should see:
+
+   ```
+   [playwright-mcp] Registered 24 Playwright MCP tool(s).
+   ```
+
+### Available tools
+
+Once loaded, tools such as these are available to the model:
+
+- `browser_navigate` — navigate to a URL
+- `browser_snapshot` — capture accessibility tree of the current page
+- `browser_click`, `browser_type`, `browser_fill_form` — interact with elements
+- `browser_take_screenshot` — capture a screenshot
+- `browser_console_messages`, `browser_network_requests` — inspect page activity
+
+### Using with the `playwright-pom` skill
+
+The `playwright-pom` skill now includes an MCP-driven workflow:
+
+1. User asks for a POM for a page/URL.
+2. The agent calls `browser_navigate` to open the page.
+3. The agent calls `browser_snapshot` to inspect the accessibility tree.
+4. The agent generates a page object using resilient locators (`getByRole`, `getByLabel`, `getByTestId`).
+
+See `skills/playwright-pom/SKILL.md` for the full workflow and example.
+
+## mabl MCP bridge
+
+Dino can expose the official [mabl MCP server](https://help.mabl.com/hc/en-us/articles/47299375773844-mabl-MCP-overview) as pi.dev tools using OAuth authentication. This lets the agent query mabl workspaces, tests, plans, runs, results, and other mabl resources directly from the conversation.
+
+### Setup
+
+1. In the Dino directory, install the package dependencies (this pulls in `@mablhq/mabl-cli` and the MCP SDK):
+
+   ```bash
+   cd /path/to/dino
+   npm install
+   ```
+
+2. Make sure Dino is installed as a project-local pi package so the extension is loaded (run this from your project directory, e.g. `YourTesting`):
+
+   ```bash
+   pi install ../dino --approve -l
+   ```
+
+   If already installed, reload the package:
+
+   ```bash
+   pi update --extension ../dino
+   # or just reinstall
+   pi install ../dino --approve -l
+   ```
+
+3. Start pi in a project where you want to use the mabl tools. The extension no longer runs the OAuth check automatically on startup. To check authentication, run the OAuth flow, and load the mabl MCP tools, use the extension command:
+
+   ```
+   /mabl-auth
+   ```
+
+   If you are not already authenticated with mabl, the command runs `mabl auth login --auto` to perform the OAuth flow. Follow the on-screen prompts (open the authorization URL in a browser and approve access). After authentication succeeds you should see:
+
+   ```
+   [mabl-mcp] Registered N mabl MCP tool(s).
+   ```
+
+   > **Note:** `mabl auth login --auto` is designed for headless/agent environments. It captures the OAuth authorization code automatically, but you still need to approve the login in a browser the first time.
+
+### Manual OAuth (if the automatic flow is blocked)
+
+If the automatic OAuth flow cannot complete inside pi (for example, because no browser is available), authenticate outside of pi and then run the command inside pi:
+
+```bash
+cd /path/to/dino
+npx @mablhq/mabl-cli auth login --auto
+# approve the login in your browser, then:
+pi start
+```
+
+Once pi is running, invoke `/mabl-auth` to load the mabl MCP tools.
+
+### Available tools
+
+Once loaded, the mabl MCP tools exposed by the server become available to the model. Tool names and capabilities depend on the current mabl MCP server version; examples include:
+
+- Querying workspaces, applications, environments, and plans
+- Listing tests and test runs
+- Retrieving run results and diagnostics
+
+The extension discovers the tool list dynamically from the server, so new tools are automatically available after updating `@mablhq/mabl-cli`.
+
+### Authentication note
+
+The extension stores no credentials itself. It relies on the mabl CLI's own OAuth token storage (managed by `@mablhq/mabl-cli`). To sign out, run:
+
+```bash
+npx @mablhq/mabl-cli auth clear
+```
+
+### Command reference
+
+- `/mabl-auth` — Check mabl OAuth status, run `mabl auth login --auto` if needed, and start the mabl MCP server so the model can use the mabl tools.
+

package/extensions/dino.ts

@@ -0,0 +1,70 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { VERSION } from "@earendil-works/pi-coding-agent";
+
+function getDinoHeader(theme: Theme): string[] {
+  const purple = (text: string) => theme.fg("accent", text);
+  const muted = (text: string) => theme.fg("muted", text);
+  const dim = (text: string) => theme.fg("dim", text);
+
+  // Block-letter ASCII for "DINO"
+  const d = ["█████", "█   █", "█   █", "█   █", "█████"];
+  const i = [" ███ ", "  █  ", "  █  ", "  █  ", " ███ "];
+  const n = ["█   █", "██  █", "█ █ █", "█  ██", "█   █"];
+  const o = [" ███ ", "█   █", "█   █", "█   █", " ███ "];
+
+  const letters = [d, i, n, o];
+  const titleLines: string[] = [];
+  for (let i = 0; i < 5; i++) {
+    titleLines.push(purple(letters.map((l) => l[i]).join("  ")));
+  }
+
+  const dino = [
+    "                ████████",
+    "              ██░░░░░░░░██",
+    "            ██░░░░░░░░░░░░██",
+    "           █░░░░░░░░░░░░░░░█",
+    "          █░░░░░░░░░░░░░░░░░█",
+    "         █░░░░░░░░░░░░░░░░░░░█",
+    "        █░░░░░░░░░░░░░░░░░░░░█",
+    "       █░░░░░░░░░░░░░░░░░░░░░░█",
+    "      █░░░░░░░░░░░░░░░░░░░░░░░█",
+    "     █░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    "    █░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    "   █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    "  █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    " █░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    "███████████████████████████████████████",
+    "█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    "█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█",
+    " ████████████████████████████████████",
+    "        █   █        █   █",
+    "        █   █        █   █",
+  ];
+
+  const subtitle = `${muted("   friendly purple dinosaur")}${dim(` v${VERSION}`)}`;
+
+  return ["", ...titleLines, subtitle, "", ...dino.map(purple), ""];
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.mode === "tui") {
+      ctx.ui.setHeader((_tui, theme) => {
+        return {
+          render(_width: number): string[] {
+            return getDinoHeader(theme);
+          },
+          invalidate() {},
+        };
+      });
+    }
+  });
+
+  pi.registerCommand("dino-header", {
+    description: "Restore built-in header",
+    handler: async (_args, ctx) => {
+      ctx.ui.setHeader(undefined);
+      ctx.ui.notify("Built-in header restored", "info");
+    },
+  });
+}

package/extensions/mabl-mcp.ts

@@ -0,0 +1,306 @@
+/**
+ * Bridge the mabl MCP server into pi.dev as custom tools.
+ *
+ * This extension does NOT run the mabl OAuth check at startup. Instead it
+ * registers a `/mabl-auth` command that the user can run explicitly. The
+ * command checks authentication, runs `mabl auth login --auto` if needed, and
+ * then starts `mabl mcp start` and registers the exposed tools.
+ */
+import { createRequire } from "node:module";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type, type TSchema } from "typebox";
+
+const require = createRequire(import.meta.url);
+
+function jsonSchemaToTypeBox(schema: unknown): TSchema {
+  if (!schema || typeof schema !== "object") {
+    return Type.Any();
+  }
+  const s = schema as Record<string, any>;
+
+  switch (s.type) {
+    case "object": {
+      const properties: Record<string, TSchema> = {};
+      const required = new Set<string>(s.required ?? []);
+      for (const [key, value] of Object.entries(s.properties ?? {})) {
+        const child = jsonSchemaToTypeBox(value);
+        properties[key] = required.has(key) ? child : Type.Optional(child);
+      }
+      return Type.Object(properties);
+    }
+    case "array":
+      return Type.Array(jsonSchemaToTypeBox(s.items));
+    case "string":
+      return Type.String({ description: s.description });
+    case "number":
+    case "integer":
+      return Type.Number({ description: s.description });
+    case "boolean":
+      return Type.Boolean({ description: s.description });
+    case "null":
+      return Type.Null();
+    default:
+      break;
+  }
+
+  if (Array.isArray(s.enum)) {
+    return Type.Union(s.enum.map((value: unknown) => Type.Literal(value as any)));
+  }
+
+  return Type.Any({ description: s.description });
+}
+
+function runCommand(
+  command: string,
+  args: string[],
+  options?: { stdio?: "inherit" | "pipe"; timeoutMs?: number }
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const stdio = options?.stdio === "inherit" ? "inherit" : "pipe";
+    const child = spawn(command, args, {
+      stdio: ["inherit", stdio, stdio],
+      shell: false,
+      windowsHide: true,
+    });
+
+    const stdoutChunks: Buffer[] = [];
+    const stderrChunks: Buffer[] = [];
+    let killedByTimeout = false;
+
+    if (child.stdout && stdio === "pipe") {
+      child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    }
+    if (child.stderr && stdio === "pipe") {
+      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    }
+
+    const timeout = options?.timeoutMs
+      ? setTimeout(() => {
+          killedByTimeout = true;
+          child.kill("SIGTERM");
+        }, options.timeoutMs)
+      : undefined;
+
+    let settled = false;
+
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve({
+        exitCode: -1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8") || String(err),
+      });
+    });
+
+    child.on("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      resolve({
+        exitCode: killedByTimeout ? -1 : code ?? 0,
+        stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+      });
+    });
+  });
+}
+
+async function resolveMablBin(): Promise<string | undefined> {
+  try {
+    const pkgPath = require.resolve("@mablhq/mabl-cli/package.json");
+    return path.join(path.dirname(pkgPath), "cli.js");
+  } catch {
+    return undefined;
+  }
+}
+
+async function checkAuthentication(
+  nodePath: string,
+  mablBin: string
+): Promise<boolean> {
+  const infoResult = await runCommand(nodePath, [mablBin, "auth", "info"], {
+    timeoutMs: 30000,
+  });
+  return (
+    infoResult.exitCode === 0 &&
+    !infoResult.stdout.toLowerCase().includes("not logged in") &&
+    !infoResult.stderr.toLowerCase().includes("not logged in")
+  );
+}
+
+export default async function (pi: ExtensionAPI) {
+  let mcpState:
+    | {
+        transport: StdioClientTransport;
+        client: Client;
+        toolsRegistered: number;
+      }
+    | undefined;
+  let cleanupRegistered = false;
+
+  const cleanup = async () => {
+    if (!mcpState) return;
+    try {
+      await mcpState.transport.close();
+      await mcpState.client.close();
+    } catch {
+      // ignore cleanup errors
+    }
+    mcpState = undefined;
+  };
+
+  pi.registerCommand("mabl-auth", {
+    description:
+      "Check mabl OAuth status, log in if needed, and load mabl MCP tools.",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      const mablBin = await resolveMablBin();
+      if (!mablBin) {
+        ctx.ui.notify(
+          "[mabl-mcp] @mablhq/mabl-cli is not installed. Run `npm install` in the Dino package directory.",
+          "error"
+        );
+        return;
+      }
+
+      const nodePath = process.execPath;
+
+      if (mcpState) {
+        const stillAuthenticated = await checkAuthentication(nodePath, mablBin);
+        if (stillAuthenticated) {
+          ctx.ui.notify(
+            `[mabl-mcp] Already authenticated. ${mcpState.toolsRegistered} mabl MCP tool(s) loaded.`,
+            "info"
+          );
+        } else {
+          ctx.ui.notify(
+            "[mabl-mcp] MCP server is running but authentication appears expired. Run `/mabl-auth` again after logging in.",
+            "warning"
+          );
+        }
+        return;
+      }
+
+      ctx.ui.notify("[mabl-mcp] Checking mabl authentication...", "info");
+      let authenticated = await checkAuthentication(nodePath, mablBin);
+
+      if (!authenticated) {
+        ctx.ui.notify(
+          "[mabl-mcp] Not authenticated. Starting OAuth login (auto-capture mode)...",
+          "info"
+        );
+        const loginResult = await runCommand(
+          nodePath,
+          [mablBin, "auth", "login", "--auto"],
+          { stdio: "inherit" }
+        );
+        if (loginResult.exitCode !== 0) {
+          ctx.ui.notify(
+            `[mabl-mcp] mabl OAuth login failed or was cancelled (exit ${loginResult.exitCode}). Run manually with: npx @mablhq/mabl-cli auth login --auto`,
+            "error"
+          );
+          return;
+        }
+        authenticated = await checkAuthentication(nodePath, mablBin);
+        if (!authenticated) {
+          ctx.ui.notify(
+            "[mabl-mcp] mabl OAuth login appeared to succeed but is still not authenticated.",
+            "error"
+          );
+          return;
+        }
+        ctx.ui.notify("[mabl-mcp] mabl OAuth login succeeded.", "info");
+      } else {
+        ctx.ui.notify("[mabl-mcp] Already authenticated with mabl.", "info");
+      }
+
+      // Start the mabl MCP server and register tools.
+      ctx.ui.notify("[mabl-mcp] Starting mabl MCP server...", "info");
+      const transport = new StdioClientTransport({
+        command: nodePath,
+        args: [mablBin, "mcp", "start"],
+        stderr: "inherit",
+      });
+
+      const client = new Client({
+        name: "dino-mabl-mcp",
+        version: "0.1.0",
+      });
+
+      try {
+        await client.connect(transport);
+      } catch (err) {
+        ctx.ui.notify(
+          `[mabl-mcp] Could not connect to mabl MCP server: ${err}`,
+          "error"
+        );
+        return;
+      }
+
+      let tools;
+      try {
+        const result = await client.listTools();
+        tools = result.tools;
+      } catch (err) {
+        ctx.ui.notify(
+          `[mabl-mcp] Could not list mabl MCP tools: ${err}`,
+          "error"
+        );
+        return;
+      }
+
+      for (const tool of tools) {
+        pi.registerTool({
+          name: tool.name,
+          label: tool.name,
+          description: tool.description ?? ``,
+          promptSnippet: `mabl MCP tool: ${tool.description ?? tool.name}`,
+          parameters: jsonSchemaToTypeBox(tool.inputSchema),
+          async execute(_toolCallId, params) {
+            const result = await client.callTool({
+              name: tool.name,
+              arguments: (params ?? {}) as Record<string, unknown>,
+            });
+
+            const content = (result.content as any[]).map((item: any) => {
+              if (item.type === "text") {
+                return { type: "text" as const, text: item.text };
+              }
+              if (item.type === "image") {
+                return {
+                  type: "image" as const,
+                  data: item.data,
+                  mimeType: item.mimeType,
+                };
+              }
+              return { type: "text" as const, text: JSON.stringify(item) };
+            });
+
+            return { content, details: result };
+          },
+        });
+      }
+
+      mcpState = { transport, client, toolsRegistered: tools.length };
+      ctx.ui.notify(
+        `[mabl-mcp] Registered ${tools.length} mabl MCP tool(s).`,
+        "info"
+      );
+
+      if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        pi.on("session_shutdown", cleanup);
+      }
+    },
+  });
+}