@polygraph/claude-plugin 0.4.28 → 0.4.30

package/.claude-plugin/plugin.json

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

package/agents/polygraph-init-subagent.md

@@ -22,7 +22,7 @@ These tools are available via MCP and CLI. Use whichever is available in your en
 
 | MCP Tool | CLI Equivalent | Description |
 | --- | --- | --- |
-| `list_repos` | `polygraph repo list` | Discover candidate repositories with descriptions and graph relationships |
+| `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 |
@@ -65,16 +65,22 @@ 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:
 
-- **`initiator`**: The current repository, or `null` if not running from a specific repo
-- **`candidates`**: Candidate account repositories, each with:
+- **`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`)
   - `description`: AI-generated description of what the repository does (may be null)
-  - `vcsConfiguration.repositoryFullName`: Full repo name (e.g., `org/repo`)
-  - `graphRelationship`: How this repository relates to the initiator (`distance`, `direction`, `path`), or `null` if the repository is not in the dependency graph. When `initiator` is null, `graphRelationship` will be null for all candidates.
-- **`dependencyGraph`**: Graph of repository dependency `edges` (always available, independent of initiator)
 
 ### Step 2: Select Relevant Repos
 
@@ -84,14 +90,11 @@ If `selectedRepoIds` or exact repo refs were provided by the main agent, use tho
 
 Otherwise, analyze the candidates using the `userContext` to determine which repos are relevant:
 
-1. Read each candidate's `description` and `graphRelationship`
-2. Match against the `userContext` — consider:
-   - Repository descriptions that mention relevant functionality
-   - Graph relationships (closer repos are more likely relevant); note that `graphRelationship` may be `null` for repositories not in the dependency graph — use their `description` to assess relevance
-   - When `graphRelationship` is null for all candidates (no initiator), rely on `description` fields and the raw `dependencyGraph` edges for selection instead
-   - Direction (upstream/downstream based on the nature of the change)
-3. Select only the repos that are clearly relevant to the task
-4. If uncertain which repos are relevant, include all candidates (safe default)
+1. Read each repo's `description`
+2. Match repo descriptions 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
 
@@ -147,11 +150,6 @@ Return a structured summary in this format:
 | Repo | Repository ID | Description | Selected |
 | --- | --- | --- | --- |
 | REPO_FULL_NAME | REPOSITORY_ID | DESCRIPTION | Yes/No |
-
-### Initiator
-(Only include this section if `list_repos` was called and `initiator` is non-null)
-- **Name:** <initiator name>
-- **Repo:** <initiator repo full name>
 ```
 
 ## Important Notes

package/hooks/hooks.json

@@ -18,6 +18,10 @@
           {
             "type": "command",
             "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/reinject-polygraph-context.mjs"
+          },
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/record-session-mapping.mjs claude"
           }
         ]
       }

package/hooks/record-session-mapping.mjs

