@polygraph/cursor-plugin 0.4.51

package/README.md

@@ -0,0 +1,113 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/polygraph-skills/main/source/assets/polygraph-light.svg">
+    <img src="https://raw.githubusercontent.com/nrwl/polygraph-skills/main/source/assets/polygraph.svg" alt="Polygraph Logo" width="140">
+  </picture>
+</p>
+
+<h1 align="center">Polygraph Skills</h1>
+
+<p align="center">
+  AI agent skills and subagents for <a href="https://trypolygraph.com/">Polygraph</a> — the agent-agnostic meta-harness for maximum agentic autonomy, giving agents visibility across every repo and memory that survives every session.
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Codex-555?logo=openai&logoColor=white&style=flat" alt="Codex">
+  <img src="https://img.shields.io/badge/Claude_Code-555?logo=anthropic&logoColor=white&style=flat" alt="Claude Code">
+  <img src="https://img.shields.io/badge/GitHub_Copilot-555?logo=github&logoColor=white&style=flat" alt="GitHub Copilot">
+  <img src="https://img.shields.io/badge/Gemini-555?logo=google&logoColor=white&style=flat" alt="Gemini">
+  <img src="https://img.shields.io/badge/OpenCode-555?logo=terminal&logoColor=white&style=flat" alt="OpenCode">
+  <br>
+  <img src="https://img.shields.io/github/license/nrwl/polygraph-skills" alt="License">
+</p>
+
+## What is Polygraph?
+
+Polygraph is the agent-agnostic meta-harness for maximum agentic autonomy. It works with the agents you already use and gives them what they're missing: visibility across every repo boundary, and memory that survives every session. Agents discover how repositories relate, coordinate changes across them, and hand off or resume work later with repos, branches, PRs, and logs all preserved.
+
+## Setup
+
+Run the interactive setup and follow the prompts:
+
+```sh
+polygraph config
+```
+
+It detects your AI agent — Claude Code, Codex, OpenCode, and more — and installs the Polygraph skills and subagents for it. Re-run it any time to add another agent or update an existing install.
+
+### Codex: raising the long-poll ceiling
+
+The delegate subagent polls child agents with `show_agent(waitForTransitionMs: 300000)` — a single 5-minute wait instead of a stream of short polls, which is what keeps delegation cheap. Claude Code and OpenCode honor the full wait. Codex does not by default.
+
+Codex caps every MCP tool call at `tool_timeout_sec = 60`, so long polls effectively cap at 50s. Nothing the plugin ships can change that: a plugin's `.mcp.json` has no timeout field, and `tool_timeout_sec` is only read from `~/.codex/config.toml`. Polling still works at 50s — the MCP resolves the real ceiling per client and returns early rather than erroring — you just pay for more round trips.
+
+To get the full 5-minute wait under Codex, set **both**:
+
+1. `tool_timeout_sec` in `~/.codex/config.toml`:
+
+   ```toml
+   [mcp_servers.polygraph]
+   tool_timeout_sec = 360
+   ```
+
+2. `POLYGRAPH_MCP_MAX_WAIT_MS` in that server's env, if you launch it from the CLI:
+
+   ```sh
+   POLYGRAPH_MCP_MAX_WAIT_MS=300000
+   ```
+
+Neither is required — they are a throughput optimization, not a correctness fix.
+
+## Skills
+
+- **polygraph** — Comprehensive guidance for Polygraph sessions: shared context, repository graph visibility, PR/CI state, delegation, and session management.
+- **adversarial-review** — Second-opinion review by independent per-repo agents that presents and attaches one consolidated review artifact.
+- **await-polygraph-ci** — Wait for CI pipelines to settle across all repos in a session, investigate failures, and present fix options.
+- **get-latest-ci** — One-shot fetch of the latest CI pipeline execution for the current branch.
+- **session-debrief** — Analyze the raw logs of past Polygraph sessions and produce structured, rank-ordered debriefs for use in a different session.
+
+## Agents
+
+- **polygraph-init-subagent** — Discovers candidate repositories and initializes a Polygraph session.
+- **polygraph-delegate-subagent** — Delegates work to a child agent in another repository, polls for completion.
+- **session-debrief** — Analyzes the raw logs of past Polygraph sessions and returns a structured, rank-ordered debrief for the current task.
+
+## Development
+
+```sh
+# Install dependencies
+npm install
+
+# Regenerate generated artifacts
+npm run sync-artifacts
+```
+
+Estimate the compiled prompt cost of every skill and subagent for Claude Code,
+Codex, and OpenCode:
+
+```sh
+npm run report:token-costs
+```
+
+The report uses four characters per estimated token by default. Override the
+ratio when needed with `npm run report:token-costs -- --characters-per-token 3.5`.
+Pull requests run the same report when opened or updated and keep the latest
+results in a single collapsible comment.
+
+## Releasing
+
+Run the `Release PR` GitHub Actions workflow with a version bump (`patch`, `minor`, or `major`).
+It opens a release PR against `main` instead of pushing directly.
+When that PR is merged, the `Stage Release` workflow automatically tags the release and publishes the Claude, Codex, and OpenCode npm packages.
+A maintainer must then review and approve each staged package with 2FA before it is published to the live registry.
+
+Configure each npm package's trusted publisher to allow `npm stage publish` from `.github/workflows/publish.yml`.
+For the strictest release flow, do not allow direct `npm publish` for the trusted publisher and disallow token-based publishing after the staged workflow has been verified.
+
+## Learn More
+
+- **[Polygraph](https://trypolygraph.com/)** — The agent-agnostic meta-harness for maximum agentic autonomy
+- **[@polygraph/mcp](https://www.npmjs.com/package/@polygraph/mcp)** — The MCP server that powers Polygraph tools
+## License
+
+License information is defined in the package metadata.

package/agents/polygraph-delegate-subagent.md

@@ -0,0 +1,65 @@
+---
+
+name: polygraph-delegate-subagent
+description: Waits for one Polygraph child agent (addressed by delegation id) to finish or need attention, then exits with a short fixed message. Never reads logs. Runs in the background.
+is_background: true
+
+---
+
+# Polygraph Delegate Subagent
+
+You wait for one Polygraph child agent to finish. You do not read its work.
+
+The main agent already spawned the child via `spawn_agent` and received a delegation id. Your entire job is to poll that id until the child needs attention, then exit with a short fixed message. The main agent reads the child's result itself — every log line you echo is duplicated tokens, so you never fetch logs.
+
+## Input (from the main agent)
+
+| Parameter   | Description                                                  |
+| ----------- | ------------------------------------------------------------ |
+| `sessionId` | The Polygraph session ID                                     |
+| `id`        | The delegation id returned by `spawn_agent` (e.g. `frontend-1`) |
+
+## Two ways to poll
+
+| MCP tool     | CLI equivalent                                                                        |
+| ------------ | ------------------------------------------------------------------------------------- |
+| `show_agent` | `polygraph agent show --session <sessionId> --id <id> --wait-for-transition-ms 300000` |
+
+Prefer the MCP tool. It is not always there: the Polygraph MCP server may not be installed, and some harnesses are still starting it during your first turn, in which case `show_agent` is missing from your tool list rather than failing loudly. Check your available tools before the first poll. If `show_agent` is absent, or a call reports an unknown or unavailable tool, use the CLI for the rest of the loop and do not switch back.
+
+The CLI takes the same two identifiers, blocks the same way, and prints the same payload as JSON on stdout: `{ "success": true, "sessionId": "…", "children": [ … ] }`. Read `children[0]` from it exactly as you would from the tool response. Everything below applies to whichever one you are using.
+
+## Loop
+
+Call `show_agent` with exactly these arguments, repeatedly:
+
+- `sessionId`: the session ID
+- `id`: the delegation id
+- `waitForTransitionMs`: 300000
+
+Never pass `tail`. Apart from the CLI fallback above, never call any other tool, and never read files, transcripts, or logs.
+
+Each call blocks up to 5 minutes, then returns the child's `status` on `children[0]`:
+
+- `in-progress` or `created` → poll again with the same arguments.
+- `completed`, `failed`, `cancelled`, `input-required`, or `permission-required` → stop looping and exit with the message below.
+
+If a call errors, retry it once. If it errors again, exit with the error text plus the delegation id and stop.
+
+## Exit message (fixed template)
+
+Return exactly this, filled in from the last `show_agent` response — nothing more:
+
+```
+Child agent <id> is done.
+
+**Repo:** <repoFullName>
+**Delegation id:** <id>
+**Status:** <status>
+
+Read the result with show_agent (id: "<id>").
+```
+
+For `input-required` or `permission-required`, replace "is done." with "needs attention." and keep everything else identical.
+
+Do not summarize, quote, or describe the child's work. Do not include log lines. The main agent reads the result itself via `show_agent`.

package/agents/polygraph-init-subagent.md

@@ -0,0 +1,157 @@
+---
+
+name: polygraph-init-subagent
+description: Discovers candidate repositories or adds exact repository refs directly, initializes a Polygraph session, or fetches details of an existing session. Returns a structured summary of the session with repos, repository IDs, and session URL.
+
+---
+
+# Polygraph Init Subagent
+
+You are a Polygraph initialization subagent. Your job is to add exact repository refs directly when provided, discover candidate repositories when needed, initialize a Polygraph session, and return a structured summary.
+
+## Available Tools
+
+These tools are available via MCP and CLI. Use whichever is available in your environment.
+
+| MCP Tool | CLI Equivalent | Description |
+| --- | --- | --- |
+| `list_repos` | `polygraph repo list` | Discover candidate repositories. |
+| `start_session` | `polygraph session start --repo <ids>` | Initialize a NEW session with selected repositories. Only use when no `sessionId` was provided. |
+| `add_repo` | — | Attach repositories to an EXISTING session. Use when `sessionId` was provided and the session has no repos yet, or when the user wants to add more. |
+| `show_session` | `polygraph session show <id> [--details]` | Get full session details including URL, and use details when session summary, repo IDs, PR URLs, and PR descriptions are needed |
+
+## Input Parameters (from Main Agent)
+
+The main agent provides these parameters in the prompt:
+
+| Parameter              | Description                                                             |
+| ---------------------- | ----------------------------------------------------------------------- |
+| `sessionId`            | (Optional) If provided, use this session — never call `start_session`. If the session is empty, attach repos via `add_repo`. If it already has repos, just fetch details. |
+| `userContext`          | Description of what the user wants to do, to help select relevant repos |
+| `selectedRepoIds`      | (Optional) Pre-selected repository IDs or refs to include; skip repo selection |
+
+Additionally, the main agent may pass in repos via **MCP resource syntax** (e.g. `polygraph://repos/org/repo-name`).
+
+**Direct-add rule:** If `sessionId` is provided and the prompt names exact repositories to add by ID, short name, full name, GitHub `owner/repo` slug, URL-like slug, or MCP resource syntax, call `add_repo` directly with those refs in `repoIds`. Refs are not limited to organization repos — public open-source repos can be added by `owner/repo` slug or URL, even though they never appear in `list_repos`. Do NOT call `list_repos`, do NOT ask for candidates, and do NOT require candidate discovery first. Candidate discovery is account-repo-only; `list_repos` is only for discovery/filtering when the user does not know the exact repo or explicitly wants candidate selection.
+
+## Workflow
+
+### Decide which mode to run in
+
+Pick one branch up front based on whether `sessionId` was provided:
+
+1. **No `sessionId`** — create a new session. Run Step 1 → Step 2 → Step 3a (`start_session`) → Step 4 → Step 5.
+2. **`sessionId` provided, session already has repos, and the user did not ask to add more** — just inspect. Skip directly to Step 4 (`show_session`) → Step 5. Do NOT call `list_repos`, `start_session`, or `add_repo`.
+3. **`sessionId` provided, session has no repos, or user asked to add more** — attach repos to the existing session. First call `show_session` to confirm the current repo list. If exact repo refs were provided, skip Step 1 and Step 2, then call Step 3b (`add_repo`) directly with those refs. Otherwise run Step 1 → Step 2 → Step 3b (`add_repo`) → Step 4 → Step 5.
+
+**Hard rule:** if `sessionId` is provided, NEVER call `start_session` — that would create a brand-new session and orphan the one the parent is already in. Use `add_repo` instead.
+
+To distinguish modes 2 and 3, call `show_session(sessionId)` before deciding. If the session repository list is empty, or the parent agent explicitly asked you to add or discover more repos, proceed with mode 3; otherwise mode 2.
+
+### Step 1: Discover Candidate Repos
+
+**Skip this step** in mode 2 (existing session, already populated), or if repos were already provided via `selectedRepoIds`, exact repo refs, or MCP resource syntax and the user hasn't asked to discover more.
+
+Call `list_repos` to discover available candidate repositories:
+
+```
+list_repos()
+```
+
+`list_repos` accepts these optional parameters; set whichever apply. Refer to the tool schema for each parameter.
+
+- `connectedTo`: repo ID, name, or full name (e.g. `nrwl/ocean`); pair with `connectionType`
+- `connectionType`: `directly-upstream` | `directly-downstream` | `directly-both` (default) | `upstream` | `downstream` | `both`
+- `publishedPackages`, `consumedPackages`, `publishedApis`, `consumedApis`: arrays of package names / API paths
+- `nameFilter`: array of repo name patterns (e.g. `nrwl/*`)
+- `semanticQuery`: free-text description of the repositories you want
+
+This returns:
+
+- **`repos`**: Candidate account repositories, each with:
+  - `id`: Repository ID
+  - `name`: Repository name
+  - `repository`: Full repo name (e.g., `org/repo`)
+  - `provider`: VCS provider (e.g., `GITHUB`)
+
+Candidate entries do not include repository descriptions. For natural-language discovery, pass the user's intent in `semanticQuery` so the service can apply semantic matching internally.
+
+### Step 2: Select Relevant Repos
+
+**Skip this step** in mode 2 (existing session, already populated).
+
+If `selectedRepoIds` or exact repo refs were provided by the main agent, use those directly and skip selection.
+
+Otherwise, analyze the candidates using the `userContext` to determine which repos are relevant:
+
+1. Review each repo's `repository`, `name`, `provider`, and any relationship/filter metadata returned by the tool
+2. Match those fields and any requested filters against the `userContext` to identify relevant repos
+3. Select the repos that are relevant to the task
+4. When uncertain, include all candidates
+5. When the user described the task in natural language and the result is large, re-query with `semanticQuery` set to that description
+
+### Step 3: Initialize Polygraph Session or Attach Repos
+
+Pick the substep that matches the mode chosen above.
+
+#### Step 3a — `start_session` (mode 1: no `sessionId`)
+
+Call `start_session` to create a new session with the selected repositories:
+
+```
+start_session(selectedRepoIds: [...])
+```
+
+If no repos were filtered and all candidates should be included, pass every candidate repository ID in `selectedRepoIds`.
+
+#### Step 3b — `add_repo` (mode 3: existing empty session)
+
+Call `add_repo` to attach the selected repositories to the existing session — do NOT call `start_session`:
+
+```
+add_repo(sessionId: "<sessionId>", repoIds: [...])
+```
+
+`repoIds` may be repository IDs from discovery, or exact refs provided by the user: short name, full name, GitHub `owner/repo` slug, URL-like slug, or MCP resource syntax — including repos outside the organization, such as public open-source repos. For exact user-provided refs, pass the strings directly and do not call `list_repos` first.
+
+### Step 4: Get Session Details
+
+Call `show_session` to retrieve full session information. When joining an existing session to inspect prior work, request details if the tool exposes that option so the response includes repo IDs and PR descriptions:
+
+```
+show_session(sessionId: "<sessionId>", details: true)
+```
+
+### Step 5: Return Summary
+
+Return a structured summary in this format:
+
+```
+## Polygraph Session Initialized
+
+**Session ID:** <sessionId>
+**Session URL:** <polygraphSessionUrl>
+
+### Repositories in this session
+
+| Repo | Repository ID | Relationship |
+| --- | --- | --- |
+| REPO_FULL_NAME | REPOSITORY_ID | DIRECTION (distance: N) |
+
+### All Candidates Discovered
+(Only include this section if `list_repos` was called)
+
+| Repo | Repository ID | Selected |
+| --- | --- | --- |
+| REPO_FULL_NAME | REPOSITORY_ID | Yes/No |
+```
+
+## Important Notes
+
+- Do NOT delegate work to repos — that is the main agent's responsibility
+- Do NOT call `spawn_agent` — only initialize the session, attach repos, or fetch existing session details
+- **NEVER call `start_session` when `sessionId` was provided.** Creating a new session would orphan the one the parent agent is operating in. Use `add_repo` to populate an empty existing session instead.
+- If `sessionId` is provided and the session already has repos, skip discovery and selection unless the user asked to add more repos
+- For exact repo refs, call `add_repo` directly and skip discovery
+- If `start_session` or `add_repo` fails, return the error details so the main agent can handle it
+- Always call `show_session` after init/add (or directly when joining an existing session) to get the session URL

package/agents/session-debrief.md

@@ -0,0 +1,28 @@
+---
+
+name: session-debrief
+description: Analyze the raw logs of one or more past Polygraph sessions and return a structured, rank-ordered debrief for the current task. Launch as a background agent with a ranked list of relevant Polygraph session IDs/lines and a one-paragraph statement of the current task; it invokes the session-debrief skill, pulls parent and child transcripts via the polygraph CLI, and returns one consolidated debrief. Read-only with respect to the inspected sessions.
+is_background: true
+
+---
+
+# Session Debrief Subagent
+
+You produce debriefs of PAST Polygraph sessions so a parent agent working on a NEW task can decide what context is relevant. You run in the background and speed matters — the parent keeps working while it waits and folds your debrief in whenever it lands.
+
+You are READ-ONLY with respect to the inspected sessions: never resume them, never spawn agents into them, never push branches, create PRs, or update their descriptions.
+
+## Input Parameters (from Main Agent)
+
+The main agent provides these in the prompt:
+
+| Parameter     | Description                                                                                       |
+| ------------- | ------------------------------------------------------------------------------------------------ |
+| `sessions`    | A ranked list of relevant Polygraph sessions (IDs/lines, most relevant first, with optional titles/URLs) |
+| `currentTask` | A one-paragraph statement of the task the parent is currently working on                         |
+
+## What to do
+
+Invoke the `session-debrief` skill and follow its procedure and output template exactly. Pass through the ranked session list and the current-task statement you received. The skill is the single source of truth for how to pull transcripts via the polygraph CLI, how to fan out across multiple sessions, and how to format each debrief section — do not reinvent or duplicate that procedure here.
+
+Return the consolidated, rank-ordered debrief as your final message.

package/bin/polygraph-cursor-plugin.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+// source/cursor/lib/installer.mjs
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var PLUGIN_NAME = "polygraph";
+var PAYLOAD_ENTRIES = [
+  "plugin.json",
+  "skills",
+  "agents",
+  "hooks",
+  "package.json",
+  "README.md",
+  "LICENSE"
+];
+function getPackageRootFromMetaUrl(metaUrl) {
+  return resolve(dirname(fileURLToPath(metaUrl)), "..");
+}
+function resolveUserHome(env = process.env) {
+  const userHome = env.HOME?.trim() || homedir();
+  return resolve(expandHome(userHome, env));
+}
+function getPluginInstallPath(userHome) {
+  return join(userHome, ".polygraph", "plugins", "cursor", PLUGIN_NAME);
+}
+function expandHome(value, env) {
+  if (value === "~" || value.startsWith("~/")) {
+    const home = env.HOME?.trim() || homedir();
+    return join(home, value.slice(1));
+  }
+  return value;
+}
+function loadPackageMetadata(packageRoot) {
+  const packageJsonPath = join(packageRoot, "package.json");
+  const pluginManifestPath = join(packageRoot, "plugin.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(`Missing package.json at ${packageJsonPath}`);
+  }
+  if (!existsSync(pluginManifestPath)) {
+    throw new Error(`Missing Cursor plugin manifest at ${pluginManifestPath}`);
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  const pluginManifest = JSON.parse(readFileSync(pluginManifestPath, "utf8"));
+  if (pluginManifest.name !== PLUGIN_NAME) {
+    throw new Error(
+      `Expected plugin.json name to be "${PLUGIN_NAME}", received "${pluginManifest.name ?? "undefined"}"`
+    );
+  }
+  if (!packageJson.version) {
+    throw new Error(`Missing package version in ${packageJsonPath}`);
+  }
+  return { version: packageJson.version };
+}
+function readInstalledVersion(pluginPath) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(pluginPath, "package.json"), "utf8")
+    );
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function isInstallComplete(pluginPath) {
+  return existsSync(join(pluginPath, "plugin.json")) && existsSync(join(pluginPath, "skills"));
+}
+function installPlugin({ packageRoot, env = process.env, force = false }) {
+  const { version } = loadPackageMetadata(packageRoot);
+  const userHome = resolveUserHome(env);
+  const pluginPath = getPluginInstallPath(userHome);
+  const installAlreadyPresent = existsSync(pluginPath);
+  const previousVersion = installAlreadyPresent ? readInstalledVersion(pluginPath) : null;
+  const complete = installAlreadyPresent && isInstallComplete(pluginPath);
+  const versionMismatch = installAlreadyPresent && previousVersion !== version;
+  const shouldCopy = !installAlreadyPresent || force || versionMismatch || !complete;
+  if (shouldCopy) {
+    rmSync(pluginPath, { recursive: true, force: true });
+    mkdirSync(pluginPath, { recursive: true });
+    for (const entry of PAYLOAD_ENTRIES) {
+      const src = join(packageRoot, entry);
+      if (existsSync(src)) {
+        cpSync(src, join(pluginPath, entry), { recursive: true });
+      }
+    }
+  }
+  return {
+    ok: true,
+    action: "install",
+    plugin: PLUGIN_NAME,
+    version,
+    previousVersion,
+    pluginPath,
+    copied: shouldCopy,
+    overwritten: installAlreadyPresent && force,
+    pluginUpdated: installAlreadyPresent && versionMismatch && !force
+  };
+}
+function checkInstall({ packageRoot = null, env = process.env } = {}) {
+  const userHome = resolveUserHome(env);
+  const pluginPath = getPluginInstallPath(userHome);
+  const installed = existsSync(pluginPath) && isInstallComplete(pluginPath);
+  const installedVersion = installed ? readInstalledVersion(pluginPath) : null;
+  const packageVersion = packageRoot ? loadPackageMetadata(packageRoot).version : null;
+  return {
+    ok: installed,
+    plugin: PLUGIN_NAME,
+    pluginPath,
+    installed,
+    installedVersion,
+    packageVersion,
+    upToDate: installed && packageVersion !== null ? installedVersion === packageVersion : null
+  };
+}
+
+// source/cursor/bin/polygraph-cursor-plugin.mjs
+var usage = `Usage:
+  npx @polygraph/cursor-plugin
+  npx @polygraph/cursor-plugin install [--force] [--json]
+  npx @polygraph/cursor-plugin check [--json]
+
+The install command materializes the plugin payload to a directory the
+Polygraph CLI passes to cursor-agent via --plugin-dir on every launch.
+Manual runs can load it the same way:
+
+  cursor-agent --plugin-dir <plugin path>`;
+async function main() {
+  const args = process.argv.slice(2);
+  let command = "install";
+  let json = false;
+  let force = false;
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (arg === "install" || arg === "check") {
+      command = arg;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      console.log(usage);
+      return;
+    }
+    throw new Error(`Unknown argument: ${arg}
+
+${usage}`);
+  }
+  if (command === "check" && force) {
+    throw new Error("--force is only supported with the install command");
+  }
+  const packageRoot = getPackageRootFromMetaUrl(import.meta.url);
+  const result = command === "check" ? checkInstall({ packageRoot, env: process.env }) : installPlugin({ packageRoot, env: process.env, force });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (command === "check") {
+    if (result.ok) {
+      console.log("Polygraph Cursor plugin is materialized.");
+      console.log(`Plugin path: ${result.pluginPath}`);
+      console.log(`Installed version: ${result.installedVersion ?? "unknown"}`);
+    } else {
+      console.error(
+        `Polygraph Cursor plugin check failed: no complete payload at ${result.pluginPath}.`
+      );
+    }
+  } else {
+    console.log(`Materialized Polygraph Cursor plugin ${result.version}.`);
+    console.log(`Plugin path: ${result.pluginPath}`);
+    console.log(
+      `The Polygraph CLI loads it automatically; manual runs: cursor-agent --plugin-dir ${result.pluginPath}`
+    );
+  }
+  if (command === "check" && !result.ok) {
+    process.exitCode = 1;
+  }
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`polygraph-cursor-plugin failed: ${message}`);
+  process.exitCode = 1;
+});