@permissionbrick/auto-review-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 permissionBRICK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,265 @@
+# auto-review-mcp
+
+A local MCP server that orchestrates a **continuous review loop between two coding agents**: one
+**developer** and one **reviewer**. They both connect to this one long-running server at the same
+time and hand work back and forth through it — no human in the middle of the loop.
+
+```
+ developer agent                  auto-review server                 reviewer agent
+ ───────────────                  ──────────────────                 ──────────────
+ (works on a batch)
+ request_review(summary, ──────▶  stages all changes, diffs vs HEAD
+   commit_message)                registers the batch, BLOCKS dev
+                                  wakes reviewer  ──────────────────▶ get_next_review()
+                                                                      (returns summary + full diff)
+                                                                      reviews it…
+                                  ◀────────────────────────────────── submit_review(approved
+                                  approved → git commit (dev's msg)        | changes_requested,
+ ◀────── {approved, commit_sha}   changes → forward the issue              issue, category)
+   or {changes_requested, issue}
+ (continue / fix & resubmit)                                              get_next_review() …
+```
+
+The protocol is taught entirely through the MCP **tool descriptions**, so the two agents
+self-orchestrate from the tools alone.
+
+## How it works
+
+- **One shared coordinator, two role-scoped endpoints**:
+  - Developer agent → `…/developer/mcp` (tools: `initialize_review_session`, `request_review`,
+    `signal_complete`, `workflow_status`)
+  - Reviewer agent → `…/reviewer/mcp` (tools: `get_next_review`, `submit_review`,
+    `workflow_status`)
+  - Role is fixed by the endpoint, so there is no role/agent-id parameter on the calls.
+- **The developer names the repo at runtime.** As its first step the developer agent calls
+  `initialize_review_session` with the absolute path of the repo it's editing. The coordinator
+  remembers it for its lifetime (or until called again). So there's nothing repo-specific to bake
+  into config. (You can still pre-set it with `--repo`/`AUTO_REVIEW_REPO` if you prefer.)
+- **Two ways to attach** (see [Connect the two agents](#connect-the-two-agents)):
+  - **stdio (recommended)** — each agent's `.mcp.json` runs `npx -y @permissionbrick/auto-review-mcp
+    --role …`, a thin proxy. The first proxy auto-starts a single shared background coordinator; both
+    proxies forward to it. No server to start by hand. The shared state lives in the coordinator, not
+    the agents.
+  - **HTTP** — you start the coordinator yourself (`auto-review-server`) and point each agent at its
+    URL (good for remote agents or sharing one coordinator across machines).
+- **Blocking handoffs.** `request_review` blocks until the reviewer rules; `get_next_review`
+  blocks until a batch arrives. Waiting is **event-driven**, so the actual handoff is instant. A
+  call only holds the connection open up to a bounded **poll window** (`AUTO_REVIEW_POLL_SECONDS`),
+  then returns `keep_waiting`; the agent immediately calls again. This makes the wait effectively
+  unbounded while surviving connection drops and client timeouts. See
+  [Tuning how long a call waits](#tuning-how-long-a-call-waits).
+- **The server owns the commits.** On approval the server runs `git add -A` + `git commit` with
+  the developer's commit message (plus a `Reviewed-by: auto-review` trailer). HEAD advances, so
+  each review's diff is naturally just the new batch. The developer never commits.
+- **One batch at a time**, identified by a `batch_id`. The diff shown to the reviewer is the full
+  unified diff of the working tree vs HEAD (new/deleted files included).
+
+## Install
+
+You don't need to install anything by hand — the recommended setup runs the server on demand with
+`npx` (see [Connect the two agents](#connect-the-two-agents)). Prefer global CLIs? Install them with:
+
+```bash
+npm install -g @permissionbrick/auto-review-mcp
+# bins: auto-review-mcp (stdio proxy) · auto-review-server (HTTP coordinator) · auto-review-cli (poller)
+```
+
+### Build from source
+
+```bash
+git clone https://github.com/permissionBRICK/auto-review.git
+cd auto-review
+npm install        # installs deps and builds (via the prepare script)
+```
+
+## Connect the two agents
+
+Launch **two Claude Code instances** — one developer, one reviewer. Both must point at the **same
+git repository** the developer edits (it must be a git repo, not this server's directory).
+
+### Option A — `node`/stdio (recommended)
+
+Each agent's `.mcp.json` runs the stdio proxy via `npx`; the first one auto-starts the shared
+coordinator. Nothing to install or run by hand, and **no repo path in config** — the developer agent
+declares it at runtime via `initialize_review_session`. Sample configs are in
+[`configs/`](configs/):
+
+```jsonc
+// configs/developer.mcp.json  (reviewer.mcp.json is identical with --role reviewer)
+{
+  "mcpServers": {
+    "auto-review": {
+      "command": "npx",
+      "args": ["-y", "@permissionbrick/auto-review-mcp", "--role", "developer"],
+      "env": { "AUTO_REVIEW_POLL_SECONDS": "240" },
+      "timeout": 1800000
+    }
+  }
+}
+```
+
+The shipped configs use a **240 s** poll window (`AUTO_REVIEW_POLL_SECONDS`) — the practical max
+per single hold (see [Tuning how long a call waits](#tuning-how-long-a-call-waits)). Idle waiters
+re-poll every ~240 s; handoffs are still instant. For long *uninterrupted* waits, use the poller
+CLI, which loops over these windows.
+
+```bash
+# Developer instance (point at the config above, e.g. configs/developer.mcp.json)
+claude --mcp-config configs/developer.mcp.json --strict-mcp-config
+# Reviewer instance (separate terminal)
+claude --mcp-config configs/reviewer.mcp.json --strict-mcp-config
+```
+
+`--strict-mcp-config` makes each instance load *only* that file. No launch-time env is needed — the
+config's `timeout` field raises Claude Code's per-call cap by itself.
+
+Proxy env / args (also accepted as `--flags` in `args`): `AUTO_REVIEW_ROLE`, `AUTO_REVIEW_PORT`
+(default `8765`), `AUTO_REVIEW_HOST` (default `127.0.0.1`), `AUTO_REVIEW_POLL_SECONDS` (default
+`40` if unset; the shipped config sets `240`), `AUTO_REVIEW_MAX_DIFF_BYTES` (default `200000`), and
+optionally `AUTO_REVIEW_REPO` to pre-set the repo instead of using `initialize_review_session`. The
+coordinator logs to `${TMPDIR}/auto-review-coordinator-<port>.log` and keeps running after the
+agents exit (kill it via that port if you want a clean reset — also needed to apply a changed poll
+window, see below).
+
+### Option B — HTTP (manual start / remote agents)
+
+Start the coordinator yourself and point each agent at its URL (configs:
+`configs/*.http.mcp.json`):
+
+```bash
+# start the shared HTTP coordinator (no install needed via npx; or use the global bin)
+npx -y -p @permissionbrick/auto-review-mcp auto-review-server --port 8765 --poll-seconds 240   # keep ≤ ~270; optional: --repo /path
+claude --mcp-config configs/developer.http.mcp.json --strict-mcp-config
+claude --mcp-config configs/reviewer.http.mcp.json  --strict-mcp-config
+```
+
+The HTTP configs carry `"timeout": 3600000`, so no launch env is needed here either. Server flags
+(env var in parens): `--repo` (`AUTO_REVIEW_REPO`, optional — else the developer sets it via
+`initialize_review_session`), `--port` (`AUTO_REVIEW_PORT`, `8765`), `--host` (`AUTO_REVIEW_HOST`,
+`0.0.0.0` — reachable as `agent-vm.mshome.net`), `--poll-seconds` (`AUTO_REVIEW_POLL_SECONDS`,
+`1500`), `--max-diff-bytes` (`AUTO_REVIEW_MAX_DIFF_BYTES`, `200000`). `GET /healthz` returns a JSON
+snapshot of the workflow.
+
+### Tuning how long a call waits
+
+`get_next_review` and `request_review` each block in **one** call for up to the **poll window**,
+then return `keep_waiting` and the agent re-calls. Two limits bound that single call:
+
+| Knob | Where | Effect |
+|------|-------|--------|
+| `AUTO_REVIEW_POLL_SECONDS` | config `env` (stdio) / `--poll-seconds` (HTTP) | how long the server holds before `keep_waiting`. **Must stay under ~270 s** (see below). |
+| `timeout` (ms) | per-server field in `.mcp.json` | Claude Code's per-call cap (default **60000**). Must be **≥ the poll window**. Overrides `MCP_TOOL_TIMEOUT`; not extended by progress. |
+
+Handoffs themselves are event-driven (instant) regardless — the poll window only sets how long an
+*idle* waiter holds before re-polling.
+
+> ⚠️ **Hard ~5-minute ceiling on a single HTTP hold.** Every MCP client here is Node-based (the
+> stdio proxy and the poller CLI both use Node's `fetch`/undici, whose default `headersTimeout` is
+> **300 s**), so a long-poll held longer than ~5 min dies as `fetch failed`. Worse, the abandoned
+> request leaves a server-side waiter that could swallow a batch. **So keep
+> `AUTO_REVIEW_POLL_SECONDS` ≤ ~270 s** (the shipped configs use **240**). You cannot get a longer
+> *single* hold by raising the window — for longer **effective** waits, the poller CLI loops over
+> many ≤270 s polls (see [the Codex section](#avoiding-re-polls-on-codex-the-shell-poll-command)),
+> and the CLI never fails fatally on a hiccup.
+
+Two more caveats:
+
+- **The coordinator is a singleton.** Changing the poll window only takes effect on a fresh
+  coordinator — kill the running one (`fuser -k <port>/tcp`, or `kill` the pid on that port) so the
+  next agent restarts it with the new value. Both agents should use the same window.
+- Across machines (HTTP transport), a dropped connection isn't retried until the next poll; prefer
+  a shorter window there too.
+
+### Using Codex instead of Claude Code
+
+Codex (OpenAI) works as the client, but it's the opposite of Claude Code on timeouts:
+
+- It reads `~/.codex/config.toml`, **not** `.mcp.json`, and **ignores the `timeout` field**.
+- All Codex harnesses (CLI, VS Code extension, Windows app) enforce a **hard ~120 s
+  `awaiting tools/call` deadline** that `tool_timeout_sec` does **not** reliably raise
+  ([openai/codex#13831](https://github.com/openai/codex/issues/13831)). So unlike Claude Code, a
+  single blocking call **cannot exceed ~120 s** on Codex.
+
+Therefore, do the **reverse** of the Claude tuning: keep the poll window safely **under** 120 s so
+the coordinator returns `keep_waiting` before Codex gives up, and the agent re-polls. `90` is a good
+value. See [`configs/codex.config.toml`](configs/codex.config.toml):
+
+```toml
+[mcp_servers.auto-review]
+command = "npx"
+args = ["-y", "@permissionbrick/auto-review-mcp", "--role", "developer"]  # reviewer in its own config
+env = { AUTO_REVIEW_POLL_SECONDS = "90" }   # MUST be < Codex's ~120 s ceiling
+startup_timeout_sec = 30
+tool_timeout_sec = 110
+```
+
+Handoffs are still instant — the window only sets how often an idle waiter re-polls. The
+singleton-coordinator rule still applies: both agents need the same `AUTO_REVIEW_POLL_SECONDS`, and
+you must kill any running coordinator for a changed window to take effect.
+
+#### Avoiding re-polls on Codex: the shell poll command
+
+Re-polling under 120 s works but is chatty. To get long, quiet waits anyway, there's a built-in
+escape hatch: an MCP tool call is capped at ~120 s, but a **shell command isn't**. When
+`get_next_review` / `request_review` is killed by Codex's `timed out awaiting tools/call` error, the
+agent never receives a result — so the tool **descriptions** (not the responses) tell it to fall
+back to a blocking shell command that waits without the limit and prints the same JSON:
+
+```
+# the tool description already prints the exact command (absolute paths, ready to paste); by name:
+npx -y -p @permissionbrick/auto-review-mcp auto-review-cli next-review    --port 8765 --timeout 1500   # reviewer
+npx -y -p @permissionbrick/auto-review-mcp auto-review-cli await-verdict  --port 8765 --timeout 1500   # developer
+```
+
+These hit a plain-HTTP long-poll endpoint on the coordinator, hide `keep_waiting` internally, and
+block until there's a real result (give the command a long *command* timeout, ~25 min). The agent
+should use them **only after an actual timeout error** — a normal `keep_waiting` return just means
+"call the tool again", and running the shell command then would be a redundant double-wait.
+
+With this fallback you can even set a **long** poll window (so the MCP call carries the fast case
+within 120 s and the shell command carries longer waits). Verify it with `npm run demo:cli`.
+
+## Suggested prompts
+
+The tools are self-describing, so the prompts can be short.
+
+**Developer:**
+> You are the *developer*. First call `initialize_review_session` (the `auto-review` MCP) with the
+> absolute path of this repo. Then implement <the task> in small, self-contained batches. After each
+> batch, call `request_review` with a clear summary and commit message, and follow whatever it
+> returns: on `changes_requested`, fix the issue and resubmit; on `approved`, continue with the next
+> batch. Do not run `git commit` yourself. When the whole task is done and the last batch is
+> approved, call `signal_complete`.
+
+**Reviewer:**
+> You are the *reviewer*. Repeatedly call `get_next_review` (the `auto-review` MCP) to receive each
+> batch (summary + full diff vs HEAD), review it against <the task/spec> and for code quality, then
+> call `submit_review` — `approved`, or `changes_requested` with a clear `issue` and `category`
+> (`spec`/`code`). Keep looping until you get `workflow_complete`.
+
+On **Codex**, also allow shell commands and add: *"If a `get_next_review`/`request_review` call ever
+fails with `timed out awaiting tools/call`, follow that tool's CLIENT-TIMEOUT FALLBACK instructions
+— run the shell command it names to wait, then continue."*
+
+## Verify
+
+End-to-end tests that spin up a throwaway git repo and drive the full loop (keep_waiting → submit →
+review → changes_requested → fix → approve → commit → complete):
+
+```bash
+npm run build
+npm run demo         # HTTP path: two SDK clients against a running server
+npm run demo:stdio   # node/stdio path: two spawned proxies + auto-started coordinator
+npm run demo:cli     # shell poll-command path: MCP for instant ops + cli.js for the blocking wait
+```
+
+Each prints a checklist and exits non-zero if anything fails.
+
+## Notes & limitations (v1)
+
+- **State is in-memory.** Restarting the server resets the loop (no batch is mid-flight unless an
+  agent is actively blocked). There is no persistence yet.
+- **One developer + one reviewer.** A single batch flows at a time; extra connections share the
+  same state.
+- **Commit hooks are respected.** If a pre-commit hook rejects an approved batch, the reviewer gets
+  an error and the batch stays open to retry or send back as `changes_requested`.

package/dist/cli.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Thin blocking poller for the auto-review coordinator — the shell command an
+ * agent runs when its MCP client kills a blocking tool call with a hard timeout
+ * (e.g. Codex's ~120s "timed out awaiting tools/call"). A shell process is NOT
+ * bound by that MCP per-call limit, so this can wait far longer.
+ *
+ * It hits a plain-HTTP long-poll endpoint on the coordinator and hides
+ * `keep_waiting` internally: it blocks until there is a REAL result, then prints
+ * that JSON to stdout and exits. The agent reads stdout and acts on it.
+ *
+ *   next-review     wait for the next batch to review   (reviewer)
+ *   await-verdict   wait for the verdict of the batch you already submitted (developer)
+ *   status          print the current workflow status once and exit
+ *
+ * Flags: --port (8765) --host (127.0.0.1) --timeout <seconds> (1500) and the
+ * usual --poll-seconds / --max-diff-bytes (only used if it has to start the
+ * coordinator). On reaching --timeout it prints {"status":"keep_waiting"} and
+ * exits 0, so the agent can simply run it again.
+ */
+import { setTimeout as sleep } from "node:timers/promises";
+import { ensureCoordinator } from "./launch.js";
+const ENDPOINTS = {
+    "next-review": { path: "/reviewer/next-review" },
+    "await-verdict": { path: "/developer/await-verdict" },
+};
+function out(obj) {
+    process.stdout.write(`${JSON.stringify(obj, null, 2)}\n`);
+}
+function errlog(msg) {
+    process.stderr.write(`[auto-review cli] ${msg}\n`);
+}
+function parse(argv) {
+    let sub = "";
+    const opts = new Map();
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith("--")) {
+            if (!sub)
+                sub = a;
+            continue;
+        }
+        const key = a.slice(2);
+        const eq = key.indexOf("=");
+        if (eq >= 0)
+            opts.set(key.slice(0, eq), key.slice(eq + 1));
+        else if (i + 1 < argv.length && !argv[i + 1].startsWith("--"))
+            opts.set(key, argv[++i]);
+        else
+            opts.set(key, "true");
+    }
+    const get = (k, env, dflt) => opts.get(k) ?? process.env[env] ?? dflt;
+    return {
+        sub,
+        host: get("host", "AUTO_REVIEW_HOST", "127.0.0.1"),
+        port: Number(get("port", "AUTO_REVIEW_PORT", "8765")),
+        timeoutSeconds: Number(get("timeout", "AUTO_REVIEW_CLI_TIMEOUT", "3600")),
+        pollSeconds: Number(get("poll-seconds", "AUTO_REVIEW_POLL_SECONDS", "40")),
+        maxDiffBytes: Number(get("max-diff-bytes", "AUTO_REVIEW_MAX_DIFF_BYTES", "200000")),
+    };
+}
+async function main() {
+    const cfg = parse(process.argv.slice(2));
+    const base = `http://${cfg.host}:${cfg.port}`;
+    if (cfg.sub === "status") {
+        await ensureCoordinator({ ...cfg, log: errlog });
+        const r = await fetch(`${base}/healthz`);
+        const body = (await r.json());
+        out(body.status ?? body);
+        return;
+    }
+    const endpoint = ENDPOINTS[cfg.sub];
+    if (!endpoint) {
+        errlog(`unknown command '${cfg.sub}'. Use: next-review | await-verdict | status`);
+        process.exit(2);
+    }
+    const target = { ...cfg, log: errlog };
+    await ensureCoordinator(target);
+    const url = `${base}${endpoint.path}`;
+    const deadline = Date.now() + cfg.timeoutSeconds * 1000;
+    // Cap each HTTP request well under Node/undici's default 300s headersTimeout,
+    // which otherwise kills a longer-held long-poll with "fetch failed". The
+    // coordinator returns keep_waiting within its (smaller) poll window, so this
+    // cap normally never bites; it just bounds a single request for safety.
+    const PER_REQUEST_MS = 270_000;
+    // Loop until a real result or our own --timeout budget. Transient errors
+    // (undici timeout, a coordinator restart, a network blip) are NEVER fatal
+    // mid-wait — we self-heal and keep polling, so one shell command can wait
+    // for the whole budget (default 1h) without ever returning "fetch failed".
+    for (;;) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            out({ status: "keep_waiting", message: "Time budget elapsed; run this command again to keep waiting." });
+            return;
+        }
+        let body;
+        try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(Math.min(remaining, PER_REQUEST_MS)) });
+            if (!res.ok) {
+                errlog(`coordinator returned HTTP ${res.status}; retrying`);
+                await sleep(2000);
+                continue;
+            }
+            body = (await res.json());
+        }
+        catch (e) {
+            // Per-request cap reached, undici headers/body timeout, or a blip. Keep
+            // looping; re-ensure the coordinator in case it died, then retry.
+            if (deadline - Date.now() > 1500) {
+                errlog(`poll hiccup (${e?.name ?? e}); retrying`);
+                await ensureCoordinator({ ...target, log: () => { } }).catch(() => { });
+                await sleep(1000);
+            }
+            continue;
+        }
+        if (body.status === "keep_waiting")
+            continue; // coordinator window elapsed → re-poll
+        out(body);
+        return;
+    }
+}
+main().catch((e) => {
+    errlog(`FATAL: ${e?.stack ?? String(e)}`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/descriptions.js

@@ -0,0 +1,71 @@
+/**
+ * Tool descriptions. These are the *contract*: they must teach the whole
+ * auto-review protocol so the two agents can self-orchestrate from the tool
+ * descriptions alone, with no extra prompting.
+ */
+export const INITIALIZE_SESSION_DESC = `Start the auto-review session by telling the server which git repository this workflow operates on. CALL THIS ONCE, FIRST — before request_review.
+
+Pass 'repo_path': the ABSOLUTE path to the root of the git repository you are working in (normally your current working directory). The server performs ALL git operations there — it diffs your working tree against HEAD to show the reviewer, and commits each approved batch — so it MUST be the exact checkout you are editing.
+
+The repository is remembered for the lifetime of the server, or until you call this again (which starts a fresh session). Returns {"status":"ok","repo":...,"head":...} on success, or {"status":"error","message":...} if the path is not a git repository.`;
+export const REQUEST_REVIEW_DESC = `Submit a completed batch of work to the reviewer and BLOCK until the reviewer responds. (Call initialize_review_session once first; if you haven't, this returns {"status":"not_initialized"}.)
+
+WHEN TO CALL: every time you finish a self-contained, coherent chunk of the task — a logical, commit-sized unit (a part of a feature, an enclosed subset of the task). Work in small, reviewable increments rather than one giant change.
+
+WHAT TO PASS:
+- summary: what you changed and WHY, in enough detail for a reviewer to judge it against the task/spec.
+- commit_message: a good commit message for this batch (this exact message is used for the commit on approval).
+
+IMPORTANT: Do NOT stage or commit anything yourself. The server automatically snapshots ALL current changes in the working tree (it runs 'git add -A') and computes the diff against HEAD. The server commits the batch for you, and only after the reviewer approves it. Never run 'git commit'.
+
+This call BLOCKS until the review is finished. It returns exactly one of:
+- {"status":"approved","commit_sha":...}  → the reviewer approved and the server has committed this batch. Move on to the NEXT batch of work.
+- {"status":"changes_requested","issue":...,"category":"spec"|"code"}  → the reviewer found a problem. 'category' is "spec" (it does not meet the requirement) or "code" (a code-level defect/bug/quality issue). Read 'issue', fix it, then call request_review again with an updated summary/commit_message.
+- {"status":"keep_waiting"}  → the review is still in progress; this returned only to keep the connection alive. IMMEDIATELY call request_review again with the SAME arguments to keep waiting. (Re-submitting unchanged work does not create a duplicate review.)
+- {"status":"nothing_to_review"}  → there are no changes versus HEAD. Do some work first, then call again.
+
+Only one batch is reviewed at a time.`;
+export const SIGNAL_COMPLETE_DESC = `Signal that the ENTIRE task is finished and there is nothing left to implement (typically right after your final batch was approved).
+
+This tells the reviewer the workflow is over: the reviewer's next get_next_review will return {"status":"workflow_complete"} so it can stop waiting. Optionally pass a closing 'note'. Do not call this while you still have batches to submit.`;
+export const GET_NEXT_REVIEW_DESC = `Ask for the next batch of work to review and BLOCK until one is available.
+
+WHEN TO CALL: FIRST, as soon as you start (you are the reviewer and wait for the developer). Then again every time after you submit a verdict, to wait for the next batch.
+
+This call BLOCKS. It returns exactly one of:
+- {"status":"review_ready","batch_id":...,"summary":...,"commit_message":...,"diff":...,"diff_stat":...}  → a developer submitted a batch. 'summary' is the developer's description, 'commit_message' their proposed message, 'diff' is the FULL unified diff of all current changes versus HEAD (i.e. exactly this batch), 'diff_stat' is the file/line summary. Review it against BOTH the task/spec AND code quality, then call submit_review with this same batch_id.
+- {"status":"keep_waiting"}  → nothing is ready yet; this returned only to keep the connection alive. IMMEDIATELY call get_next_review again to keep waiting.
+- {"status":"workflow_complete"}  → the developer signalled the whole task is done. Stop; there is nothing left to review.
+
+You review one batch at a time. After you receive a "review_ready" batch you must eventually call submit_review for that batch_id before any further work can flow.`;
+export const SUBMIT_REVIEW_DESC = `Record your verdict on the batch you are currently reviewing and unblock the developer.
+
+WHAT TO PASS:
+- batch_id: the id you received from get_next_review.
+- verdict: "approved" or "changes_requested".
+  - "approved" → the batch meets the requirement and the code is acceptable. The server IMMEDIATELY commits the batch (using the developer's commit_message) and reports the new commit to the developer. Do not commit anything yourself.
+  - "changes_requested" → something is wrong. You MUST also pass:
+      - issue: a clear, actionable description of what is wrong and what to change.
+      - category: "spec" (it fails to meet the task/requirement) or "code" (a code-level defect such as a bug, regression, or quality problem).
+    The developer receives this, fixes it, and resubmits.
+
+After submitting, call get_next_review again to wait for the next batch.`;
+export const WORKFLOW_STATUS_DESC = `Read-only. Return the current state of the auto-review workflow: the phase (idle / awaiting_review / reviewing), a summary of the batch currently under review (if any), the last verdict, the number of completed batches, and the repo path. Does not block and never changes anything.`;
+/**
+ * Appended to a blocking tool's description so the agent can recover when its
+ * MCP client kills the call with a hard timeout (e.g. Codex's ~120s
+ * "timed out awaiting tools/call"). On that timeout there is NO tool response,
+ * so this guidance must live in the static description — not in any result.
+ */
+export function timeoutFallbackNote(pollCommand, waits) {
+    return `CLIENT-TIMEOUT FALLBACK — only when THIS call FAILS with a client-side timeout error (e.g. "timed out awaiting tools/call after 120s"): your MCP client gave up before the wait finished, so you never received a result. Do NOT just retry the tool (it will time out again the same way). Instead run this shell command to wait for ${waits} without the per-call MCP limit — it blocks until there is a real result and then prints the same JSON:
+
+    ${pollCommand}
+
+RUN IT SO IT ACTUALLY BLOCKS — it must stay in the foreground until it returns; do not let it drop into a background task and do not poll it with repeated short waits.
+- On Codex: if exec_command returns a session_id because the process is still running (exec_command may yield a session after ~30s even when you pass a longer timeout), do NOT poll repeatedly with short waits. Immediately call write_stdin on that session with chars:"" and a long yield_time_ms (~1500000 ms, i.e. ~25 min) so you block until the command produces its result; if it yields again before finishing, repeat the blocking write_stdin.
+- On other harnesses: just give the command a long command/exec timeout (~25 min) and let it block.
+
+Only use this on an actual timeout error. If the tool RETURNS normally — including a "keep_waiting" result — do NOT run the shell command; just call the tool again as usual. Running it after a normal return would be a redundant double-wait.`;
+}
+//# sourceMappingURL=descriptions.js.map

package/dist/descriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.js","sourceRoot":"","sources":["../src/descriptions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;6PAIsN,CAAC;AAE9P,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;sCAgBG,CAAC;AAEvC,MAAM,CAAC,MAAM,oBAAoB,GAAG;;gPAE4M,CAAC;AAEjP,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;oKASgI,CAAC;AAErK,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;yEAWuC,CAAC;AAE1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,2RAA2R,CAAC;AAEhU;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAAmB,EAAE,KAAa;IACpE,OAAO,0UAA0U,KAAK;;MAElV,WAAW;;;;;;iPAMgO,CAAC;AAClP,CAAC"}

package/dist/git.js

@@ -0,0 +1,99 @@
+/**
+ * Thin async wrapper around the `git` CLI for the project repo under review.
+ *
+ * All commands use `git -C <dir> ...` and `execFile` (no shell) so paths and
+ * messages with spaces or special characters are safe.
+ */
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export class GitError extends Error {
+    stderr;
+    constructor(message, stderr) {
+        super(message);
+        this.stderr = stderr;
+        this.name = "GitError";
+    }
+}
+export class GitRepo {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    async git(args) {
+        try {
+            const { stdout, stderr } = await execFileAsync("git", ["-C", this.dir, ...args], {
+                maxBuffer: 64 * 1024 * 1024, // 64MB — big diffs are fine
+                encoding: "utf8",
+            });
+            return { stdout, stderr };
+        }
+        catch (err) {
+            const e = err;
+            throw new GitError(`git ${args.join(" ")} failed: ${e.message ?? "unknown error"}`, e.stderr ?? e.stdout);
+        }
+    }
+    /** Throws a helpful error if `dir` is not inside a git work tree. */
+    async assertRepo() {
+        try {
+            const { stdout } = await this.git(["rev-parse", "--is-inside-work-tree"]);
+            if (stdout.trim() !== "true") {
+                throw new GitError(`${this.dir} is not a git work tree`);
+            }
+        }
+        catch (err) {
+            if (err instanceof GitError) {
+                throw new GitError(`'${this.dir}' is not a git repository. Point --repo / AUTO_REVIEW_REPO at the ` +
+                    `project the developer agent is editing (it must be a git repo).`, err.stderr);
+            }
+            throw err;
+        }
+    }
+    /** Current HEAD sha, or null if the repo has no commits yet. */
+    async head() {
+        try {
+            const { stdout } = await this.git(["rev-parse", "HEAD"]);
+            return stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Stage everything (`git add -A`) and capture the full diff vs HEAD, including
+     * new and deleted files. Staging means a later commit captures exactly what
+     * was reviewed.
+     */
+    async captureDiff(maxBytes) {
+        await this.git(["add", "-A"]);
+        const { stdout: stat } = await this.git(["diff", "--cached", "--stat"]);
+        const { stdout: fullDiff } = await this.git(["diff", "--cached"]);
+        const fullBytes = Buffer.byteLength(fullDiff, "utf8");
+        const isEmpty = fullDiff.trim() === "";
+        const diffHash = createHash("sha1").update(fullDiff).digest("hex");
+        let diff = fullDiff;
+        let truncated = false;
+        if (fullBytes > maxBytes) {
+            truncated = true;
+            diff =
+                fullDiff.slice(0, maxBytes) +
+                    `\n\n... [diff truncated: ${fullBytes} bytes total, showing first ${maxBytes}. ` +
+                    `See the --stat summary above for the full file list and inspect the working tree directly if needed.]`;
+        }
+        return { diff, diffStat: stat.trim(), diffHash, isEmpty, truncated, fullBytes };
+    }
+    /**
+     * Commit the currently-staged changes with `message` plus a Reviewed-by
+     * trailer. Returns the new commit sha. Throws GitError on failure (e.g. a
+     * pre-commit hook rejected the change) so the caller can keep the batch open.
+     */
+    async commit(message) {
+        await this.git(["commit", "-m", message, "--trailer", "Reviewed-by: auto-review"]);
+        const sha = await this.head();
+        if (!sha)
+            throw new GitError("commit appeared to succeed but HEAD is still unset");
+        return sha;
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/git.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"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"}