@@ -0,0 +1,172 @@
+// Hidden SessionStart hook — records an agent-capture mapping file that binds
+// this agent's session id to the Polygraph session id in the environment.
+// Used by both the Claude Code plugin (agentType=claude) and the Codex plugin
+// (agentType=codex). The agentType is passed as the first CLI argument so the
+// same script ships in both plugin artifacts.
+//
+// File contract (must match the Polygraph CLI reader exactly):
+//   ~/.polygraph/sidecars/<POLYGRAPH_SESSION_ID>/mapping-<agentType>-<agentSessionId>.json
+//
+// Behaviour:
+//   - Silent no-op when POLYGRAPH_SESSION_ID is unset.
+//   - Silent no-op when POLYGRAPH_CHILD_AGENT is set (child agents must not
+//     register themselves as parents).
+//   - Atomic write: write to <path>.tmp-<pid>, then rename over final path.
+//   - Refresh: when a valid prior mapping for the same session already exists,
+//     preserve its firstSeenAt and only update lastSeenAt + mutable fields.
+//   - All failures are silently swallowed; never writes to stdout (Claude Code
+//     injects hook stdout into the model context); never exits non-zero.
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function tryParseJson(str) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return null;
+  }
+}
+
+function sanitizeFilename(str) {
+  return str.replace(/[^A-Za-z0-9._-]/g, '_');
+}
+
+/**
+ * Write (or refresh) the agent-capture mapping file.
+ *
+ * @param {object} opts
+ * @param {string} opts.agentType         'claude' | 'codex'
+ * @param {string} opts.agentSessionId    The harness's own session id.
+ * @param {string} opts.polygraphSessionId Value of POLYGRAPH_SESSION_ID.
+ * @param {string} opts.cwd               Agent working directory.
+ * @param {string} [opts.transcriptPath]  Absolute transcript path; omit when unknown.
+ * @param {number} [opts.pid]             Harness process id; omit when not knowable.
+ * @param {string} [home]                 Override HOME for testing.
+ */
+export function writeCaptureMapping(
+  { agentType, agentSessionId, polygraphSessionId, cwd, transcriptPath, pid },
+  home = process.env.HOME?.trim() || homedir()
+) {
+  const sidecarDir = join(home, '.polygraph', 'sidecars', polygraphSessionId);
+  mkdirSync(sidecarDir, { recursive: true });
+
+  const filenamePart = sanitizeFilename(`${agentType}-${agentSessionId}`);
+  const finalPath = join(sidecarDir, `mapping-${filenamePart}.json`);
+  const tmpPath = `${finalPath}.tmp-${process.pid}`;
+
+  const now = Date.now();
+
+  // Refresh semantics: preserve firstSeenAt from a valid prior mapping.
+  let firstSeenAt = now;
+  if (existsSync(finalPath)) {
+    const existing = tryParseJson(readFileSync(finalPath, 'utf8'));
+    if (
+      existing !== null &&
+      existing.version === 1 &&
+      existing.polygraphSessionId === polygraphSessionId &&
+      existing.agentSessionId === agentSessionId &&
+      Number.isFinite(existing.firstSeenAt)
+    ) {
+      firstSeenAt = existing.firstSeenAt;
+    }
+  }
+
+  const mapping = {
+    version: 1,
+    polygraphSessionId,
+    agentType,
+    agentSessionId,
+    cwd,
+    ...(transcriptPath != null ? { transcriptPath } : {}),
+    ...(pid != null ? { pid } : {}),
+    source: 'hook',
+    firstSeenAt,
+    lastSeenAt: now,
+  };
+
+  writeFileSync(tmpPath, JSON.stringify(mapping, null, 2) + '\n');
+  renameSync(tmpPath, finalPath);
+}
+
+export function main() {
+  try {
+    const polygraphSessionId = process.env.POLYGRAPH_SESSION_ID;
+    if (!polygraphSessionId) return;
+    if (process.env.POLYGRAPH_CHILD_AGENT) return;
+
+    const agentType = process.argv[2];
+    if (!agentType) return;
+
+    let payload = {};
+    const raw = readStdin();
+    if (raw) {
+      const parsed = tryParseJson(raw);
+      if (parsed !== null) payload = parsed;
+    }
+
+    const agentSessionId =
+      typeof payload.session_id === 'string' ? payload.session_id : '';
+    if (!agentSessionId) return;
+
+    const cwd =
+      typeof payload.cwd === 'string' && payload.cwd
+        ? payload.cwd
+        : process.cwd();
+
+    // transcript_path is present on Claude/Codex payloads; may be null — omit
+    // the field when absent or null rather than writing null into the mapping.
+    const transcriptPath =
+      typeof payload.transcript_path === 'string' && payload.transcript_path
+        ? payload.transcript_path
+        : undefined;
+
+    writeCaptureMapping({
+      agentType,
+      agentSessionId,
+      polygraphSessionId,
+      cwd,
+      transcriptPath,
+      // 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.
+  }
+}
+
+// Run only when executed directly as a hook, not when imported (e.g. by tests).
+// realpathSync both sides so the check holds when the plugin lives under a
+// symlinked path (e.g. macOS /tmp -> /private/tmp).
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return (
+      realpathSync(process.argv[1]) ===
+      realpathSync(fileURLToPath(import.meta.url))
+    );
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main();
+}

package/package.json

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

package/skills/polygraph/SKILL.md

@@ -21,7 +21,7 @@ Polygraph functionality is available via both MCP tools and CLI commands. Use wh
 
 | MCP Tool | CLI Equivalent | Description |
 | --- | --- | --- |
-| `list_repos` | `polygraph repo list` | Discover candidate repositories with descriptions and graph relationships |
+| `list_repos` | `polygraph repo list` | Discover candidate repositories. |
 | `start_session` | `polygraph session start --repo <ids>` | Initialize a Polygraph session with selected repositories |
 | `spawn_agent` | — | Start a new child task or send a follow-up to an active task in another repository. Input: `{ sessionId, repo, instruction, context? }`. Output: `{ taskId, message, status: 'delegated' }`. Follow-up routing is automatic: if the repo already has an active child task, the instruction is delivered to it as a follow-up message; otherwise a new child run starts. A repo has at most one active child at a time. A session resume or reconstruction is read-only context restoration; after resuming, do not use `spawn_agent` to continue changes unless the user explicitly asks for changes. |
 | `show_agent` | — | Poll flat per-child status for the session. Output: `{ children: PolygraphChildStatusItem[] }` where each item exposes `repositoryId`, `repoFullName`, `status`, `lastOutputLines`, `durationMs`, `instruction`, `agentType?`, `inputRequiredQuestion?`. `status` is an AcpRunStatus: `'created' \| 'in-progress' \| 'input-required' \| 'permission-required' \| 'completed' \| 'failed' \| 'cancelled'` (British double-L on `'cancelled'`). `inputRequiredQuestion` is populated only when `status === 'input-required'`. |