@plot-ai/linux-x64-musl 0.0.2 → 0.0.4

package/bin/CHANGELOG.md

@@ -1,5 +1,5 @@
 # changelog
 
-## 0.0.2
+## 0.0.4
 
 - packaged plot-ai release

package/bin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plot-ai/linux-x64-musl",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "piConfig": {
     "name": "plot",
     "configDir": ".plot"

package/bin/tracker/beads/skills/plot-beads-tracker/SKILL.md

@@ -0,0 +1,241 @@
+---
+name: plot-beads-tracker
+description: "beads issue state management for plot orchestration. hybrid model: native beads status for primary lifecycle, labels for orchestrator sub-states (rework, merging). workpad comment lifecycle and bd queries. use when moving issues between states, creating/updating workpad comments, or querying issue status."
+---
+
+# plot-beads-tracker
+
+manages issue state and progress tracking for the plot orchestrator via beads status, labels, and comments.
+
+use `bd` for all tracker operations. the git/PR lifecycle uses `gh` separately.
+
+## state model
+
+beads uses a hybrid state model with two layers:
+
+- **status** (native beads lifecycle): `open`, `in_progress`, `blocked`, `deferred`, `closed`
+- **labels** (orchestrator sub-states): `plot:rework`, `plot:merging`
+
+the orchestrator checks labels first. if a configured label exists on the issue, it becomes the routing state. otherwise the native beads status is the state.
+
+```
+                  ┌─────────┐
+                  │  open    │  agent picks up, starts work
+                  └────┬────┘
+                       │ bd update <id> --status in_progress
+                       ▼
+                ┌─────────────┐
+                │ in_progress  │  agent implements, pushes PR
+                └──────┬──────┘
+                       │ bd update <id> --status blocked
+                       ▼
+                  ┌─────────┐
+                  │ blocked  │  human reviews PR
+                  └────┬────┘
+                       │
+            ┌──────────┼──────────┐
+            ▼          ▼          ▼
+     ┌────────────┐  ┌─────────────────┐  ┌────────┐
+     │plot:rework │  │  plot:merging    │  │closed  │
+     │(label)     │  │  (label)        │  │(reject)│
+     └─────┬──────┘  └───────┬─────────┘  └────────┘
+           │                 │
+           │ agent fixes,    │ agent merges PR,
+           │ removes label,  │ removes label,
+           │ → blocked       │ closes issue
+           │                 │
+           ▼                 ▼
+      ┌─────────┐      ┌────────┐
+      │ blocked  │      │ closed │
+      └─────────┘      └────────┘
+```
+
+## state transitions
+
+```bash
+# open → in_progress (starting work)
+bd update <id> --status in_progress
+
+# in_progress → blocked (PR ready for review)
+bd update <id> --status blocked
+
+# human approves → add merging label (human does this)
+bd label add <id> plot:merging
+
+# human requests changes → add rework label (human does this)
+bd label add <id> plot:rework
+
+# plot:rework → blocked (rework complete, remove label first)
+bd label remove <id> plot:rework
+bd update <id> --status blocked
+
+# plot:merging → closed (PR merged, remove label first)
+bd label remove <id> plot:merging
+bd close <id> -r "completed"
+
+# reopen closed → in_progress
+bd reopen <id> -r "needs rework"
+```
+
+## available states
+
+| source | state          | meaning                     | agent action                                          |
+| ------ | -------------- | --------------------------- | ----------------------------------------------------- |
+| status | `open`         | queued for work             | move to `in_progress`, start implementation           |
+| status | `in_progress`  | implementation underway     | continue implementation, push PR, move to `blocked`   |
+| status | `blocked`      | waiting on human review     | do nothing, wait                                      |
+| status | `deferred`     | intentionally postponed     | do nothing, wait                                      |
+| label  | `plot:rework`  | reviewer requested changes  | address feedback, remove label, move to `blocked`     |
+| label  | `plot:merging` | human approved PR           | merge PR, remove label, close issue                   |
+| status | `closed`       | terminal                    | stop                                                  |
+
+workflow routing:
+
+- dispatch_states: `open`, `in_progress`, `plot:rework`, `plot:merging`
+- parked_states: `blocked`, `deferred`
+- terminal_states: `closed`
+
+## workpad comment
+
+a persistent beads comment used as a living scratchpad across agent sessions.
+
+### find current workpad
+
+comments are append-only. there is no edit-in-place. the current workpad is the latest comment whose body starts with `## Plot Workpad`.
+
+```bash
+bd comments <id> --json
+```
+
+scan the returned comments and pick the latest one starting with `## Plot Workpad`.
+
+if none exists, create one.
+
+### create workpad
+
+write the full workpad body to a temp file, then add it as a comment:
+
+````bash
+cat > /tmp/workpad.md <<'WORKPAD'
+## Plot Workpad
+
+```text
+<workspace-id>@<short-sha>
+```
+
+### Plan
+- [ ] 1. <task>
+
+### Acceptance Criteria
+- [ ] <criterion>
+
+### Validation
+- [ ] targeted tests: `<command>`
+
+### Latest Attempt Summary
+- changed: <files or none>
+- validated: <commands + outcome>
+- failed: <remaining failure or none>
+- blocked: <blocker or none>
+
+### Notes
+- <durable context>
+WORKPAD
+
+bd comments add <id> -f /tmp/workpad.md
+````
+
+### update workpad
+
+do not try to edit an old comment. add a new full workpad comment with the complete updated body.
+
+````bash
+cat > /tmp/workpad.md <<'WORKPAD'
+...full updated workpad body...
+WORKPAD
+
+bd comments add <id> -f /tmp/workpad.md
+````
+
+### rules
+
+- treat the latest `## Plot Workpad` comment as canonical
+- never rely on older workpad comments once a newer one exists
+- update the workpad after every meaningful milestone
+- never leave completed items unchecked
+- include workspace id and short sha at top: `<workspace-id>@<short-sha>`
+- keep the full workpad body in each update so the latest comment is self-contained
+
+## workpad template
+
+````markdown
+## Plot Workpad
+
+```text
+<workspace-id>@<short-sha>
+```
+
+### Plan
+- [ ] 1. Parent task
+  - [ ] 1.1 Child task
+- [ ] 2. Parent task
+
+### Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+### Validation
+- [ ] targeted tests: `<command>`
+
+### Latest Attempt Summary
+- changed: <files or none>
+- validated: <commands + outcome>
+- failed: <remaining failure or none>
+- blocked: <blocker or none>
+
+### Notes
+- <short durable context>
+
+````
+
+## issue queries
+
+```bash
+# full issue details
+bd show <id> --json
+
+# all comments (for workpad lookup)
+bd comments <id> --json
+
+# list by status
+bd list --status open --json
+bd list --status in_progress --json
+bd list --status blocked --json
+
+# list by label
+bd list --label plot:rework --json
+bd list --label plot:merging --json
+
+# ready work: open + no blockers
+bd ready --json
+
+# complex filters
+bd query "status=open AND priority<=1" --json
+bd query "label=plot:rework" --json
+
+# text search
+bd search "keyword" --json
+
+# dependencies
+bd dep list <id>
+```
+
+## out-of-scope issue creation
+
+if you discover unrelated work, file a separate beads issue instead of expanding scope:
+
+```bash
+bd create "discovered: <title>" -t task -p 2 -d "<description>"
+```
+
+keep the new issue narrow and factual. reference the triggering issue in the description when useful.

