@polygraph/opencode-plugin 0.4.32 → 0.4.34

package/README.md

@@ -8,7 +8,7 @@
 <h1 align="center">Polygraph Skills</h1>
 
 <p align="center">
-  AI agent skills and subagents for <a href="https://nx.dev/features/polygraph">Polygraph</a> multi-repo coordination.
+  AI agent skills and subagents for <a href="https://trypolygraph.com/">Polygraph</a> — the meta-harness for maximum agentic autonomy, giving agents visibility across every repo and memory that survives every session.
 </p>
 
 <p align="center">
@@ -23,7 +23,17 @@
 
 ## What is Polygraph?
 
-Polygraph is a standalone product for coordinating changes across multiple repositories. It lets AI agents delegate work to child agents in other repos, monitor CI across repos, and manage multi-repo sessions.
+Polygraph is a 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.
 
 ## Skills
 
@@ -36,66 +46,6 @@ Polygraph is a standalone product for coordinating changes across multiple repos
 - **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
 
-## Codex Installer
-
-The publishable Codex package now exposes an explicit installer CLI:
-
-```sh
-npx @polygraph/codex-plugin
-```
-
-That command copies the packaged Codex plugin into:
-
-```text
-~/.agents/plugins/polygraph
-```
-
-installs the packaged custom Codex subagents into:
-
-```text
-$CODEX_HOME/agents
-```
-
-updates the personal Codex marketplace at:
-
-```text
-~/.agents/plugins/marketplace.json
-```
-
-so the `polygraph` plugin points at `./.agents/plugins/polygraph`, and enables the plugin in:
-
-```text
-$CODEX_HOME/config.toml
-```
-
-`CODEX_HOME` defaults to `~/.codex` when unset.
-
-To verify an install, run:
-
-```sh
-npx @polygraph/codex-plugin check
-```
-
-## OpenCode Plugin
-
-The publishable OpenCode package exposes the skills and subagents through OpenCode's native plugin system. Add it to `opencode.json`:
-
-```json
-{
-  "plugin": ["@polygraph/opencode-plugin"]
-}
-```
-
-For repeatable installs, pin the npm version:
-
-```json
-{
-  "plugin": ["@polygraph/opencode-plugin@0.4.18"]
-}
-```
-
-The plugin adds its packaged `skills/` directory to OpenCode's skill paths and registers the packaged Markdown agents as `subagent` entries in OpenCode config during startup.
-
 ## Development
 
 ```sh
@@ -118,10 +68,8 @@ For the strictest release flow, do not allow direct `npm publish` for the truste
 
 ## Learn More
 
-- **[Polygraph](https://nx.dev/features/polygraph)** — Multi-repo coordination with Polygraph
+- **[Polygraph](https://trypolygraph.com/)** — The meta-harness for maximum agentic autonomy
 - **[@polygraph/mcp](https://www.npmjs.com/package/@polygraph/mcp)** — The MCP server that powers Polygraph tools
-- **[Nx AI Agent Skills](https://github.com/nrwl/nx-ai-agents-config)** — The main Nx AI agent skills repo
-
 ## License
 
 License information is defined in the package metadata.

package/agent-capture-mapping.mjs

@@ -17,7 +17,15 @@
 //   - Refresh: preserves firstSeenAt when a valid prior mapping exists.
 //   - All failures are silently swallowed.
 
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 
@@ -25,6 +33,55 @@ function sanitizeMappingFilename(str) {
   return str.replace(/[^A-Za-z0-9._-]/g, '_');
 }
 
+const HOOK_LOG_MAX_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Append a one-line JSON record of a hook failure to ~/.polygraph/logs/hooks.log.
+ *
+ * Hooks otherwise swallow their errors silently (a broken hook must never break
+ * the agent session) and must never write to stdout — so this on-disk log is the
+ * only record that something went wrong. The logger is itself failure-proof:
+ * any error here is swallowed so a logging bug can never break a hook.
+ *
+ * @param {string} hook        Identifier for the failing hook.
+ * @param {unknown} error      The thrown value.
+ * @param {object} [meta]      Extra context to record (sessionID, etc.).
+ * @param {string} [home]      Override HOME for testing.
+ */
+export function logHookFailure(
+  hook,
+  error,
+  meta = {},
+  home = process.env.HOME?.trim() || homedir()
+) {
+  try {
+    const logsDir = path.join(home, '.polygraph', 'logs');
+    mkdirSync(logsDir, { recursive: true });
+    const logFile = path.join(logsDir, 'hooks.log');
+
+    // Best-effort rotation so the log can't grow unbounded.
+    try {
+      if (statSync(logFile).size > HOOK_LOG_MAX_BYTES) {
+        renameSync(logFile, `${logFile}.1`);
+      }
+    } catch {
+      // no prior log, or rotation failed — ignore
+    }
+
+    const entry = {
+      time: new Date().toISOString(),
+      hook,
+      pid: process.pid,
+      ...meta,
+      error: error instanceof Error ? error.message : String(error),
+      ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+    };
+    appendFileSync(logFile, JSON.stringify(entry) + '\n');
+  } catch {
+    // Logging must never throw — a failing logger must not break the hook.
+  }
+}
+
 /**
  * Write (or refresh) the agent-capture mapping for an OpenCode session.
  * Reads POLYGRAPH_SESSION_ID and POLYGRAPH_CHILD_AGENT from process.env.
@@ -84,7 +141,9 @@ export function writeAgentCaptureMapping(
 
     writeFileSync(tmpPath, JSON.stringify(mapping, null, 2) + '\n');
     renameSync(tmpPath, finalPath);
-  } catch {
-    // Silent — a broken plugin hook must never break the agent session.
+  } catch (error) {
+    // Silent toward the agent — a broken plugin hook must never break the
+    // session — but record it so failures are not invisible.
+    logHookFailure('opencode:writeAgentCaptureMapping', error, { agentSessionId }, home);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polygraph/opencode-plugin",
-  "version": "0.4.32",
+  "version": "0.4.34",
   "description": "AI agent skills and subagents for Polygraph multi-repo coordination",
   "license": "UNLICENSED",
   "private": false,

package/server.js

@@ -14,7 +14,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import yaml from 'js-yaml';
 
-import { writeAgentCaptureMapping } from './agent-capture-mapping.mjs';
+import { writeAgentCaptureMapping, logHookFailure } from './agent-capture-mapping.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = __dirname;
@@ -39,11 +39,16 @@ export const PolygraphPlugin = async () => {
     },
 
     'shell.env': async (input, output) => {
-      output.env.POLYGRAPH_AGENT_SESSION_ID = input.sessionID;
-      output.env.POLYGRAPH_AGENT_TYPE = 'opencode';
-      // Record the agent-capture mapping so the Polygraph CLI can bind
-      // parent-log capture deterministically for this session.
-      writeAgentCaptureMapping(input.sessionID);
+      try {
+        output.env.POLYGRAPH_AGENT_SESSION_ID = input.sessionID;
+        output.env.POLYGRAPH_AGENT_TYPE = 'opencode';
+        // Record the agent-capture mapping so the Polygraph CLI can bind
+        // parent-log capture deterministically for this session.
+        writeAgentCaptureMapping(input.sessionID);
+      } catch (error) {
+        // Never let a hook failure break the OpenCode session; just record it.
+        logHookFailure('opencode:shell.env', error, { sessionID: input?.sessionID });
+      }
     },
 
     // OpenCode has no SessionStart hook, but the Polygraph CLI already seeds the
@@ -52,13 +57,20 @@ export const PolygraphPlugin = async () => {
     // before each compaction; the note is appended to the summarization prompt
     // (best-effort — we trust the model to keep the id + repos in the summary).
     'experimental.session.compacting': async (input, output) => {
-      const note = polygraphCompactionNote(input.sessionID);
-      if (note) {
-        output.context.push(note);
+      try {
+        const note = polygraphCompactionNote(input.sessionID);
+        if (note) {
+          output.context.push(note);
+        }
+        // Refresh the mapping on compaction (same refresh semantics as Claude/Codex
+        // SessionStart hooks firing on 'compact').
+        writeAgentCaptureMapping(input.sessionID);
+      } catch (error) {
+        // Never let a hook failure break the OpenCode session; just record it.
+        logHookFailure('opencode:session.compacting', error, {
+          sessionID: input?.sessionID,
+        });
       }
-      // Refresh the mapping on compaction (same refresh semantics as Claude/Codex
-      // SessionStart hooks firing on 'compact').
-      writeAgentCaptureMapping(input.sessionID);
     },
   };
 };