@polygraph/codex-plugin 0.4.32 → 0.4.34

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "polygraph",
-  "version": "0.4.32",
+  "version": "0.4.34",
   "description": "AI agent skills and subagents for Polygraph multi-repo coordination",
   "author": {
     "name": "Narwhal Technologies Inc",

package/.mcp.json

@@ -5,7 +5,10 @@
       "command": "npx",
       "args": [
         "@polygraph/mcp@latest"
-      ]
+      ],
+      "env": {
+        "POLYGRAPH_AGENT_TYPE": "codex"
+      }
     }
   }
 }

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/hooks/record-session-mapping.mjs

@@ -18,17 +18,58 @@
 //     injects hook stdout into the model context); never exits non-zero.
 
 import {
+  appendFileSync,
   existsSync,
   mkdirSync,
   readFileSync,
   realpathSync,
   renameSync,
+  statSync,
   writeFileSync,
 } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+const HOOK_LOG_MAX_BYTES = 5 * 1024 * 1024;
+
+// Append a one-line JSON record of a hook failure to ~/.polygraph/logs/hooks.log.
+// This hook swallows its errors silently and must never write to stdout (Claude
+// Code injects hook stdout into the model context), so this on-disk log is the
+// only record that something went wrong. The logger is itself failure-proof.
+function logHookFailure(
+  hook,
+  error,
+  meta = {},
+  home = process.env.HOME?.trim() || homedir()
+) {
+  try {
+    const logsDir = join(home, '.polygraph', 'logs');
+    mkdirSync(logsDir, { recursive: true });
+    const logFile = join(logsDir, 'hooks.log');
+
+    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.
+  }
+}
+
 function readStdin() {
   try {
     return readFileSync(0, 'utf8');
@@ -147,8 +188,10 @@ export function main() {
       // process.ppid is the harness pid when the hook is spawned as a child.
       pid: process.ppid,
     });
-  } catch {
-    // Silent — a broken hook must never break the agent session.
+  } catch (error) {
+    // Silent toward the agent — a broken hook must never break the session —
+    // but record it so failures are not invisible.
+    logHookFailure(`${process.argv[2] || 'unknown'}:record-session-mapping`, error);
   }
 }
 

package/hooks/reinject-polygraph-context.mjs

@@ -18,7 +18,16 @@
 //
 // Outside a Polygraph session (no matching sidecar) the hook is a silent no-op.
 
-import { readFileSync, readdirSync, existsSync, realpathSync } from 'node:fs';
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  statSync,
+} from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -27,6 +36,45 @@ export function polygraphRoot(home = homedir()) {
   return path.join(home, '.polygraph');
 }
 
+const HOOK_LOG_MAX_BYTES = 5 * 1024 * 1024;
+
+// Append a one-line JSON record of a hook failure to ~/.polygraph/logs/hooks.log.
+// This hook must never write to stdout except its hookSpecificOutput payload
+// (Claude Code injects hook stdout into the model context), so this on-disk log
+// is the only record that something went wrong. The logger is failure-proof.
+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');
+
+    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.
+  }
+}
+
 function readJson(file) {
   try {
     return JSON.parse(readFileSync(file, 'utf8'));
@@ -115,30 +163,36 @@ function readStdin() {
 }
 
 export function main() {
-  let payload = {};
-  const raw = readStdin();
-  if (raw) {
-    try {
-      payload = JSON.parse(raw);
-    } catch {
-      payload = {};
+  let agentSessionId = '';
+  try {
+    let payload = {};
+    const raw = readStdin();
+    if (raw) {
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        payload = {};
+      }
     }
-  }
 
-  const agentSessionId =
-    payload.session_id || process.env.CLAUDE_CODE_SESSION_ID || '';
+    agentSessionId =
+      payload.session_id || process.env.CLAUDE_CODE_SESSION_ID || '';
 
-  const context = buildPolygraphContext(agentSessionId);
-  if (!context) return; // not a Polygraph session — stay silent
+    const context = buildPolygraphContext(agentSessionId);
+    if (!context) return; // not a Polygraph session — stay silent
 
-  process.stdout.write(
-    JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: 'SessionStart',
-        additionalContext: context,
-      },
-    })
-  );
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'SessionStart',
+          additionalContext: context,
+        },
+      })
+    );
+  } catch (error) {
+    // Never let a hook failure surface to the agent; just record it.
+    logHookFailure('reinject-polygraph-context', error, { agentSessionId });
+  }
 }
 
 // Run only when executed directly as a hook, not when imported (e.g. by tests).

package/package.json

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