package/bin/tracker/github/skills/plot-github-tracker/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: plot-github-tracker
+description: "github issue state management for plot orchestration. state transitions via labels, workpad comment lifecycle, and issue/PR linkage. use when moving issues between states, creating/updating workpad comments, or linking PRs to issues."
+---
+
+# plot-github-tracker
+
+manages issue state and progress tracking for the plot orchestrator via GitHub labels and comments.
+
+use `gh` CLI for all GitHub operations. `$GITHUB_REPO` must be set to `owner/repo`.
+
+## state transitions
+
+issue state is determined by labels. plot only routes issues that have an explicit `plot:*` state label. unlabeled issues are ignored.
+
+transition by removing the previous `plot:*` label and adding the new one:
+
+```bash
+# todo -> in-progress
+gh issue edit <number>   --repo "$GITHUB_REPO"   --remove-label "plot:todo"   --add-label "plot:in-progress"
+
+# in-progress -> human-review
+gh issue edit <number>   --repo "$GITHUB_REPO"   --remove-label "plot:in-progress"   --add-label "plot:human-review"
+
+# rework -> human-review
+gh issue edit <number>   --repo "$GITHUB_REPO"   --remove-label "plot:rework"   --add-label "plot:human-review"
+
+# merging -> done, then close
+gh issue edit <number>   --repo "$GITHUB_REPO"   --remove-label "plot:merging"   --add-label "plot:done"
+gh issue close <number> --repo "$GITHUB_REPO"
+```
+
+if you need to move a terminal issue back into active work, reopen first, then swap labels:
+
+```bash
+gh issue reopen <number> --repo "$GITHUB_REPO"
+gh issue edit <number>   --repo "$GITHUB_REPO"   --remove-label "plot:done"   --add-label "plot:rework"
+```
+
+## available states
+
+| label             | meaning                    | agent action                                           |
+| ----------------- | -------------------------- | ------------------------------------------------------ |
+| plot:todo         | queued for work            | move to plot:in-progress, start execution              |
+| plot:in-progress  | implementation underway    | implement, verify, open PR, move to plot:human-review |
+| plot:human-review | PR open, waiting on human  | do nothing, wait                                       |
+| plot:rework       | reviewer requested changes | read feedback, fix, move to plot:human-review         |
+| plot:merging      | human approved             | merge PR, move to plot:done                           |
+| plot:done         | terminal                   | stop                                                   |
+
+## workpad comment
+
+a single persistent GitHub issue comment used as a living scratchpad across agent sessions.
+
+### find or create
+
+```bash
+# search for existing workpad
+gh api repos/$GITHUB_REPO/issues/<number>/comments --jq '.[] | select(.body | startswith("## Plot Workpad")) | .id' | head -1
+```
+
+if not found, create it:
+
+```bash
+gh api repos/$GITHUB_REPO/issues/<number>/comments   -X POST   -f body='## Plot Workpad
+
+### Plan
+
+- [ ] 1. <task>
+
+### Acceptance Criteria
+
+- [ ] <criterion>
+
+### Validation
+
+- [ ] <test command>
+
+### Latest Attempt Summary
+
+- changed: <files or none>
+- validated: <commands + outcome>
+- failed: <remaining failure or none>
+- blocked: <blocker or none>
+
+### Notes
+
+- <durable context>'
+```
+
+### update existing
+
+replace the full workpad body in place:
+
+```bash
+gh api repos/$GITHUB_REPO/issues/comments/<id>   -X PATCH   -f body='...full updated workpad body...'
+```
+
+### rules
+
+- exactly one workpad comment per issue, identified by `## Plot Workpad` header
+- reuse existing comment on continuation runs — do not create duplicates
+- update the workpad after every meaningful milestone
+- never leave completed items unchecked
+- include workspace id and short sha at top: `<workspace-id>@<short-sha>`
+
+## workpad template
+
+````markdown
+## Plot Workpad
+
+```text
+<workspace-id>@<short-sha>
+```
+
+### Plan
+
+- [ ] 1. Parent task
+  - [ ] 1.1 Child task
+- [ ] 2. Parent task
+
+### Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+### Validation
+
+- [ ] targeted tests: `<command>`
+
+### Latest Attempt Summary
+
+- changed: <files or none>
+- validated: <commands + outcome>
+- failed: <remaining failure or none>
+- blocked: <blocker or none>
+
+### Notes
+
+- <short durable context>
+
+````
+
+## issue queries
+
+```bash
+# view issue details
+gh issue view <number> --repo "$GITHUB_REPO" --json title,body,state,labels,comments
+
+# list open issues by label
+gh issue list --repo "$GITHUB_REPO" --label "plot:in-progress" --state open
+```
+
+## PR linkage
+
+after creating or updating a PR, ensure the PR body includes `Resolves #<number>`. that is the durable issue/PR link.
+
+if you need to post the PR URL back to the issue, add a normal issue comment:
+
+```bash
+gh api repos/$GITHUB_REPO/issues/<number>/comments   -X POST   -f body='linked PR: <pr-url>'
+```

package/bin/tui-worker.js

@@ -148024,7 +148024,7 @@ var require_lib4 = __commonJS((exports, module2) => {
 // packages/plot/src/tui-worker.ts
 import { Console } from "console";
 import { createWriteStream as createWriteStream5, mkdirSync as mkdirSync9, readFileSync as readFileSync22 } from "fs";
-import { dirname as dirname20 } from "path";
+import { dirname as dirname21 } from "path";
 
 // node_modules/.bun/effect@3.19.19/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -194228,8 +194228,8 @@ class ObservabilityApi extends exports_Effect.Service()("ObservabilityApi", {
 }
 
 // packages/plot/src/runtime-builder.ts
-import { existsSync as existsSync24, readdirSync as readdirSync12 } from "fs";
-import { dirname as dirname19, join as join34, resolve as resolve14 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync12 } from "fs";
+import { dirname as dirname20, join as join35, resolve as resolve14 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
 // node_modules/.bun/@effect+platform-bun@0.87.1+6d9c3e47916ac965/node_modules/@effect/platform-bun/dist/esm/BunContext.js
@@ -290688,9 +290688,189 @@ var PiAgentLive = exports_Layer.succeed(AgentService, AgentService.of({
   run: (config2) => createEventStream(config2)
 }));
 // packages/plot/src/tracker/beads/index.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// packages/plot/src/tracker/beads/daemon-transport.ts
 import { execFile } from "child_process";
+import { existsSync as existsSync24 } from "fs";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname19, join as join34 } from "path";
+import { createConnection } from "net";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+function walkUp(startDir, filename, globalFallback = false) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join34(dir, ".beads", filename);
+    if (existsSync24(candidate))
+      return candidate;
+    const parent = dirname19(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  if (globalFallback) {
+    const globalPath = join34(homedir14(), ".beads", filename);
+    if (existsSync24(globalPath))
+      return globalPath;
+  }
+  return null;
+}
+function findSocketPath(workspaceRoot) {
+  return walkUp(workspaceRoot, "bd.sock", true);
+}
+function findBeadsDirectory(workspaceRoot) {
+  let dir = workspaceRoot;
+  while (true) {
+    const candidate = join34(dir, ".beads");
+    if (existsSync24(candidate))
+      return candidate;
+    const parent = dirname19(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+
+class BeadsDaemonTransport {
+  workspaceRoot;
+  requestTimeoutMs;
+  actor;
+  socketPath = null;
+  constructor(workspaceRoot, requestTimeoutMs = 5000, actor = "plot") {
+    this.workspaceRoot = workspaceRoot;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.actor = actor;
+  }
+  async listAllIssues() {
+    return this.send("list", { status: "all" });
+  }
+  async listOpenIssues() {
+    return this.send("list", { limit: 0 });
+  }
+  async viewIssue(id3) {
+    return this.send("show", { id: id3 });
+  }
+  async send(operation, args2) {
+    const socketPath = await this.ensureRunning();
+    return await new Promise((resolve14, reject) => {
+      const socket = createConnection(socketPath);
+      let responseData = "";
+      let settled = false;
+      const settle = (fn2, value6) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timeout5);
+        fn2(value6);
+      };
+      const handleResponse = (raw2) => {
+        const trimmed2 = raw2.trim();
+        if (!trimmed2) {
+          settle(reject, new Error("beads daemon returned empty response"));
+          return;
+        }
+        try {
+          const response = JSON.parse(trimmed2);
+          if (response.success) {
+            settle(resolve14, response.data);
+            return;
+          }
+          settle(reject, new Error(response.error ?? "unknown beads daemon error"));
+        } catch {
+          settle(reject, new Error(`failed to parse beads daemon response: ${trimmed2}`));
+        }
+      };
+      const timeout5 = setTimeout(() => {
+        socket.destroy();
+        settle(reject, new Error(`beads daemon request timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      socket.on("connect", () => {
+        socket.write(JSON.stringify({
+          operation,
+          args: args2,
+          cwd: this.workspaceRoot,
+          actor: this.actor
+        }) + `
+`);
+      });
+      socket.on("data", (chunk5) => {
+        responseData += chunk5.toString();
+        if (responseData.includes(`
+`)) {
+          socket.destroy();
+          handleResponse(responseData);
+        }
+      });
+      socket.on("end", () => {
+        if (!settled && responseData.length > 0) {
+          handleResponse(responseData);
+          return;
+        }
+        if (!settled) {
+          settle(reject, new Error("beads daemon closed connection without a response"));
+        }
+      });
+      socket.on("error", (error4) => {
+        this.socketPath = null;
+        settle(reject, new Error(`beads daemon connection error: ${error4.message}`));
+      });
+    });
+  }
+  async ensureRunning() {
+    if (this.socketPath)
+      return this.socketPath;
+    const found = findSocketPath(this.workspaceRoot);
+    if (found) {
+      this.socketPath = found;
+      return found;
+    }
+    await this.startDaemon();
+    if (!this.socketPath)
+      throw new Error("beads daemon socket unavailable");
+    return this.socketPath;
+  }
+  async startDaemon() {
+    const beadsDirectory = findBeadsDirectory(this.workspaceRoot);
+    if (!beadsDirectory) {
+      throw new Error("no .beads directory found");
+    }
+    await execFileAsync("bd", ["daemon", "start"], {
+      cwd: this.workspaceRoot,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    const expectedSocketPath = join34(beadsDirectory, "bd.sock");
+    await new Promise((resolve14, reject) => {
+      const startedAt = Date.now();
+      const timer = setInterval(() => {
+        if (existsSync24(expectedSocketPath)) {
+          clearInterval(timer);
+          this.socketPath = expectedSocketPath;
+          resolve14();
+          return;
+        }
+        if (Date.now() - startedAt >= this.requestTimeoutMs) {
+          clearInterval(timer);
+          reject(new Error(`beads daemon socket did not appear within ${this.requestTimeoutMs}ms`));
+        }
+      }, 100);
+    });
+  }
+}
+async function tryCreateBeadsDaemonTransport(workspaceRoot) {
+  const transport = new BeadsDaemonTransport(workspaceRoot);
+  try {
+    await transport.listAllIssues();
+    return transport;
+  } catch {
+    return null;
+  }
+}
+
+// packages/plot/src/tracker/beads/index.ts
+var execFileAsync2 = promisify2(execFile2);
 var normalizeState2 = (s) => s.trim().toLowerCase();
 function mapBdFailure(error4, resourceId) {
   const message = error4 instanceof Error ? error4.message : String(error4);
@@ -290709,36 +290889,65 @@ function mapBdFailure(error4, resourceId) {
   }
   return new Error(`bd command failed: ${details}`);
 }
-function createBeadsOps(config2) {
+async function createBeadsOps(config2) {
+  const workspaceRoot = config2.beadsDir ?? process.cwd();
+  const daemon = await tryCreateBeadsDaemonTransport(workspaceRoot);
   const runBd = async (args2, options5) => {
     try {
-      return await execFileAsync("bd", args2, {
+      return await execFileAsync2("bd", args2, {
         maxBuffer: 50 * 1024 * 1024,
-        ...config2.beadsDir ? { cwd: config2.beadsDir } : {}
+        cwd: workspaceRoot
       });
     } catch (error4) {
       throw mapBdFailure(error4, options5?.resourceId);
     }
   };
+  const parseIssueList = (value6) => value6;
+  const parseDetailedIssue = (value6, id3) => {
+    const issue2 = Array.isArray(value6) ? value6[0] : value6;
+    if (!issue2)
+      throw new Error(`bd show returned empty result for ${id3}`);
+    return issue2;
+  };
+  const runDaemon = async (operation) => {
+    if (!daemon)
+      return null;
+    try {
+      return await operation(daemon);
+    } catch {
+      return null;
+    }
+  };
   const listIssues = async (status3) => {
+    const daemonResult = await runDaemon((transport) => transport.listAllIssues());
+    if (daemonResult) {
+      if (status3 === "all")
+        return daemonResult;
+      return daemonResult.filter((issue2) => normalizeState2(issue2.status) === normalizeState2(status3));
+    }
     const result = await runBd(["list", "--json", "--status", status3]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const listAllIssues = async () => {
+    const daemonResult = await runDaemon((transport) => transport.listAllIssues());
+    if (daemonResult)
+      return daemonResult;
     const result = await runBd(["list", "--json", "--status", "all"]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const listOpenIssues = async () => {
+    const daemonResult = await runDaemon((transport) => transport.listOpenIssues());
+    if (daemonResult)
+      return daemonResult;
     const result = await runBd(["list", "--json", "--limit", "0"]);
-    return JSON.parse(result.stdout);
+    return parseIssueList(JSON.parse(result.stdout));
   };
   const viewIssue = async (id3) => {
+    const daemonResult = await runDaemon((transport) => transport.viewIssue(id3));
+    if (daemonResult)
+      return parseDetailedIssue(daemonResult, id3);
     const result = await runBd(["show", id3, "--json"], { resourceId: id3 });
-    const parsed = JSON.parse(result.stdout);
-    const issue2 = Array.isArray(parsed) ? parsed[0] : parsed;
-    if (!issue2)
-      throw new Error(`bd show returned empty result for ${id3}`);
-    return issue2;
+    return parseDetailedIssue(JSON.parse(result.stdout), id3);
   };
   const mapState = (bd) => {
     const labelNames = (bd.labels ?? []).map((l) => normalizeState2(l));
@@ -290759,7 +290968,64 @@ function createBeadsOps(config2) {
     createdAt: bd.created_at || null,
     updatedAt: bd.updated_at || null
   });
-  const fetchRunContext = async (issueId, _state) => {
+  const runGh = async (args2) => {
+    return await execFileAsync2("gh", args2, {
+      maxBuffer: 50 * 1024 * 1024,
+      cwd: workspaceRoot
+    });
+  };
+  const fetchPrReviews = async (issueId) => {
+    const repoArgs = config2.githubRepo ? ["--repo", config2.githubRepo] : [];
+    try {
+      const prSearchResult = await runGh([
+        "pr",
+        "list",
+        ...repoArgs,
+        "--state",
+        "open",
+        "--json",
+        "number,headRefName,body",
+        "--limit",
+        "50"
+      ]);
+      const prs = JSON.parse(prSearchResult.stdout);
+      const linkedPr = prs.find((pr) => pr.body?.includes(issueId));
+      if (!linkedPr)
+        return null;
+      const reviewResult = await runGh([
+        "pr",
+        "view",
+        String(linkedPr.number),
+        ...repoArgs,
+        "--json",
+        "reviews,comments"
+      ]);
+      const prData = JSON.parse(reviewResult.stdout);
+      const parts2 = [];
+      if (prData.reviews?.length) {
+        for (const r of prData.reviews) {
+          if (r.body)
+            parts2.push(`**${r.author.login}** (${r.state}):
+${r.body}`);
+        }
+      }
+      if (prData.comments?.length) {
+        for (const c of prData.comments) {
+          if (c.body)
+            parts2.push(`**${c.author.login}**:
+${c.body}`);
+        }
+      }
+      return parts2.length > 0 ? parts2.join(`
+
+---
+
+`) : null;
+    } catch {
+      return null;
+    }
+  };
+  const fetchRunContext = async (issueId, state) => {
     let comments = [];
     try {
       const issue2 = await viewIssue(issueId);
@@ -290771,7 +291037,12 @@ function createBeadsOps(config2) {
     const workpadComment = comments.find((c) => c.text.startsWith("## Plot Workpad"));
     if (workpadComment)
       workpad = workpadComment.text;
-    return buildRunContext({ workpad, reviewFeedback: null });
+    let reviews = null;
+    const normalizedDispatch = config2.dispatchStates.map(normalizeState2);
+    if (normalizedDispatch.includes(normalizeState2(state))) {
+      reviews = await fetchPrReviews(issueId);
+    }
+    return buildRunContext({ workpad, reviewFeedback: reviews });
   };
   return {
     runBd,
@@ -290790,6 +291061,7 @@ var plugin2 = {
     return {
       kind: String(raw2.kind),
       beadsDir: typeof raw2["beadsDir"] === "string" ? raw2["beadsDir"] : undefined,
+      githubRepo: typeof raw2["githubRepo"] === "string" ? raw2["githubRepo"] : undefined,
       dispatchStates: Array.isArray(raw2["dispatchStates"]) ? raw2["dispatchStates"] : undefined,
       parkedStates: Array.isArray(raw2["parkedStates"]) ? raw2["parkedStates"] : undefined,
       terminalStates: Array.isArray(raw2["terminalStates"]) ? raw2["terminalStates"] : undefined
@@ -290801,13 +291073,15 @@ var plugin2 = {
       ...config2.parkedStates ?? [],
       ...config2.terminalStates ?? []
     ].filter((s, i, arr) => arr.indexOf(s) === i);
-    const ops = createBeadsOps({
+    const ops = await createBeadsOps({
       beadsDir: config2.beadsDir,
+      githubRepo: config2.githubRepo,
+      dispatchStates: config2.dispatchStates ?? [],
       allStates
     });
     return {
       async fetchCandidateIssues(dispatchStates) {
-        const bdIssues = await ops.listOpenIssues();
+        const bdIssues = await ops.listAllIssues();
         const issues = bdIssues.map(ops.mapIssue);
         const normalized = new Set(dispatchStates.map(normalizeState2));
         return issues.filter((i) => normalized.has(normalizeState2(i.state)));
@@ -290819,19 +291093,12 @@ var plugin2 = {
         return issues.filter((i) => normalized.has(normalizeState2(i.state)));
       },
       async fetchIssueStatesByIds(ids3) {
-        const results = await Promise.all(ids3.map(async (id3) => {
-          try {
-            const bd = await ops.viewIssue(id3);
-            return [
-              { id: bd.id, state: ops.mapState(bd) }
-            ];
-          } catch (e) {
-            if (e instanceof PluginNotFoundError)
-              return [];
-            throw e;
-          }
+        const wantedIds = new Set(ids3);
+        const allIssues = await ops.listAllIssues();
+        return allIssues.filter((issue2) => wantedIds.has(issue2.id)).map((issue2) => ({
+          id: issue2.id,
+          state: ops.mapState(issue2)
         }));
-        return results.flat();
       },
       fetchRunContext: (issueId, state) => ops.fetchRunContext(issueId, state)
     };
@@ -290839,9 +291106,9 @@ var plugin2 = {
 };
 var beads_default = plugin2;
 // packages/plot/src/tracker/github/index.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 var normalizeState3 = (s) => s.trim().toLowerCase();
 function mapGhFailure(error4, resourceId) {
   const message = error4 instanceof Error ? error4.message : String(error4);
@@ -290870,7 +291137,7 @@ function createGithubOps(config2) {
   const ghFields = "number,title,body,state,labels,url,createdAt,updatedAt";
   const runGh = async (args2, options5) => {
     try {
-      return await execFileAsync2("gh", args2, {
+      return await execFileAsync3("gh", args2, {
         maxBuffer: 50 * 1024 * 1024
       });
     } catch (error4) {
@@ -291156,11 +291423,11 @@ function adaptTrackerClient(plain) {
 var builtinTrackers = {
   beads: {
     definition: beads_default,
-    moduleDir: join34(dirname19(fileURLToPath6(import.meta.url)), "tracker", "beads")
+    moduleDir: join35(dirname20(fileURLToPath6(import.meta.url)), "tracker", "beads")
   },
   github: {
     definition: github_default,
-    moduleDir: join34(dirname19(fileURLToPath6(import.meta.url)), "tracker", "github")
+    moduleDir: join35(dirname20(fileURLToPath6(import.meta.url)), "tracker", "github")
   }
 };
 function buildPluginConfig(resolved) {
@@ -291178,11 +291445,11 @@ function syncGithubRepoEnv(resolved) {
   delete process.env["GITHUB_REPO"];
 }
 function discoverSkillPaths(moduleDir) {
-  const skillsDir = join34(moduleDir, "skills");
-  if (!existsSync24(skillsDir))
+  const skillsDir = join35(moduleDir, "skills");
+  if (!existsSync25(skillsDir))
     return [];
   try {
-    return readdirSync12(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join34(skillsDir, entry.name)).filter((dir) => existsSync24(join34(dir, "SKILL.md")));
+    return readdirSync12(skillsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join35(skillsDir, entry.name)).filter((dir) => existsSync25(join35(dir, "SKILL.md")));
   } catch {
     return [];
   }
@@ -291225,7 +291492,7 @@ function resolvePlugin(resolved) {
       return yield* exports_Effect.die(new Error(`Tracker plugin "${kind}" does not export a valid default tracker plugin definition`));
     }
     const config2 = yield* resolveDefinitionConfig(definition, rawConfig);
-    const moduleDir = kind.startsWith("./") || kind.startsWith("../") || kind.startsWith("/") ? dirname19(resolve14(kind)) : undefined;
+    const moduleDir = kind.startsWith("./") || kind.startsWith("../") || kind.startsWith("/") ? dirname20(resolve14(kind)) : undefined;
     return yield* makeResolvedPlugin(definition, config2, moduleDir);
   });
 }
@@ -291379,7 +291646,7 @@ function postResponse(message) {
 function redirectProcessOutput(path14) {
   if (!path14)
     return;
-  mkdirSync9(dirname20(path14), { recursive: true });
+  mkdirSync9(dirname21(path14), { recursive: true });
   const stream8 = createWriteStream5(path14, { flags: "a" });
   const write4 = (chunk5) => {
     stream8.write(typeof chunk5 === "string" ? chunk5 : Buffer.from(chunk5));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plot-ai/linux-x64-musl",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "license": "MIT",
   "description": "orchestrate coding agents against an issue tracker",